var shadow$provide = {};
var CLOSURE_NO_DEPS = true;
var CLOSURE_BASE_PATH = '/js/cljs-runtime/';
var CLOSURE_DEFINES = {"shadow.cljs.devtools.client.env.repl_pprint":false,"shadow.cljs.devtools.client.env.reload_strategy":"optimized","shadow.cljs.devtools.client.env.devtools_url":"","shadow.cljs.devtools.client.env.autoload":true,"shadow.cljs.devtools.client.env.proc_id":"9eb08624-721a-4b99-9525-fad9c7b3eae3","shadow.cljs.devtools.client.env.use_document_protocol":false,"goog.ENABLE_DEBUG_LOADER":false,"shadow.cljs.devtools.client.env.server_port":9630,"shadow.cljs.devtools.client.env.server_token":"6096f7d3-3614-47d6-81ae-ec1a7c0685db","shadow.cljs.devtools.client.env.use_document_host":true,"shadow.cljs.devtools.client.env.module_format":"goog","goog.LOCALE":"en","shadow.cljs.devtools.client.env.build_id":"game","shadow.cljs.devtools.client.env.ignore_warnings":false,"goog.DEBUG":true,"shadow.cljs.devtools.client.env.log":true,"shadow.cljs.devtools.client.env.ssl":false,"shadow.cljs.devtools.client.env.enabled":true,"shadow.cljs.devtools.client.env.server_host":"localhost","shadow.cljs.devtools.client.env.worker_client_id":2,"goog.TRANSPILE":"never"};
var COMPILED = false;
var goog = goog || {};
goog.global = this || self;
goog.global.CLOSURE_UNCOMPILED_DEFINES;
goog.global.CLOSURE_DEFINES;
goog.exportPath_ = function(name, object, overwriteImplicit, objectToExportTo) {
  var parts = name.split(".");
  var cur = objectToExportTo || goog.global;
  if (!(parts[0] in cur) && typeof cur.execScript != "undefined") {
    cur.execScript("var " + parts[0]);
  }
  var part;
  for (; parts.length && (part = parts.shift());) {
    if (!parts.length && object !== undefined) {
      if (!overwriteImplicit && goog.isObject(object) && goog.isObject(cur[part])) {
        var prop;
        for (prop in object) {
          if (object.hasOwnProperty(prop)) {
            cur[part][prop] = object[prop];
          }
        }
      } else {
        cur[part] = object;
      }
    } else if (cur[part] && cur[part] !== Object.prototype[part]) {
      cur = cur[part];
    } else {
      cur = cur[part] = {};
    }
  }
};
goog.define = function(name, defaultValue) {
  var value = defaultValue;
  if (!COMPILED) {
    var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;
    var defines = goog.global.CLOSURE_DEFINES;
    if (uncompiledDefines && uncompiledDefines.nodeType === undefined && Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {
      value = uncompiledDefines[name];
    } else if (defines && defines.nodeType === undefined && Object.prototype.hasOwnProperty.call(defines, name)) {
      value = defines[name];
    }
  }
  return value;
};
goog.FEATURESET_YEAR = goog.define("goog.FEATURESET_YEAR", 2012);
goog.DEBUG = goog.define("goog.DEBUG", true);
goog.LOCALE = goog.define("goog.LOCALE", "en");
goog.TRUSTED_SITE = goog.define("goog.TRUSTED_SITE", true);
goog.DISALLOW_TEST_ONLY_CODE = goog.define("goog.DISALLOW_TEST_ONLY_CODE", COMPILED && !goog.DEBUG);
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING = goog.define("goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING", false);
goog.provide = function(name) {
  if (goog.isInModuleLoader_()) {
    throw new Error("goog.provide cannot be used within a module.");
  }
  if (!COMPILED) {
    if (goog.isProvided_(name)) {
      throw new Error('Namespace "' + name + '" already declared.');
    }
  }
  goog.constructNamespace_(name);
};
goog.constructNamespace_ = function(name, object, overwriteImplicit) {
  if (!COMPILED) {
    delete goog.implicitNamespaces_[name];
    var namespace = name;
    for (; namespace = namespace.substring(0, namespace.lastIndexOf("."));) {
      if (goog.getObjectByName(namespace)) {
        break;
      }
      goog.implicitNamespaces_[namespace] = true;
    }
  }
  goog.exportPath_(name, object, overwriteImplicit);
};
goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;
goog.getScriptNonce_ = function(opt_window) {
  var doc = (opt_window || goog.global).document;
  var script = doc.querySelector && doc.querySelector("script[nonce]");
  if (script) {
    var nonce = script["nonce"] || script.getAttribute("nonce");
    if (nonce && goog.NONCE_PATTERN_.test(nonce)) {
      return nonce;
    }
  }
  return "";
};
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module = function(name) {
  if (typeof name !== "string" || !name || name.search(goog.VALID_MODULE_RE_) == -1) {
    throw new Error("Invalid module identifier");
  }
  if (!goog.isInGoogModuleLoader_()) {
    throw new Error("Module " + name + " has been loaded incorrectly. Note, " + "modules cannot be loaded as normal scripts. They require some kind of " + "pre-processing step. You're likely trying to load a module via a " + "script tag or as a part of a concatenated bundle without rewriting the " + "module. For more info see: " + "https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");
  }
  if (goog.moduleLoaderState_.moduleName) {
    throw new Error("goog.module may only be called once per module.");
  }
  goog.moduleLoaderState_.moduleName = name;
  if (!COMPILED) {
    if (goog.isProvided_(name)) {
      throw new 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 (name in goog.loadedModules_) {
      return goog.loadedModules_[name].exports;
    } else if (!goog.implicitNamespaces_[name]) {
      var ns = goog.getObjectByName(name);
      return ns != null ? ns : null;
    }
  }
  return null;
};
goog.ModuleType = {ES6:"es6", GOOG:"goog"};
goog.moduleLoaderState_ = null;
goog.isInModuleLoader_ = function() {
  return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
};
goog.isInGoogModuleLoader_ = function() {
  return !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.GOOG;
};
goog.isInEs6ModuleLoader_ = function() {
  var inLoader = !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.ES6;
  if (inLoader) {
    return true;
  }
  var jscomp = goog.global["$jscomp"];
  if (jscomp) {
    if (typeof jscomp.getCurrentModulePath != "function") {
      return false;
    }
    return !!jscomp.getCurrentModulePath();
  }
  return false;
};
goog.module.declareLegacyNamespace = function() {
  if (!COMPILED && !goog.isInGoogModuleLoader_()) {
    throw new Error("goog.module.declareLegacyNamespace must be called from " + "within a goog.module");
  }
  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
    throw new Error("goog.module must be called prior to " + "goog.module.declareLegacyNamespace.");
  }
  goog.moduleLoaderState_.declareLegacyNamespace = true;
};
goog.declareModuleId = function(namespace) {
  if (!COMPILED) {
    if (!goog.isInEs6ModuleLoader_()) {
      throw new Error("goog.declareModuleId may only be called from " + "within an ES6 module");
    }
    if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {
      throw new Error("goog.declareModuleId may only be called once per module.");
    }
    if (namespace in goog.loadedModules_) {
      throw new Error('Module with namespace "' + namespace + '" already exists.');
    }
  }
  if (goog.moduleLoaderState_) {
    goog.moduleLoaderState_.moduleName = namespace;
  } else {
    var jscomp = goog.global["$jscomp"];
    if (!jscomp || typeof jscomp.getCurrentModulePath != "function") {
      throw new Error('Module with namespace "' + namespace + '" has been loaded incorrectly.');
    }
    var exports = jscomp.require(jscomp.getCurrentModulePath());
    goog.loadedModules_[namespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:namespace};
  }
};
goog.setTestOnly = function(opt_message) {
  if (goog.DISALLOW_TEST_ONLY_CODE) {
    opt_message = opt_message || "";
    throw new 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.getObjectByName(name) != null;
  };
  goog.implicitNamespaces_ = {"goog.module":true};
}
goog.getObjectByName = function(name, opt_obj) {
  var parts = name.split(".");
  var cur = opt_obj || goog.global;
  var i = 0;
  for (; i < parts.length; i++) {
    cur = cur[parts[i]];
    if (cur == null) {
      return null;
    }
  }
  return cur;
};
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
  if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
    goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);
  }
};
goog.ENABLE_DEBUG_LOADER = goog.define("goog.ENABLE_DEBUG_LOADER", true);
goog.logToConsole_ = function(msg) {
  if (goog.global.console) {
    goog.global.console["error"](msg);
  }
};
goog.require = function(namespace) {
  if (!COMPILED) {
    if (goog.ENABLE_DEBUG_LOADER) {
      goog.debugLoader_.requested(namespace);
    }
    if (goog.isProvided_(namespace)) {
      if (goog.isInModuleLoader_()) {
        return goog.module.getInternal_(namespace);
      }
    } else if (goog.ENABLE_DEBUG_LOADER) {
      var moduleLoaderState = goog.moduleLoaderState_;
      goog.moduleLoaderState_ = null;
      try {
        goog.debugLoader_.load_(namespace);
      } finally {
        goog.moduleLoaderState_ = moduleLoaderState;
      }
    }
    return null;
  }
};
goog.requireType = function(namespace) {
  return {};
};
goog.basePath = "";
goog.global.CLOSURE_BASE_PATH;
goog.global.CLOSURE_NO_DEPS;
goog.global.CLOSURE_IMPORT_SCRIPT;
goog.abstractMethod = function() {
  throw new Error("unimplemented abstract method");
};
goog.addSingletonGetter = function(ctor) {
  ctor.instance_ = undefined;
  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.LOAD_MODULE_USING_EVAL = goog.define("goog.LOAD_MODULE_USING_EVAL", true);
goog.SEAL_MODULE_EXPORTS = goog.define("goog.SEAL_MODULE_EXPORTS", goog.DEBUG);
goog.loadedModules_ = {};
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
goog.TRANSPILE = goog.define("goog.TRANSPILE", "detect");
goog.ASSUME_ES_MODULES_TRANSPILED = goog.define("goog.ASSUME_ES_MODULES_TRANSPILED", false);
goog.TRUSTED_TYPES_POLICY_NAME = goog.define("goog.TRUSTED_TYPES_POLICY_NAME", "goog");
goog.hasBadLetScoping = null;
goog.loadModule = function(moduleDef) {
  var previousState = goog.moduleLoaderState_;
  try {
    goog.moduleLoaderState_ = {moduleName:"", declareLegacyNamespace:false, type:goog.ModuleType.GOOG};
    var origExports = {};
    var exports = origExports;
    if (typeof moduleDef === "function") {
      exports = moduleDef.call(undefined, exports);
    } else if (typeof moduleDef === "string") {
      exports = goog.loadModuleFromSource_.call(undefined, exports, moduleDef);
    } else {
      throw new Error("Invalid module definition");
    }
    var moduleName = goog.moduleLoaderState_.moduleName;
    if (typeof moduleName === "string" && moduleName) {
      if (goog.moduleLoaderState_.declareLegacyNamespace) {
        var isDefaultExport = origExports !== exports;
        goog.constructNamespace_(moduleName, exports, isDefaultExport);
      } else if (goog.SEAL_MODULE_EXPORTS && Object.seal && typeof exports == "object" && exports != null) {
        Object.seal(exports);
      }
      var data = {exports:exports, type:goog.ModuleType.GOOG, moduleId:goog.moduleLoaderState_.moduleName};
      goog.loadedModules_[moduleName] = data;
    } else {
      throw new Error('Invalid module name "' + moduleName + '"');
    }
  } finally {
    goog.moduleLoaderState_ = previousState;
  }
};
goog.loadModuleFromSource_ = function(exports) {
  eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(arguments[1]));
  return exports;
};
goog.normalizePath_ = function(path) {
  var components = path.split("/");
  var i = 0;
  for (; 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.global.CLOSURE_LOAD_FILE_SYNC;
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.typeOf = function(value) {
  var s = typeof value;
  if (s != "object") {
    return s;
  }
  if (!value) {
    return "null";
  }
  if (Array.isArray(value)) {
    return "array";
  }
  return s;
};
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.isObject = function(val) {
  var type = typeof val;
  return type == "object" && val != null || type == "function";
};
goog.getUid = function(obj) {
  return Object.prototype.hasOwnProperty.call(obj, goog.UID_PROPERTY_) && 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.cloneObject = function(obj) {
  var type = goog.typeOf(obj);
  if (type == "object" || type == "array") {
    if (typeof obj.clone === "function") {
      return obj.clone();
    }
    if (typeof Map !== "undefined" && obj instanceof Map) {
      return new Map(obj);
    } else if (typeof Set !== "undefined" && obj instanceof Set) {
      return new Set(obj);
    }
    var clone = type == "array" ? [] : {};
    var key;
    for (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.now = function() {
  return Date.now();
};
goog.globalEval = function(script) {
  (0,eval)(script);
};
goog.cssNameMapping_;
goog.cssNameMappingStyle_;
goog.global.CLOSURE_CSS_NAME_MAP_FN;
goog.getCssName = function(className, opt_modifier) {
  if (String(className).charAt(0) == ".") {
    throw new Error('className passed in goog.getCssName must not start with ".".' + " You passed: " + className);
  }
  var getMapping = function(cssName) {
    return goog.cssNameMapping_[cssName] || cssName;
  };
  var renameByParts = function(cssName) {
    var parts = cssName.split("-");
    var mapped = [];
    var i = 0;
    for (; 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;
    };
  }
  var result = opt_modifier ? className + "-" + rename(opt_modifier) : rename(className);
  if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {
    return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);
  }
  return result;
};
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.GetMsgOptions = function() {
};
goog.GetMsgOptions.prototype.html;
goog.GetMsgOptions.prototype.unescapeHtmlEntities;
goog.GetMsgOptions.prototype.original_code;
goog.GetMsgOptions.prototype.example;
goog.getMsg = function(str, opt_values, opt_options) {
  if (opt_options && opt_options.html) {
    str = str.replace(/</g, "\x26lt;");
  }
  if (opt_options && opt_options.unescapeHtmlEntities) {
    str = str.replace(/&lt;/g, "\x3c").replace(/&gt;/g, "\x3e").replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&amp;/g, "\x26");
  }
  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, objectToExportTo) {
  goog.exportPath_(publicPath, object, true, 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);
    var i = 2;
    for (; i < arguments.length; i++) {
      args[i - 2] = arguments[i];
    }
    return parentCtor.prototype[methodName].apply(me, args);
  };
};
goog.scope = function(fn) {
  if (goog.isInModuleLoader_()) {
    throw new Error("goog.scope is not supported within a 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 new 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.defineClass.SEAL_CLASS_INSTANCES = goog.define("goog.defineClass.SEAL_CLASS_INSTANCES", goog.DEBUG);
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
  if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
    return ctr;
  }
  var wrappedCtr = function() {
    var instance = ctr.apply(this, arguments) || this;
    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
    return instance;
  };
  return wrappedCtr;
};
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];
    }
  }
  var i = 0;
  for (; 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.identity_ = function(s) {
  return s;
};
goog.createTrustedTypesPolicy = function(name) {
  var policy = null;
  var policyFactory = goog.global.trustedTypes;
  if (!policyFactory || !policyFactory.createPolicy) {
    return policy;
  }
  try {
    policy = policyFactory.createPolicy(name, {createHTML:goog.identity_, createScript:goog.identity_, createScriptURL:goog.identity_});
  } catch (e) {
    goog.logToConsole_(e.message);
  }
  return policy;
};
if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
  goog.isEdge_ = function() {
    var userAgent = goog.global.navigator && goog.global.navigator.userAgent ? goog.global.navigator.userAgent : "";
    var edgeRe = /Edge\/(\d+)(\.\d)*/i;
    return !!userAgent.match(edgeRe);
  };
  goog.inHtmlDocument_ = function() {
    var doc = goog.global.document;
    return doc != null && "write" in doc;
  };
  goog.isDocumentLoading_ = function() {
    var doc = goog.global.document;
    return doc.attachEvent ? doc.readyState != "complete" : doc.readyState == "loading";
  };
  goog.findBasePath_ = function() {
    if (goog.global.CLOSURE_BASE_PATH != undefined && typeof goog.global.CLOSURE_BASE_PATH === "string") {
      goog.basePath = goog.global.CLOSURE_BASE_PATH;
      return;
    } else if (!goog.inHtmlDocument_()) {
      return;
    }
    var doc = goog.global.document;
    var currentScript = doc.currentScript;
    if (currentScript) {
      var scripts = [currentScript];
    } else {
      scripts = doc.getElementsByTagName("SCRIPT");
    }
    var i = scripts.length - 1;
    for (; i >= 0; --i) {
      var script = scripts[i];
      var src = script.src;
      var qmark = src.lastIndexOf("?");
      var l = qmark == -1 ? src.length : qmark;
      if (src.slice(l - 7, l) == "base.js") {
        goog.basePath = src.slice(0, l - 7);
        return;
      }
    }
  };
  goog.findBasePath_();
  goog.protectScriptTag_ = function(str) {
    return str.replace(/<\/(SCRIPT)/ig, "\\x3c/$1");
  };
  goog.DebugLoader_ = function() {
    this.dependencies_ = {};
    this.idToPath_ = {};
    this.written_ = {};
    this.loadingDeps_ = [];
    this.depsToLoad_ = [];
    this.paused_ = false;
    this.factory_ = new goog.DependencyFactory();
    this.deferredCallbacks_ = {};
    this.deferredQueue_ = [];
  };
  goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
    function resolve() {
      if (cb) {
        goog.global.setTimeout(cb, 0);
        cb = null;
      }
    }
    var cb = callback;
    if (!namespaces.length) {
      resolve();
      return;
    }
    var deps = [];
    var i = 0;
    for (; i < namespaces.length; i++) {
      var path = this.getPathFromDeps_(namespaces[i]);
      if (!path) {
        throw new Error("Unregonized namespace: " + namespaces[i]);
      }
      deps.push(this.dependencies_[path]);
    }
    var require = goog.require;
    var loaded = 0;
    i = 0;
    for (; i < namespaces.length; i++) {
      require(namespaces[i]);
      deps[i].onLoad(function() {
        if (++loaded == namespaces.length) {
          resolve();
        }
      });
    }
  };
  goog.DebugLoader_.prototype.loadClosureDeps = function() {
    var relPath = "deps.js";
    this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}));
    this.loadDeps_();
  };
  goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
    var path = this.getPathFromDeps_(absPathOrId);
    if (path && (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
      var callback = this.deferredCallbacks_[path];
      if (callback) {
        delete this.deferredCallbacks_[path];
        callback();
      }
    }
  };
  goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
    this.factory_ = factory;
  };
  goog.DebugLoader_.prototype.load_ = function(namespace) {
    if (!this.getPathFromDeps_(namespace)) {
      var errorMessage = "goog.require could not find: " + namespace;
      goog.logToConsole_(errorMessage);
    } else {
      var loader = this;
      var deps = [];
      var visit = function(namespace) {
        var path = loader.getPathFromDeps_(namespace);
        if (!path) {
          throw new Error("Bad dependency path or symbol: " + namespace);
        }
        if (loader.written_[path]) {
          return;
        }
        loader.written_[path] = true;
        var dep = loader.dependencies_[path];
        var i = 0;
        for (; i < dep.requires.length; i++) {
          if (!goog.isProvided_(dep.requires[i])) {
            visit(dep.requires[i]);
          }
        }
        deps.push(dep);
      };
      visit(namespace);
      var wasLoading = !!this.depsToLoad_.length;
      this.depsToLoad_ = this.depsToLoad_.concat(deps);
      if (!this.paused_ && !wasLoading) {
        this.loadDeps_();
      }
    }
  };
  goog.DebugLoader_.prototype.loadDeps_ = function() {
    var loader = this;
    var paused = this.paused_;
    for (; this.depsToLoad_.length && !paused;) {
      (function() {
        var loadCallDone = false;
        var dep = loader.depsToLoad_.shift();
        var loaded = false;
        loader.loading_(dep);
        var controller = {pause:function() {
          if (loadCallDone) {
            throw new Error("Cannot call pause after the call to load.");
          } else {
            paused = true;
          }
        }, resume:function() {
          if (loadCallDone) {
            loader.resume_();
          } else {
            paused = false;
          }
        }, loaded:function() {
          if (loaded) {
            throw new Error("Double call to loaded.");
          }
          loaded = true;
          loader.loaded_(dep);
        }, pending:function() {
          var pending = [];
          var i = 0;
          for (; i < loader.loadingDeps_.length; i++) {
            pending.push(loader.loadingDeps_[i]);
          }
          return pending;
        }, setModuleState:function(type) {
          goog.moduleLoaderState_ = {type:type, moduleName:"", declareLegacyNamespace:false};
        }, registerEs6ModuleExports:function(path, exports, opt_closureNamespace) {
          if (opt_closureNamespace) {
            goog.loadedModules_[opt_closureNamespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:opt_closureNamespace || ""};
          }
        }, registerGoogModuleExports:function(moduleId, exports) {
          goog.loadedModules_[moduleId] = {exports:exports, type:goog.ModuleType.GOOG, moduleId:moduleId};
        }, clearModuleState:function() {
          goog.moduleLoaderState_ = null;
        }, defer:function(callback) {
          if (loadCallDone) {
            throw new Error("Cannot register with defer after the call to load.");
          }
          loader.defer_(dep, callback);
        }, areDepsLoaded:function() {
          return loader.areDepsLoaded_(dep.requires);
        }};
        try {
          dep.load(controller);
        } finally {
          loadCallDone = true;
        }
      })();
    }
    if (paused) {
      this.pause_();
    }
  };
  goog.DebugLoader_.prototype.pause_ = function() {
    this.paused_ = true;
  };
  goog.DebugLoader_.prototype.resume_ = function() {
    if (this.paused_) {
      this.paused_ = false;
      this.loadDeps_();
    }
  };
  goog.DebugLoader_.prototype.loading_ = function(dep) {
    this.loadingDeps_.push(dep);
  };
  goog.DebugLoader_.prototype.loaded_ = function(dep) {
    var i = 0;
    for (; i < this.loadingDeps_.length; i++) {
      if (this.loadingDeps_[i] == dep) {
        this.loadingDeps_.splice(i, 1);
        break;
      }
    }
    i = 0;
    for (; i < this.deferredQueue_.length; i++) {
      if (this.deferredQueue_[i] == dep.path) {
        this.deferredQueue_.splice(i, 1);
        break;
      }
    }
    if (this.loadingDeps_.length == this.deferredQueue_.length && !this.depsToLoad_.length) {
      for (; this.deferredQueue_.length;) {
        this.requested(this.deferredQueue_.shift(), true);
      }
    }
    dep.loaded();
  };
  goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
    var i = 0;
    for (; i < pathsOrIds.length; i++) {
      var path = this.getPathFromDeps_(pathsOrIds[i]);
      if (!path || !(path in this.deferredCallbacks_) && !goog.isProvided_(pathsOrIds[i])) {
        return false;
      }
    }
    return true;
  };
  goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
    if (absPathOrId in this.idToPath_) {
      return this.idToPath_[absPathOrId];
    } else if (absPathOrId in this.dependencies_) {
      return absPathOrId;
    } else {
      return null;
    }
  };
  goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
    this.deferredCallbacks_[dependency.path] = callback;
    this.deferredQueue_.push(dependency.path);
  };
  goog.LoadController = function() {
  };
  goog.LoadController.prototype.pause = function() {
  };
  goog.LoadController.prototype.resume = function() {
  };
  goog.LoadController.prototype.loaded = function() {
  };
  goog.LoadController.prototype.pending = function() {
  };
  goog.LoadController.prototype.registerEs6ModuleExports = function(path, exports, opt_closureNamespace) {
  };
  goog.LoadController.prototype.setModuleState = function(type) {
  };
  goog.LoadController.prototype.clearModuleState = function() {
  };
  goog.LoadController.prototype.defer = function(callback) {
  };
  goog.LoadController.prototype.areDepsLoaded = function() {
  };
  goog.Dependency = function(path, relativePath, provides, requires, loadFlags) {
    this.path = path;
    this.relativePath = relativePath;
    this.provides = provides;
    this.requires = requires;
    this.loadFlags = loadFlags;
    this.loaded_ = false;
    this.loadCallbacks_ = [];
  };
  goog.Dependency.prototype.getPathName = function() {
    var pathName = this.path;
    var protocolIndex = pathName.indexOf("://");
    if (protocolIndex >= 0) {
      pathName = pathName.substring(protocolIndex + 3);
      var slashIndex = pathName.indexOf("/");
      if (slashIndex >= 0) {
        pathName = pathName.substring(slashIndex + 1);
      }
    }
    return pathName;
  };
  goog.Dependency.prototype.onLoad = function(callback) {
    if (this.loaded_) {
      callback();
    } else {
      this.loadCallbacks_.push(callback);
    }
  };
  goog.Dependency.prototype.loaded = function() {
    this.loaded_ = true;
    var callbacks = this.loadCallbacks_;
    this.loadCallbacks_ = [];
    var i = 0;
    for (; i < callbacks.length; i++) {
      callbacks[i]();
    }
  };
  goog.Dependency.defer_ = false;
  goog.Dependency.callbackMap_ = {};
  goog.Dependency.registerCallback_ = function(callback) {
    var key = Math.random().toString(32);
    goog.Dependency.callbackMap_[key] = callback;
    return key;
  };
  goog.Dependency.unregisterCallback_ = function(key) {
    delete goog.Dependency.callbackMap_[key];
  };
  goog.Dependency.callback_ = function(key, var_args) {
    if (key in goog.Dependency.callbackMap_) {
      var callback = goog.Dependency.callbackMap_[key];
      var args = [];
      var i = 1;
      for (; i < arguments.length; i++) {
        args.push(arguments[i]);
      }
      callback.apply(undefined, args);
    } else {
      var errorMessage = "Callback key " + key + " does not exist (was base.js loaded more than once?).";
      throw Error(errorMessage);
    }
  };
  goog.Dependency.prototype.load = function(controller) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }
    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_("Cannot use default debug loader outside of HTML documents.");
      if (this.relativePath == "deps.js") {
        goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, " + "or setting CLOSURE_NO_DEPS to true.");
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }
    var doc = goog.global.document;
    if (doc.readyState == "complete" && !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
      var isDeps = /\bdeps.js$/.test(this.path);
      if (isDeps) {
        controller.loaded();
        return;
      } else {
        throw Error('Cannot write "' + this.path + '" after document load');
      }
    }
    var nonce = goog.getScriptNonce_();
    if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING && goog.isDocumentLoading_()) {
      var key;
      var callback = function(script) {
        if (script.readyState && script.readyState != "complete") {
          script.onload = callback;
          return;
        }
        goog.Dependency.unregisterCallback_(key);
        controller.loaded();
      };
      key = goog.Dependency.registerCallback_(callback);
      var defer = goog.Dependency.defer_ ? " defer" : "";
      var nonceAttr = nonce ? ' nonce\x3d"' + nonce + '"' : "";
      var script = '\x3cscript src\x3d"' + this.path + '"' + nonceAttr + defer + ' id\x3d"script-' + key + '"\x3e\x3c/script\x3e';
      script = script + ("\x3cscript" + nonceAttr + "\x3e");
      if (goog.Dependency.defer_) {
        script = script + ("document.getElementById('script-" + key + "').onload \x3d function() {\n" + "  goog.Dependency.callback_('" + key + "', this);\n" + "};\n");
      } else {
        script = script + ("goog.Dependency.callback_('" + key + "', document.getElementById('script-" + key + "'));");
      }
      script = script + "\x3c/script\x3e";
      doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
    } else {
      var scriptEl = doc.createElement("script");
      scriptEl.defer = goog.Dependency.defer_;
      scriptEl.async = false;
      if (nonce) {
        scriptEl.nonce = nonce;
      }
      scriptEl.onload = function() {
        scriptEl.onload = null;
        controller.loaded();
      };
      scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) : this.path;
      doc.head.appendChild(scriptEl);
    }
  };
  goog.Es6ModuleDependency = function(path, relativePath, provides, requires, loadFlags) {
    goog.Es6ModuleDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(goog.Es6ModuleDependency, goog.Dependency);
  goog.Es6ModuleDependency.prototype.load = function(controller) {
    function write(src, contents) {
      var nonceAttr = "";
      var nonce = goog.getScriptNonce_();
      if (nonce) {
        nonceAttr = ' nonce\x3d"' + nonce + '"';
      }
      if (contents) {
        var script = '\x3cscript type\x3d"module" crossorigin' + nonceAttr + "\x3e" + contents + "\x3c/" + "script\x3e";
        doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
      } else {
        script = '\x3cscript type\x3d"module" crossorigin src\x3d"' + src + '"' + nonceAttr + "\x3e\x3c/" + "script\x3e";
        doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
      }
    }
    function append(src, contents) {
      var scriptEl = doc.createElement("script");
      scriptEl.defer = true;
      scriptEl.async = false;
      scriptEl.type = "module";
      scriptEl.setAttribute("crossorigin", true);
      var nonce = goog.getScriptNonce_();
      if (nonce) {
        scriptEl.nonce = nonce;
      }
      if (contents) {
        scriptEl.text = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScript(contents) : contents;
      } else {
        scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) : src;
      }
      doc.head.appendChild(scriptEl);
    }
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }
    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_("Cannot use default debug loader outside of HTML documents.");
      controller.pause();
      return;
    }
    var doc = goog.global.document;
    var dep = this;
    var create;
    if (goog.isDocumentLoading_()) {
      create = write;
      goog.Dependency.defer_ = true;
    } else {
      create = append;
    }
    var beforeKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(beforeKey);
      controller.setModuleState(goog.ModuleType.ES6);
    });
    create(undefined, 'goog.Dependency.callback_("' + beforeKey + '")');
    create(this.path, undefined);
    var registerKey = goog.Dependency.registerCallback_(function(exports) {
      goog.Dependency.unregisterCallback_(registerKey);
      controller.registerEs6ModuleExports(dep.path, exports, goog.moduleLoaderState_.moduleName);
    });
    create(undefined, 'import * as m from "' + this.path + '"; goog.Dependency.callback_("' + registerKey + '", m)');
    var afterKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(afterKey);
      controller.clearModuleState();
      controller.loaded();
    });
    create(undefined, 'goog.Dependency.callback_("' + afterKey + '")');
  };
  goog.TransformedDependency = function(path, relativePath, provides, requires, loadFlags) {
    goog.TransformedDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
    this.contents_ = null;
    this.lazyFetch_ = !goog.inHtmlDocument_() || !("noModule" in goog.global.document.createElement("script"));
  };
  goog.inherits(goog.TransformedDependency, goog.Dependency);
  goog.TransformedDependency.prototype.load = function(controller) {
    function fetch() {
      dep.contents_ = goog.loadFileSync_(dep.path);
      if (dep.contents_) {
        dep.contents_ = dep.transform(dep.contents_);
        if (dep.contents_) {
          dep.contents_ += "\n//# sourceURL\x3d" + dep.path;
        }
      }
    }
    function load() {
      if (dep.lazyFetch_) {
        fetch();
      }
      if (!dep.contents_) {
        return;
      }
      if (isEs6) {
        controller.setModuleState(goog.ModuleType.ES6);
      }
      var namespace;
      try {
        var contents = dep.contents_;
        dep.contents_ = null;
        goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(contents));
        if (isEs6) {
          namespace = goog.moduleLoaderState_.moduleName;
        }
      } finally {
        if (isEs6) {
          controller.clearModuleState();
        }
      }
      if (isEs6) {
        goog.global["$jscomp"]["require"]["ensure"]([dep.getPathName()], function() {
          controller.registerEs6ModuleExports(dep.path, goog.global["$jscomp"]["require"](dep.getPathName()), namespace);
        });
      }
      controller.loaded();
    }
    function fetchInOwnScriptThenLoad() {
      var doc = goog.global.document;
      var key = goog.Dependency.registerCallback_(function() {
        goog.Dependency.unregisterCallback_(key);
        load();
      });
      var nonce = goog.getScriptNonce_();
      var nonceAttr = nonce ? ' nonce\x3d"' + nonce + '"' : "";
      var script = "\x3cscript" + nonceAttr + "\x3e" + goog.protectScriptTag_('goog.Dependency.callback_("' + key + '");') + "\x3c/" + "script\x3e";
      doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
    }
    var dep = this;
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      fetch();
      if (this.contents_ && goog.global.CLOSURE_IMPORT_SCRIPT("", this.contents_)) {
        this.contents_ = null;
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }
    var isEs6 = this.loadFlags["module"] == goog.ModuleType.ES6;
    if (!this.lazyFetch_) {
      fetch();
    }
    var anythingElsePending = controller.pending().length > 1;
    var needsAsyncLoading = goog.Dependency.defer_ && (anythingElsePending || goog.isDocumentLoading_());
    if (needsAsyncLoading) {
      controller.defer(function() {
        load();
      });
      return;
    }
    var doc = goog.global.document;
    var isInternetExplorerOrEdge = goog.inHtmlDocument_() && ("ActiveXObject" in goog.global || goog.isEdge_());
    if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() && !isInternetExplorerOrEdge) {
      goog.Dependency.defer_ = true;
      controller.pause();
      var oldCallback = doc.onreadystatechange;
      doc.onreadystatechange = function() {
        if (doc.readyState == "interactive") {
          doc.onreadystatechange = oldCallback;
          load();
          controller.resume();
        }
        if (typeof oldCallback === "function") {
          oldCallback.apply(undefined, arguments);
        }
      };
    } else {
      if (!goog.inHtmlDocument_() || !goog.isDocumentLoading_()) {
        load();
      } else {
        fetchInOwnScriptThenLoad();
      }
    }
  };
  goog.TransformedDependency.prototype.transform = function(contents) {
  };
  goog.PreTranspiledEs6ModuleDependency = function(path, relativePath, provides, requires, loadFlags) {
    goog.PreTranspiledEs6ModuleDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);
  goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(contents) {
    return contents;
  };
  goog.GoogModuleDependency = function(path, relativePath, provides, requires, loadFlags) {
    goog.GoogModuleDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);
  goog.GoogModuleDependency.prototype.transform = function(contents) {
    if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {
      return "" + "goog.loadModule(function(exports) {" + '"use strict";' + contents + "\n" + ";return exports" + "});" + "\n//# sourceURL\x3d" + this.path + "\n";
    } else {
      return "" + "goog.loadModule(" + goog.global.JSON.stringify(contents + "\n//# sourceURL\x3d" + this.path + "\n") + ");";
    }
  };
  goog.DebugLoader_.prototype.addDependency = function(relPath, provides, requires, opt_loadFlags) {
    provides = provides || [];
    relPath = relPath.replace(/\\/g, "/");
    var path = goog.normalizePath_(goog.basePath + relPath);
    if (!opt_loadFlags || typeof opt_loadFlags === "boolean") {
      opt_loadFlags = opt_loadFlags ? {"module":goog.ModuleType.GOOG} : {};
    }
    var dep = this.factory_.createDependency(path, relPath, provides, requires, opt_loadFlags);
    this.dependencies_[path] = dep;
    var i = 0;
    for (; i < provides.length; i++) {
      this.idToPath_[provides[i]] = path;
    }
    this.idToPath_[relPath] = path;
  };
  goog.DependencyFactory = function() {
  };
  goog.DependencyFactory.prototype.createDependency = function(path, relativePath, provides, requires, loadFlags) {
    if (loadFlags["module"] == goog.ModuleType.GOOG) {
      return new goog.GoogModuleDependency(path, relativePath, provides, requires, loadFlags);
    } else {
      if (loadFlags["module"] == goog.ModuleType.ES6) {
        if (goog.ASSUME_ES_MODULES_TRANSPILED) {
          return new goog.PreTranspiledEs6ModuleDependency(path, relativePath, provides, requires, loadFlags);
        } else {
          return new goog.Es6ModuleDependency(path, relativePath, provides, requires, loadFlags);
        }
      } else {
        return new goog.Dependency(path, relativePath, provides, requires, loadFlags);
      }
    }
  };
  goog.debugLoader_ = new goog.DebugLoader_();
  goog.loadClosureDeps = function() {
    goog.debugLoader_.loadClosureDeps();
  };
  goog.setDependencyFactory = function(factory) {
    goog.debugLoader_.setDependencyFactory(factory);
  };
  goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ? goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + "#base") : null;
  if (!goog.global.CLOSURE_NO_DEPS) {
    goog.debugLoader_.loadClosureDeps();
  }
  goog.bootstrap = function(namespaces, callback) {
    goog.debugLoader_.bootstrap(namespaces, callback);
  };
}
if (!COMPILED) {
  var isChrome87 = false;
  try {
    isChrome87 = eval(goog.global.trustedTypes.emptyScript) !== goog.global.trustedTypes.emptyScript;
  } catch (err) {
  }
  goog.CLOSURE_EVAL_PREFILTER_ = goog.global.trustedTypes && isChrome87 && goog.createTrustedTypesPolicy("goog#base#devonly#eval") || {createScript:goog.identity_};
}

var SHADOW_ENV = function() {
  var env = {};

  var loadedFiles = env.loadedFiles = {};

  var doc = goog.global.document;

  if (!doc) {
    throw new Error("browser bootstrap used in incorrect target");
  }

  var scriptBase = goog.global.window.location.origin;
  if (CLOSURE_BASE_PATH[0] == '/') {
    scriptBase = scriptBase + CLOSURE_BASE_PATH;
  } else {
    // FIXME: need to handle relative paths
    scriptBase = CLOSURE_BASE_PATH;
  }


  env.scriptBase = scriptBase;

  var wentAsync = false;

  var canDocumentWrite = function() {
    return !wentAsync && doc.readyState == "loading";
  };

  var reportError = function(path, e) {
    // chrome displays e.stack in a usable way while firefox is just a garbled mess
    if (e.constructor.toString().indexOf("function cljs$core$ExceptionInfo") === 0 && navigator.appVersion.indexOf("Chrome") != -1) {
      console.error(e);
      console.error(e.stack);
    } else {
      console.error(e);
    }
    console.warn("The above error occurred when loading \"" + path + "\". Any additional errors after that one may be the result of that failure. In general your code cannot be trusted to execute properly after such a failure. Make sure to fix the first one before looking at others.");
  };

  var asyncLoad = (function() {
    var loadOrder = [];
    var loadState = {};

    function loadPending() {
      for (var i = 0, len = loadOrder.length; i < len; i++) {
        var uri = loadOrder[i];
        var state = loadState[uri];

        if (typeof state === "string") {
          loadState[uri] = true;
          if (state != "") {
            var code = state + "\n//# sourceURL=" + uri + "\n";
            try {
              goog.globalEval(code);
            } catch (e) {
              reportError(uri, e);
            }
          }
        } else if (state === true) {
          continue;
        } else {
          break;
        }
      }
    }

    // ie11 doesn't have fetch, use xhr instead
    // FIXME: not sure if fetch provides any benefit over xhr
    if (typeof window.fetch === "undefined") {
      return function asyncXhr(uri) {
        loadOrder.push(uri);
        loadState[uri] = false;
        var req = new XMLHttpRequest();
        req.onload = function(e) {
          loadState[uri] = req.responseText;
          loadPending();
        };
        req.open("GET", uri);
        req.send();
      }
    } else {
      function responseText(response) {
        // FIXME: check status
        return response.text();
      }

      function evalFetch(uri) {
        return function(code) {
          loadState[uri] = code;
          loadPending();
        };
      }

      return function asyncFetch(uri) {
        if (loadState[uri] == undefined) {
          loadState[uri] = false;
          loadOrder.push(uri);
          fetch(uri)
            .then(responseText)
            .then(evalFetch(uri));
        }
      };
    }
  })();

  env.load = function(opts, paths) {
    var docWrite = opts.forceAsync ? false : canDocumentWrite();

    paths.forEach(function(path) {
      if (!loadedFiles[path]) {
        loadedFiles[path] = true;

        var uri = scriptBase + path;

        if (docWrite) {
          document.write(
            "<script src='" + uri + "' type='text/javascript'></script>"
          );
        } else {
          // once async always async
          wentAsync = true;
          asyncLoad(uri);
        }
      }
    });
  };

  env.isLoaded = function(path) {
    return loadedFiles[path] || false; // false is better than undefined
  };

  env.setLoaded = function(path) {
    loadedFiles[path] = true;
  };

  env.evalLoad = function(path, sourceMap, code) {
    loadedFiles[path] = true;
    code += ("\n//# sourceURL=" + scriptBase + path);
    if (sourceMap) {
      code += ("\n//# sourceMappingURL=" + path + ".map");
    }
    try {
      goog.globalEval(code);
    } catch (e) {
      reportError(path, e);
    }
  }

  return env;
}.call(this);


goog.global["$CLJS"] = goog.global;



SHADOW_ENV.evalLoad("goog.debug.error.js", true, "goog.loadModule(function(exports) {\n  function DebugError(msg \x3d undefined, cause \x3d undefined) {\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, DebugError);\n    } else {\n      const stack \x3d (new Error()).stack;\n      if (stack) {\n        this.stack \x3d stack;\n      }\n    }\n    if (msg) {\n      this.message \x3d String(msg);\n    }\n    if (cause !\x3d\x3d undefined) {\n      this.cause \x3d cause;\n    }\n    this.reportErrorToServer \x3d true;\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.debug.Error\x22);\n  goog.module.declareLegacyNamespace();\n  goog.inherits(DebugError, Error);\n  DebugError.prototype.name \x3d \x22CustomError\x22;\n  exports \x3d DebugError;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.dom.nodetype.js", true, "goog.provide(\x22goog.dom.NodeType\x22);\ngoog.dom.NodeType \x3d {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};\n");
SHADOW_ENV.evalLoad("goog.asserts.asserts.js", true, "goog.loadModule(function(exports) {\n  function AssertionError(messagePattern, messageArgs) {\n    DebugError.call(this, subs(messagePattern, messageArgs));\n    this.messagePattern \x3d messagePattern;\n  }\n  function subs(pattern, subs) {\n    const splitParts \x3d pattern.split(\x22%s\x22);\n    let returnString \x3d \x22\x22;\n    const subLast \x3d splitParts.length - 1;\n    for (let i \x3d 0; i \x3c subLast; i++) {\n      const sub \x3d i \x3c subs.length ? subs[i] : \x22%s\x22;\n      returnString \x3d returnString + (splitParts[i] + sub);\n    }\n    return returnString + splitParts[subLast];\n  }\n  function doAssertFailure(defaultMessage, defaultArgs, givenMessage, givenArgs) {\n    let message \x3d \x22Assertion failed\x22;\n    let args;\n    if (givenMessage) {\n      message \x3d message + (\x22: \x22 + givenMessage);\n      args \x3d givenArgs;\n    } else if (defaultMessage) {\n      message \x3d message + (\x22: \x22 + defaultMessage);\n      args \x3d defaultArgs;\n    }\n    const e \x3d new AssertionError(\x22\x22 + message, args || []);\n    errorHandler_(e);\n  }\n  function getType(value) {\n    if (value instanceof Function) {\n      return value.displayName || value.name || \x22unknown type name\x22;\n    } else if (value instanceof Object) {\n      return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);\n    } else {\n      return value \x3d\x3d\x3d null ? \x22null\x22 : typeof value;\n    }\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.asserts\x22);\n  goog.module.declareLegacyNamespace();\n  const DebugError \x3d goog.require(\x22goog.debug.Error\x22);\n  const NodeType \x3d goog.require(\x22goog.dom.NodeType\x22);\n  exports.ENABLE_ASSERTS \x3d goog.define(\x22goog.asserts.ENABLE_ASSERTS\x22, goog.DEBUG);\n  goog.inherits(AssertionError, DebugError);\n  exports.AssertionError \x3d AssertionError;\n  AssertionError.prototype.name \x3d \x22AssertionError\x22;\n  exports.DEFAULT_ERROR_HANDLER \x3d function(e) {\n    throw e;\n  };\n  let errorHandler_ \x3d exports.DEFAULT_ERROR_HANDLER;\n  exports.setErrorHandler \x3d function(errorHandler) {\n    if (exports.ENABLE_ASSERTS) {\n      errorHandler_ \x3d errorHandler;\n    }\n  };\n  exports.assert \x3d function(condition, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 !condition) {\n      doAssertFailure(\x22\x22, null, opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return condition;\n  };\n  exports.assertExists \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 value \x3d\x3d null) {\n      doAssertFailure(\x22Expected to exist: %s.\x22, [value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.fail \x3d function(opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS) {\n      errorHandler_(new AssertionError(\x22Failure\x22 + (opt_message ? \x22: \x22 + opt_message : \x22\x22), Array.prototype.slice.call(arguments, 1)));\n    }\n  };\n  exports.assertNumber \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 typeof value !\x3d\x3d \x22number\x22) {\n      doAssertFailure(\x22Expected number but got %s: %s.\x22, [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertString \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 typeof value !\x3d\x3d \x22string\x22) {\n      doAssertFailure(\x22Expected string but got %s: %s.\x22, [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertFunction \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 typeof value !\x3d\x3d \x22function\x22) {\n      doAssertFailure(\x22Expected function but got %s: %s.\x22, [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertObject \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 !goog.isObject(value)) {\n      doAssertFailure(\x22Expected object but got %s: %s.\x22, [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertArray \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 !Array.isArray(value)) {\n      doAssertFailure(\x22Expected array but got %s: %s.\x22, [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertBoolean \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 typeof value !\x3d\x3d \x22boolean\x22) {\n      doAssertFailure(\x22Expected boolean but got %s: %s.\x22, [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertElement \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 (!goog.isObject(value) || value.nodeType !\x3d NodeType.ELEMENT)) {\n      doAssertFailure(\x22Expected Element but got %s: %s.\x22, [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertInstanceof \x3d function(value, type, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 !(value instanceof type)) {\n      doAssertFailure(\x22Expected instanceof %s but got %s.\x22, [getType(type), getType(value)], opt_message, Array.prototype.slice.call(arguments, 3));\n    }\n    return value;\n  };\n  exports.assertFinite \x3d function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS \x26\x26 (typeof value !\x3d \x22number\x22 || !isFinite(value))) {\n      doAssertFailure(\x22Expected %s to be a finite number but it is not.\x22, [value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.reflect.reflect.js", true, "goog.provide(\x22goog.reflect\x22);\ngoog.reflect.object \x3d function(type, object) {\n  return object;\n};\ngoog.reflect.objectProperty \x3d function(prop, object) {\n  return prop;\n};\ngoog.reflect.sinkValue \x3d function(x) {\n  goog.reflect.sinkValue[\x22 \x22](x);\n  return x;\n};\ngoog.reflect.sinkValue[\x22 \x22] \x3d function() {\n};\ngoog.reflect.canAccessProperty \x3d function(obj, prop) {\n  try {\n    goog.reflect.sinkValue(obj[prop]);\n    return true;\n  } catch (e) {\n  }\n  return false;\n};\ngoog.reflect.cache \x3d function(cacheObj, key, valueFn, opt_keyFn) {\n  const storedKey \x3d opt_keyFn ? opt_keyFn(key) : key;\n  if (Object.prototype.hasOwnProperty.call(cacheObj, storedKey)) {\n    return cacheObj[storedKey];\n  }\n  return cacheObj[storedKey] \x3d valueFn(key);\n};\n");
SHADOW_ENV.evalLoad("goog.math.long.js", true, "goog.loadModule(function(exports) {\n  function getCachedIntValue_(value) {\n    return reflect.cache(IntCache_, value, function(val) {\n      return new Long(val, val \x3c 0 ? -1 : 0);\n    });\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.math.Long\x22);\n  goog.module.declareLegacyNamespace();\n  const asserts \x3d goog.require(\x22goog.asserts\x22);\n  const reflect \x3d goog.require(\x22goog.reflect\x22);\n  class Long {\n    constructor(low, high) {\n      this.low_ \x3d low | 0;\n      this.high_ \x3d high | 0;\n    }\n    toInt() {\n      return this.low_;\n    }\n    toNumber() {\n      return this.high_ * TWO_PWR_32_DBL_ + this.getLowBitsUnsigned();\n    }\n    isSafeInteger() {\n      var top11Bits \x3d this.high_ \x3e\x3e 21;\n      return top11Bits \x3d\x3d 0 || top11Bits \x3d\x3d -1 \x26\x26 !(this.low_ \x3d\x3d 0 \x26\x26 this.high_ \x3d\x3d (4292870144 | 0));\n    }\n    toString(opt_radix) {\n      var radix \x3d opt_radix || 10;\n      if (radix \x3c 2 || 36 \x3c radix) {\n        throw new Error(\x22radix out of range: \x22 + radix);\n      }\n      if (this.isSafeInteger()) {\n        var asNumber \x3d this.toNumber();\n        return radix \x3d\x3d 10 ? \x22\x22 + asNumber : asNumber.toString(radix);\n      }\n      var safeDigits \x3d 14 - (radix \x3e\x3e 2);\n      var radixPowSafeDigits \x3d Math.pow(radix, safeDigits);\n      var radixToPower \x3d Long.fromBits(radixPowSafeDigits, radixPowSafeDigits / TWO_PWR_32_DBL_);\n      var remDiv \x3d this.div(radixToPower);\n      var val \x3d Math.abs(this.subtract(remDiv.multiply(radixToPower)).toNumber());\n      var digits \x3d radix \x3d\x3d 10 ? \x22\x22 + val : val.toString(radix);\n      if (digits.length \x3c safeDigits) {\n        digits \x3d \x220000000000000\x22.slice(digits.length - safeDigits) + digits;\n      }\n      val \x3d remDiv.toNumber();\n      return (radix \x3d\x3d 10 ? val : val.toString(radix)) + digits;\n    }\n    toUnsignedString(opt_radix) {\n      if (this.high_ \x3e\x3d 0) {\n        return this.toString(opt_radix);\n      }\n      var radix \x3d opt_radix || 10;\n      if (radix \x3c 2 || 36 \x3c radix) {\n        throw new Error(\x22radix out of range: \x22 + radix);\n      }\n      var longRadix \x3d Long.fromInt(radix);\n      var quotient \x3d this.shiftRightUnsigned(1).div(longRadix).shiftLeft(1);\n      var remainder \x3d this.subtract(quotient.multiply(longRadix));\n      if (remainder.greaterThanOrEqual(longRadix)) {\n        quotient \x3d quotient.add(Long.getOne());\n        remainder \x3d this.subtract(quotient.multiply(longRadix));\n      }\n      return quotient.toString(radix) + remainder.toString(radix);\n    }\n    getHighBits() {\n      return this.high_;\n    }\n    getLowBits() {\n      return this.low_;\n    }\n    getLowBitsUnsigned() {\n      return this.low_ \x3e\x3e\x3e 0;\n    }\n    getNumBitsAbs() {\n      if (this.isNegative()) {\n        if (this.equals(Long.getMinValue())) {\n          return 64;\n        } else {\n          return this.negate().getNumBitsAbs();\n        }\n      } else {\n        var val \x3d this.high_ !\x3d 0 ? this.high_ : this.low_;\n        var bit \x3d 31;\n        for (; bit \x3e 0; bit--) {\n          if ((val \x26 1 \x3c\x3c bit) !\x3d 0) {\n            break;\n          }\n        }\n        return this.high_ !\x3d 0 ? bit + 33 : bit + 1;\n      }\n    }\n    isZero() {\n      return this.low_ \x3d\x3d 0 \x26\x26 this.high_ \x3d\x3d 0;\n    }\n    isNegative() {\n      return this.high_ \x3c 0;\n    }\n    isOdd() {\n      return (this.low_ \x26 1) \x3d\x3d 1;\n    }\n    hashCode() {\n      return this.getLowBits() ^ this.getHighBits();\n    }\n    equals(other) {\n      return this.low_ \x3d\x3d other.low_ \x26\x26 this.high_ \x3d\x3d other.high_;\n    }\n    notEquals(other) {\n      return !this.equals(other);\n    }\n    lessThan(other) {\n      return this.compare(other) \x3c 0;\n    }\n    lessThanOrEqual(other) {\n      return this.compare(other) \x3c\x3d 0;\n    }\n    greaterThan(other) {\n      return this.compare(other) \x3e 0;\n    }\n    greaterThanOrEqual(other) {\n      return this.compare(other) \x3e\x3d 0;\n    }\n    compare(other) {\n      if (this.high_ \x3d\x3d other.high_) {\n        if (this.low_ \x3d\x3d other.low_) {\n          return 0;\n        }\n        return this.getLowBitsUnsigned() \x3e other.getLowBitsUnsigned() ? 1 : -1;\n      }\n      return this.high_ \x3e other.high_ ? 1 : -1;\n    }\n    negate() {\n      var negLow \x3d ~this.low_ + 1 | 0;\n      var overflowFromLow \x3d !negLow;\n      var negHigh \x3d ~this.high_ + overflowFromLow | 0;\n      return Long.fromBits(negLow, negHigh);\n    }\n    add(other) {\n      var a48 \x3d this.high_ \x3e\x3e\x3e 16;\n      var a32 \x3d this.high_ \x26 65535;\n      var a16 \x3d this.low_ \x3e\x3e\x3e 16;\n      var a00 \x3d this.low_ \x26 65535;\n      var b48 \x3d other.high_ \x3e\x3e\x3e 16;\n      var b32 \x3d other.high_ \x26 65535;\n      var b16 \x3d other.low_ \x3e\x3e\x3e 16;\n      var b00 \x3d other.low_ \x26 65535;\n      var c48 \x3d 0;\n      var c32 \x3d 0;\n      var c16 \x3d 0;\n      var c00 \x3d 0;\n      c00 \x3d c00 + (a00 + b00);\n      c16 \x3d c16 + (c00 \x3e\x3e\x3e 16);\n      c00 \x3d c00 \x26 65535;\n      c16 \x3d c16 + (a16 + b16);\n      c32 \x3d c32 + (c16 \x3e\x3e\x3e 16);\n      c16 \x3d c16 \x26 65535;\n      c32 \x3d c32 + (a32 + b32);\n      c48 \x3d c48 + (c32 \x3e\x3e\x3e 16);\n      c32 \x3d c32 \x26 65535;\n      c48 \x3d c48 + (a48 + b48);\n      c48 \x3d c48 \x26 65535;\n      return Long.fromBits(c16 \x3c\x3c 16 | c00, c48 \x3c\x3c 16 | c32);\n    }\n    subtract(other) {\n      return this.add(other.negate());\n    }\n    multiply(other) {\n      if (this.isZero()) {\n        return this;\n      }\n      if (other.isZero()) {\n        return other;\n      }\n      var a48 \x3d this.high_ \x3e\x3e\x3e 16;\n      var a32 \x3d this.high_ \x26 65535;\n      var a16 \x3d this.low_ \x3e\x3e\x3e 16;\n      var a00 \x3d this.low_ \x26 65535;\n      var b48 \x3d other.high_ \x3e\x3e\x3e 16;\n      var b32 \x3d other.high_ \x26 65535;\n      var b16 \x3d other.low_ \x3e\x3e\x3e 16;\n      var b00 \x3d other.low_ \x26 65535;\n      var c48 \x3d 0;\n      var c32 \x3d 0;\n      var c16 \x3d 0;\n      var c00 \x3d 0;\n      c00 \x3d c00 + a00 * b00;\n      c16 \x3d c16 + (c00 \x3e\x3e\x3e 16);\n      c00 \x3d c00 \x26 65535;\n      c16 \x3d c16 + a16 * b00;\n      c32 \x3d c32 + (c16 \x3e\x3e\x3e 16);\n      c16 \x3d c16 \x26 65535;\n      c16 \x3d c16 + a00 * b16;\n      c32 \x3d c32 + (c16 \x3e\x3e\x3e 16);\n      c16 \x3d c16 \x26 65535;\n      c32 \x3d c32 + a32 * b00;\n      c48 \x3d c48 + (c32 \x3e\x3e\x3e 16);\n      c32 \x3d c32 \x26 65535;\n      c32 \x3d c32 + a16 * b16;\n      c48 \x3d c48 + (c32 \x3e\x3e\x3e 16);\n      c32 \x3d c32 \x26 65535;\n      c32 \x3d c32 + a00 * b32;\n      c48 \x3d c48 + (c32 \x3e\x3e\x3e 16);\n      c32 \x3d c32 \x26 65535;\n      c48 \x3d c48 + (a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48);\n      c48 \x3d c48 \x26 65535;\n      return Long.fromBits(c16 \x3c\x3c 16 | c00, c48 \x3c\x3c 16 | c32);\n    }\n    div(other) {\n      if (other.isZero()) {\n        throw new Error(\x22division by zero\x22);\n      }\n      if (this.isNegative()) {\n        if (this.equals(Long.getMinValue())) {\n          if (other.equals(Long.getOne()) || other.equals(Long.getNegOne())) {\n            return Long.getMinValue();\n          }\n          if (other.equals(Long.getMinValue())) {\n            return Long.getOne();\n          }\n          var halfThis \x3d this.shiftRight(1);\n          var approx \x3d halfThis.div(other).shiftLeft(1);\n          if (approx.equals(Long.getZero())) {\n            return other.isNegative() ? Long.getOne() : Long.getNegOne();\n          }\n          var rem \x3d this.subtract(other.multiply(approx));\n          var result \x3d approx.add(rem.div(other));\n          return result;\n        }\n        if (other.isNegative()) {\n          return this.negate().div(other.negate());\n        }\n        return this.negate().div(other).negate();\n      }\n      if (this.isZero()) {\n        return Long.getZero();\n      }\n      if (other.isNegative()) {\n        if (other.equals(Long.getMinValue())) {\n          return Long.getZero();\n        }\n        return this.div(other.negate()).negate();\n      }\n      var res \x3d Long.getZero();\n      rem \x3d this;\n      for (; rem.greaterThanOrEqual(other);) {\n        approx \x3d Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));\n        var log2 \x3d Math.ceil(Math.log(approx) / Math.LN2);\n        var delta \x3d log2 \x3c\x3d 48 ? 1 : Math.pow(2, log2 - 48);\n        var approxRes \x3d Long.fromNumber(approx);\n        var approxRem \x3d approxRes.multiply(other);\n        for (; approxRem.isNegative() || approxRem.greaterThan(rem);) {\n          approx \x3d approx - delta;\n          approxRes \x3d Long.fromNumber(approx);\n          approxRem \x3d approxRes.multiply(other);\n        }\n        if (approxRes.isZero()) {\n          approxRes \x3d Long.getOne();\n        }\n        res \x3d res.add(approxRes);\n        rem \x3d rem.subtract(approxRem);\n      }\n      return res;\n    }\n    modulo(other) {\n      return this.subtract(this.div(other).multiply(other));\n    }\n    not() {\n      return Long.fromBits(~this.low_, ~this.high_);\n    }\n    and(other) {\n      return Long.fromBits(this.low_ \x26 other.low_, this.high_ \x26 other.high_);\n    }\n    or(other) {\n      return Long.fromBits(this.low_ | other.low_, this.high_ | other.high_);\n    }\n    xor(other) {\n      return Long.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);\n    }\n    shiftLeft(numBits) {\n      numBits \x3d numBits \x26 63;\n      if (numBits \x3d\x3d 0) {\n        return this;\n      } else {\n        var low \x3d this.low_;\n        if (numBits \x3c 32) {\n          var high \x3d this.high_;\n          return Long.fromBits(low \x3c\x3c numBits, high \x3c\x3c numBits | low \x3e\x3e\x3e 32 - numBits);\n        } else {\n          return Long.fromBits(0, low \x3c\x3c numBits - 32);\n        }\n      }\n    }\n    shiftRight(numBits) {\n      numBits \x3d numBits \x26 63;\n      if (numBits \x3d\x3d 0) {\n        return this;\n      } else {\n        var high \x3d this.high_;\n        if (numBits \x3c 32) {\n          var low \x3d this.low_;\n          return Long.fromBits(low \x3e\x3e\x3e numBits | high \x3c\x3c 32 - numBits, high \x3e\x3e numBits);\n        } else {\n          return Long.fromBits(high \x3e\x3e numBits - 32, high \x3e\x3d 0 ? 0 : -1);\n        }\n      }\n    }\n    shiftRightUnsigned(numBits) {\n      numBits \x3d numBits \x26 63;\n      if (numBits \x3d\x3d 0) {\n        return this;\n      } else {\n        var high \x3d this.high_;\n        if (numBits \x3c 32) {\n          var low \x3d this.low_;\n          return Long.fromBits(low \x3e\x3e\x3e numBits | high \x3c\x3c 32 - numBits, high \x3e\x3e\x3e numBits);\n        } else if (numBits \x3d\x3d 32) {\n          return Long.fromBits(high, 0);\n        } else {\n          return Long.fromBits(high \x3e\x3e\x3e numBits - 32, 0);\n        }\n      }\n    }\n    static fromInt(value) {\n      var intValue \x3d value | 0;\n      asserts.assert(value \x3d\x3d\x3d intValue, \x22value should be a 32-bit integer\x22);\n      if (-128 \x3c\x3d intValue \x26\x26 intValue \x3c 128) {\n        return getCachedIntValue_(intValue);\n      } else {\n        return new Long(intValue, intValue \x3c 0 ? -1 : 0);\n      }\n    }\n    static fromNumber(value) {\n      if (value \x3e 0) {\n        if (value \x3e\x3d TWO_PWR_63_DBL_) {\n          return Long.getMaxValue();\n        }\n        return new Long(value, value / TWO_PWR_32_DBL_);\n      } else if (value \x3c 0) {\n        if (value \x3c\x3d -TWO_PWR_63_DBL_) {\n          return Long.getMinValue();\n        }\n        return (new Long(-value, -value / TWO_PWR_32_DBL_)).negate();\n      } else {\n        return Long.getZero();\n      }\n    }\n    static fromBits(lowBits, highBits) {\n      return new Long(lowBits, highBits);\n    }\n    static fromString(str, opt_radix) {\n      if (str.charAt(0) \x3d\x3d \x22-\x22) {\n        return Long.fromString(str.substring(1), opt_radix).negate();\n      }\n      var numberValue \x3d parseInt(str, opt_radix || 10);\n      if (numberValue \x3c\x3d MAX_SAFE_INTEGER_) {\n        return new Long(numberValue % TWO_PWR_32_DBL_ | 0, numberValue / TWO_PWR_32_DBL_ | 0);\n      }\n      if (str.length \x3d\x3d 0) {\n        throw new Error(\x22number format error: empty string\x22);\n      }\n      if (str.indexOf(\x22-\x22) \x3e\x3d 0) {\n        throw new Error(\x27number format error: interior \x22-\x22 character: \x27 + str);\n      }\n      var radix \x3d opt_radix || 10;\n      if (radix \x3c 2 || 36 \x3c radix) {\n        throw new Error(\x22radix out of range: \x22 + radix);\n      }\n      var radixToPower \x3d Long.fromNumber(Math.pow(radix, 8));\n      var result \x3d Long.getZero();\n      var i \x3d 0;\n      for (; i \x3c str.length; i \x3d i + 8) {\n        var size \x3d Math.min(8, str.length - i);\n        var value \x3d parseInt(str.substring(i, i + size), radix);\n        if (size \x3c 8) {\n          var power \x3d Long.fromNumber(Math.pow(radix, size));\n          result \x3d result.multiply(power).add(Long.fromNumber(value));\n        } else {\n          result \x3d result.multiply(radixToPower);\n          result \x3d result.add(Long.fromNumber(value));\n        }\n      }\n      return result;\n    }\n    static isStringInRange(str, opt_radix) {\n      var radix \x3d opt_radix || 10;\n      if (radix \x3c 2 || 36 \x3c radix) {\n        throw new Error(\x22radix out of range: \x22 + radix);\n      }\n      var extremeValue \x3d str.charAt(0) \x3d\x3d \x22-\x22 ? MIN_VALUE_FOR_RADIX_[radix] : MAX_VALUE_FOR_RADIX_[radix];\n      if (str.length \x3c extremeValue.length) {\n        return true;\n      } else if (str.length \x3d\x3d extremeValue.length \x26\x26 str \x3c\x3d extremeValue) {\n        return true;\n      } else {\n        return false;\n      }\n    }\n    static getZero() {\n      return ZERO_;\n    }\n    static getOne() {\n      return ONE_;\n    }\n    static getNegOne() {\n      return NEG_ONE_;\n    }\n    static getMaxValue() {\n      return MAX_VALUE_;\n    }\n    static getMinValue() {\n      return MIN_VALUE_;\n    }\n    static getTwoPwr24() {\n      return TWO_PWR_24_;\n    }\n  }\n  exports \x3d Long;\n  const IntCache_ \x3d {};\n  const MAX_VALUE_FOR_RADIX_ \x3d [\x22\x22, \x22\x22, \x22111111111111111111111111111111111111111111111111111111111111111\x22, \x222021110011022210012102010021220101220221\x22, \x2213333333333333333333333333333333\x22, \x221104332401304422434310311212\x22, \x221540241003031030222122211\x22, \x2222341010611245052052300\x22, \x22777777777777777777777\x22, \x2267404283172107811827\x22, \x229223372036854775807\x22, \x221728002635214590697\x22, \x2241a792678515120367\x22, \x2210b269549075433c37\x22, \x224340724c6c71dc7a7\x22, \x22160e2ad3246366807\x22, \x227fffffffffffffff\x22, \x2233d3d8307b214008\x22, \x2216agh595df825fa7\x22, \n  \x22ba643dci0ffeehh\x22, \x225cbfjia3fh26ja7\x22, \x222heiciiie82dh97\x22, \x221adaibb21dckfa7\x22, \x22i6k448cf4192c2\x22, \x22acd772jnc9l0l7\x22, \x2264ie1focnn5g77\x22, \x223igoecjbmca687\x22, \x2227c48l5b37oaop\x22, \x221bk39f3ah3dmq7\x22, \x22q1se8f0m04isb\x22, \x22hajppbc1fc207\x22, \x22bm03i95hia437\x22, \x227vvvvvvvvvvvv\x22, \x225hg4ck9jd4u37\x22, \x223tdtk1v8j6tpp\x22, \x222pijmikexrxp7\x22, \x221y2p0ij32e8e7\x22];\n  const MIN_VALUE_FOR_RADIX_ \x3d [\x22\x22, \x22\x22, \x22-1000000000000000000000000000000000000000000000000000000000000000\x22, \x22-2021110011022210012102010021220101220222\x22, \x22-20000000000000000000000000000000\x22, \x22-1104332401304422434310311213\x22, \x22-1540241003031030222122212\x22, \x22-22341010611245052052301\x22, \x22-1000000000000000000000\x22, \x22-67404283172107811828\x22, \x22-9223372036854775808\x22, \x22-1728002635214590698\x22, \x22-41a792678515120368\x22, \x22-10b269549075433c38\x22, \x22-4340724c6c71dc7a8\x22, \x22-160e2ad3246366808\x22, \x22-8000000000000000\x22, \x22-33d3d8307b214009\x22, \n  \x22-16agh595df825fa8\x22, \x22-ba643dci0ffeehi\x22, \x22-5cbfjia3fh26ja8\x22, \x22-2heiciiie82dh98\x22, \x22-1adaibb21dckfa8\x22, \x22-i6k448cf4192c3\x22, \x22-acd772jnc9l0l8\x22, \x22-64ie1focnn5g78\x22, \x22-3igoecjbmca688\x22, \x22-27c48l5b37oaoq\x22, \x22-1bk39f3ah3dmq8\x22, \x22-q1se8f0m04isc\x22, \x22-hajppbc1fc208\x22, \x22-bm03i95hia438\x22, \x22-8000000000000\x22, \x22-5hg4ck9jd4u38\x22, \x22-3tdtk1v8j6tpq\x22, \x22-2pijmikexrxp8\x22, \x22-1y2p0ij32e8e8\x22];\n  const MAX_SAFE_INTEGER_ \x3d 9007199254740991;\n  const TWO_PWR_32_DBL_ \x3d 4294967296;\n  const TWO_PWR_63_DBL_ \x3d 0x7fffffffffffffff;\n  const ZERO_ \x3d Long.fromBits(0, 0);\n  const ONE_ \x3d Long.fromBits(1, 0);\n  const NEG_ONE_ \x3d Long.fromBits(-1, -1);\n  const MAX_VALUE_ \x3d Long.fromBits(4294967295, 2147483647);\n  const MIN_VALUE_ \x3d Long.fromBits(0, 2147483648);\n  const TWO_PWR_24_ \x3d Long.fromBits(1 \x3c\x3c 24, 0);\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.math.integer.js", true, "goog.provide(\x22goog.math.Integer\x22);\ngoog.require(\x22goog.reflect\x22);\ngoog.math.Integer \x3d function(bits, sign) {\n  this.sign_ \x3d sign;\n  var localBits \x3d [];\n  var top \x3d true;\n  var i \x3d bits.length - 1;\n  for (; i \x3e\x3d 0; i--) {\n    var val \x3d bits[i] | 0;\n    if (!top || val !\x3d sign) {\n      localBits[i] \x3d val;\n      top \x3d false;\n    }\n  }\n  this.bits_ \x3d localBits;\n};\ngoog.math.Integer.IntCache_ \x3d {};\ngoog.math.Integer.fromInt \x3d function(value) {\n  if (-128 \x3c\x3d value \x26\x26 value \x3c 128) {\n    return goog.reflect.cache(goog.math.Integer.IntCache_, value, function(val) {\n      return new goog.math.Integer([val | 0], val \x3c 0 ? -1 : 0);\n    });\n  }\n  return new goog.math.Integer([value | 0], value \x3c 0 ? -1 : 0);\n};\ngoog.math.Integer.fromNumber \x3d function(value) {\n  if (isNaN(value) || !isFinite(value)) {\n    return goog.math.Integer.ZERO;\n  } else if (value \x3c 0) {\n    return goog.math.Integer.fromNumber(-value).negate();\n  } else {\n    var bits \x3d [];\n    var pow \x3d 1;\n    var i \x3d 0;\n    for (; value \x3e\x3d pow; i++) {\n      bits[i] \x3d value / pow | 0;\n      pow \x3d pow * goog.math.Integer.TWO_PWR_32_DBL_;\n    }\n    return new goog.math.Integer(bits, 0);\n  }\n};\ngoog.math.Integer.fromBits \x3d function(bits) {\n  var high \x3d bits[bits.length - 1];\n  return new goog.math.Integer(bits, high \x26 1 \x3c\x3c 31 ? -1 : 0);\n};\ngoog.math.Integer.fromString \x3d function(str, opt_radix) {\n  if (str.length \x3d\x3d 0) {\n    throw new Error(\x22number format error: empty string\x22);\n  }\n  var radix \x3d opt_radix || 10;\n  if (radix \x3c 2 || 36 \x3c radix) {\n    throw new Error(\x22radix out of range: \x22 + radix);\n  }\n  if (str.charAt(0) \x3d\x3d \x22-\x22) {\n    return goog.math.Integer.fromString(str.substring(1), radix).negate();\n  } else if (str.indexOf(\x22-\x22) \x3e\x3d 0) {\n    throw new Error(\x27number format error: interior \x22-\x22 character\x27);\n  }\n  var radixToPower \x3d goog.math.Integer.fromNumber(Math.pow(radix, 8));\n  var result \x3d goog.math.Integer.ZERO;\n  var i \x3d 0;\n  for (; i \x3c str.length; i \x3d i + 8) {\n    var size \x3d Math.min(8, str.length - i);\n    var value \x3d parseInt(str.substring(i, i + size), radix);\n    if (size \x3c 8) {\n      var power \x3d goog.math.Integer.fromNumber(Math.pow(radix, size));\n      result \x3d result.multiply(power).add(goog.math.Integer.fromNumber(value));\n    } else {\n      result \x3d result.multiply(radixToPower);\n      result \x3d result.add(goog.math.Integer.fromNumber(value));\n    }\n  }\n  return result;\n};\ngoog.math.Integer.TWO_PWR_32_DBL_ \x3d (1 \x3c\x3c 16) * (1 \x3c\x3c 16);\ngoog.math.Integer.ZERO \x3d goog.math.Integer.fromInt(0);\ngoog.math.Integer.ONE \x3d goog.math.Integer.fromInt(1);\ngoog.math.Integer.TWO_PWR_24_ \x3d goog.math.Integer.fromInt(1 \x3c\x3c 24);\ngoog.math.Integer.prototype.toInt \x3d function() {\n  return this.bits_.length \x3e 0 ? this.bits_[0] : this.sign_;\n};\ngoog.math.Integer.prototype.toNumber \x3d function() {\n  if (this.isNegative()) {\n    return -this.negate().toNumber();\n  } else {\n    var val \x3d 0;\n    var pow \x3d 1;\n    var i \x3d 0;\n    for (; i \x3c this.bits_.length; i++) {\n      val \x3d val + this.getBitsUnsigned(i) * pow;\n      pow \x3d pow * goog.math.Integer.TWO_PWR_32_DBL_;\n    }\n    return val;\n  }\n};\ngoog.math.Integer.prototype.toString \x3d function(opt_radix) {\n  var radix \x3d opt_radix || 10;\n  if (radix \x3c 2 || 36 \x3c radix) {\n    throw new Error(\x22radix out of range: \x22 + radix);\n  }\n  if (this.isZero()) {\n    return \x220\x22;\n  } else if (this.isNegative()) {\n    return \x22-\x22 + this.negate().toString(radix);\n  }\n  var radixToPower \x3d goog.math.Integer.fromNumber(Math.pow(radix, 6));\n  var rem \x3d this;\n  var result \x3d \x22\x22;\n  for (; true;) {\n    var remDiv \x3d rem.divide(radixToPower);\n    var intval \x3d rem.subtract(remDiv.multiply(radixToPower)).toInt() \x3e\x3e\x3e 0;\n    var digits \x3d intval.toString(radix);\n    rem \x3d remDiv;\n    if (rem.isZero()) {\n      return digits + result;\n    } else {\n      for (; digits.length \x3c 6;) {\n        digits \x3d \x220\x22 + digits;\n      }\n      result \x3d \x22\x22 + digits + result;\n    }\n  }\n};\ngoog.math.Integer.prototype.getBits \x3d function(index) {\n  if (index \x3c 0) {\n    return 0;\n  } else if (index \x3c this.bits_.length) {\n    return this.bits_[index];\n  } else {\n    return this.sign_;\n  }\n};\ngoog.math.Integer.prototype.getBitsUnsigned \x3d function(index) {\n  var val \x3d this.getBits(index);\n  return val \x3e\x3d 0 ? val : goog.math.Integer.TWO_PWR_32_DBL_ + val;\n};\ngoog.math.Integer.prototype.getSign \x3d function() {\n  return this.sign_;\n};\ngoog.math.Integer.prototype.isZero \x3d function() {\n  if (this.sign_ !\x3d 0) {\n    return false;\n  }\n  var i \x3d 0;\n  for (; i \x3c this.bits_.length; i++) {\n    if (this.bits_[i] !\x3d 0) {\n      return false;\n    }\n  }\n  return true;\n};\ngoog.math.Integer.prototype.isNegative \x3d function() {\n  return this.sign_ \x3d\x3d -1;\n};\ngoog.math.Integer.prototype.isOdd \x3d function() {\n  return this.bits_.length \x3d\x3d 0 \x26\x26 this.sign_ \x3d\x3d -1 || this.bits_.length \x3e 0 \x26\x26 (this.bits_[0] \x26 1) !\x3d 0;\n};\ngoog.math.Integer.prototype.equals \x3d function(other) {\n  if (this.sign_ !\x3d other.sign_) {\n    return false;\n  }\n  var len \x3d Math.max(this.bits_.length, other.bits_.length);\n  var i \x3d 0;\n  for (; i \x3c len; i++) {\n    if (this.getBits(i) !\x3d other.getBits(i)) {\n      return false;\n    }\n  }\n  return true;\n};\ngoog.math.Integer.prototype.notEquals \x3d function(other) {\n  return !this.equals(other);\n};\ngoog.math.Integer.prototype.greaterThan \x3d function(other) {\n  return this.compare(other) \x3e 0;\n};\ngoog.math.Integer.prototype.greaterThanOrEqual \x3d function(other) {\n  return this.compare(other) \x3e\x3d 0;\n};\ngoog.math.Integer.prototype.lessThan \x3d function(other) {\n  return this.compare(other) \x3c 0;\n};\ngoog.math.Integer.prototype.lessThanOrEqual \x3d function(other) {\n  return this.compare(other) \x3c\x3d 0;\n};\ngoog.math.Integer.prototype.compare \x3d function(other) {\n  var diff \x3d this.subtract(other);\n  if (diff.isNegative()) {\n    return -1;\n  } else if (diff.isZero()) {\n    return 0;\n  } else {\n    return +1;\n  }\n};\ngoog.math.Integer.prototype.shorten \x3d function(numBits) {\n  var arr_index \x3d numBits - 1 \x3e\x3e 5;\n  var bit_index \x3d (numBits - 1) % 32;\n  var bits \x3d [];\n  var i \x3d 0;\n  for (; i \x3c arr_index; i++) {\n    bits[i] \x3d this.getBits(i);\n  }\n  var sigBits \x3d bit_index \x3d\x3d 31 ? 4294967295 : (1 \x3c\x3c bit_index + 1) - 1;\n  var val \x3d this.getBits(arr_index) \x26 sigBits;\n  if (val \x26 1 \x3c\x3c bit_index) {\n    val \x3d val | 4294967295 - sigBits;\n    bits[arr_index] \x3d val;\n    return new goog.math.Integer(bits, -1);\n  } else {\n    bits[arr_index] \x3d val;\n    return new goog.math.Integer(bits, 0);\n  }\n};\ngoog.math.Integer.prototype.negate \x3d function() {\n  return this.not().add(goog.math.Integer.ONE);\n};\ngoog.math.Integer.prototype.abs \x3d function() {\n  return this.isNegative() ? this.negate() : this;\n};\ngoog.math.Integer.prototype.add \x3d function(other) {\n  var len \x3d Math.max(this.bits_.length, other.bits_.length);\n  var arr \x3d [];\n  var carry \x3d 0;\n  var i \x3d 0;\n  for (; i \x3c\x3d len; i++) {\n    var a1 \x3d this.getBits(i) \x3e\x3e\x3e 16;\n    var a0 \x3d this.getBits(i) \x26 65535;\n    var b1 \x3d other.getBits(i) \x3e\x3e\x3e 16;\n    var b0 \x3d other.getBits(i) \x26 65535;\n    var c0 \x3d carry + a0 + b0;\n    var c1 \x3d (c0 \x3e\x3e\x3e 16) + a1 + b1;\n    carry \x3d c1 \x3e\x3e\x3e 16;\n    c0 \x3d c0 \x26 65535;\n    c1 \x3d c1 \x26 65535;\n    arr[i] \x3d c1 \x3c\x3c 16 | c0;\n  }\n  return goog.math.Integer.fromBits(arr);\n};\ngoog.math.Integer.prototype.subtract \x3d function(other) {\n  return this.add(other.negate());\n};\ngoog.math.Integer.prototype.multiply \x3d function(other) {\n  if (this.isZero()) {\n    return goog.math.Integer.ZERO;\n  } else if (other.isZero()) {\n    return goog.math.Integer.ZERO;\n  }\n  if (this.isNegative()) {\n    if (other.isNegative()) {\n      return this.negate().multiply(other.negate());\n    } else {\n      return this.negate().multiply(other).negate();\n    }\n  } else if (other.isNegative()) {\n    return this.multiply(other.negate()).negate();\n  }\n  if (this.lessThan(goog.math.Integer.TWO_PWR_24_) \x26\x26 other.lessThan(goog.math.Integer.TWO_PWR_24_)) {\n    return goog.math.Integer.fromNumber(this.toNumber() * other.toNumber());\n  }\n  var len \x3d this.bits_.length + other.bits_.length;\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c 2 * len; i++) {\n    arr[i] \x3d 0;\n  }\n  i \x3d 0;\n  for (; i \x3c this.bits_.length; i++) {\n    var j \x3d 0;\n    for (; j \x3c other.bits_.length; j++) {\n      var a1 \x3d this.getBits(i) \x3e\x3e\x3e 16;\n      var a0 \x3d this.getBits(i) \x26 65535;\n      var b1 \x3d other.getBits(j) \x3e\x3e\x3e 16;\n      var b0 \x3d other.getBits(j) \x26 65535;\n      arr[2 * i + 2 * j] +\x3d a0 * b0;\n      goog.math.Integer.carry16_(arr, 2 * i + 2 * j);\n      arr[2 * i + 2 * j + 1] +\x3d a1 * b0;\n      goog.math.Integer.carry16_(arr, 2 * i + 2 * j + 1);\n      arr[2 * i + 2 * j + 1] +\x3d a0 * b1;\n      goog.math.Integer.carry16_(arr, 2 * i + 2 * j + 1);\n      arr[2 * i + 2 * j + 2] +\x3d a1 * b1;\n      goog.math.Integer.carry16_(arr, 2 * i + 2 * j + 2);\n    }\n  }\n  i \x3d 0;\n  for (; i \x3c len; i++) {\n    arr[i] \x3d arr[2 * i + 1] \x3c\x3c 16 | arr[2 * i];\n  }\n  i \x3d len;\n  for (; i \x3c 2 * len; i++) {\n    arr[i] \x3d 0;\n  }\n  return new goog.math.Integer(arr, 0);\n};\ngoog.math.Integer.carry16_ \x3d function(bits, index) {\n  for (; (bits[index] \x26 65535) !\x3d bits[index];) {\n    bits[index + 1] +\x3d bits[index] \x3e\x3e\x3e 16;\n    bits[index] \x26\x3d 65535;\n    index++;\n  }\n};\ngoog.math.Integer.prototype.slowDivide_ \x3d function(other) {\n  if (this.isNegative() || other.isNegative()) {\n    throw new Error(\x22slowDivide_ only works with positive integers.\x22);\n  }\n  var twoPower \x3d goog.math.Integer.ONE;\n  var multiple \x3d other;\n  for (; multiple.lessThanOrEqual(this);) {\n    twoPower \x3d twoPower.shiftLeft(1);\n    multiple \x3d multiple.shiftLeft(1);\n  }\n  var res \x3d twoPower.shiftRight(1);\n  var total \x3d multiple.shiftRight(1);\n  var total2;\n  multiple \x3d multiple.shiftRight(2);\n  twoPower \x3d twoPower.shiftRight(2);\n  for (; !multiple.isZero();) {\n    total2 \x3d total.add(multiple);\n    if (total2.lessThanOrEqual(this)) {\n      res \x3d res.add(twoPower);\n      total \x3d total2;\n    }\n    multiple \x3d multiple.shiftRight(1);\n    twoPower \x3d twoPower.shiftRight(1);\n  }\n  var remainder \x3d this.subtract(res.multiply(other));\n  return new goog.math.Integer.DivisionResult(res, remainder);\n};\ngoog.math.Integer.prototype.divide \x3d function(other) {\n  return this.divideAndRemainder(other).quotient;\n};\ngoog.math.Integer.DivisionResult \x3d function(quotient, remainder) {\n  this.quotient \x3d quotient;\n  this.remainder \x3d remainder;\n};\ngoog.math.Integer.prototype.divideAndRemainder \x3d function(other) {\n  if (other.isZero()) {\n    throw new Error(\x22division by zero\x22);\n  } else if (this.isZero()) {\n    return new goog.math.Integer.DivisionResult(goog.math.Integer.ZERO, goog.math.Integer.ZERO);\n  }\n  if (this.isNegative()) {\n    var result \x3d this.negate().divideAndRemainder(other);\n    return new goog.math.Integer.DivisionResult(result.quotient.negate(), result.remainder.negate());\n  } else if (other.isNegative()) {\n    result \x3d this.divideAndRemainder(other.negate());\n    return new goog.math.Integer.DivisionResult(result.quotient.negate(), result.remainder);\n  }\n  if (this.bits_.length \x3e 30) {\n    return this.slowDivide_(other);\n  }\n  var res \x3d goog.math.Integer.ZERO;\n  var rem \x3d this;\n  for (; rem.greaterThanOrEqual(other);) {\n    var approx \x3d Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));\n    var log2 \x3d Math.ceil(Math.log(approx) / Math.LN2);\n    var delta \x3d log2 \x3c\x3d 48 ? 1 : Math.pow(2, log2 - 48);\n    var approxRes \x3d goog.math.Integer.fromNumber(approx);\n    var approxRem \x3d approxRes.multiply(other);\n    for (; approxRem.isNegative() || approxRem.greaterThan(rem);) {\n      approx \x3d approx - delta;\n      approxRes \x3d goog.math.Integer.fromNumber(approx);\n      approxRem \x3d approxRes.multiply(other);\n    }\n    if (approxRes.isZero()) {\n      approxRes \x3d goog.math.Integer.ONE;\n    }\n    res \x3d res.add(approxRes);\n    rem \x3d rem.subtract(approxRem);\n  }\n  return new goog.math.Integer.DivisionResult(res, rem);\n};\ngoog.math.Integer.prototype.modulo \x3d function(other) {\n  return this.divideAndRemainder(other).remainder;\n};\ngoog.math.Integer.prototype.not \x3d function() {\n  var len \x3d this.bits_.length;\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c len; i++) {\n    arr[i] \x3d ~this.bits_[i];\n  }\n  return new goog.math.Integer(arr, ~this.sign_);\n};\ngoog.math.Integer.prototype.and \x3d function(other) {\n  var len \x3d Math.max(this.bits_.length, other.bits_.length);\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c len; i++) {\n    arr[i] \x3d this.getBits(i) \x26 other.getBits(i);\n  }\n  return new goog.math.Integer(arr, this.sign_ \x26 other.sign_);\n};\ngoog.math.Integer.prototype.or \x3d function(other) {\n  var len \x3d Math.max(this.bits_.length, other.bits_.length);\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c len; i++) {\n    arr[i] \x3d this.getBits(i) | other.getBits(i);\n  }\n  return new goog.math.Integer(arr, this.sign_ | other.sign_);\n};\ngoog.math.Integer.prototype.xor \x3d function(other) {\n  var len \x3d Math.max(this.bits_.length, other.bits_.length);\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c len; i++) {\n    arr[i] \x3d this.getBits(i) ^ other.getBits(i);\n  }\n  return new goog.math.Integer(arr, this.sign_ ^ other.sign_);\n};\ngoog.math.Integer.prototype.shiftLeft \x3d function(numBits) {\n  var arr_delta \x3d numBits \x3e\x3e 5;\n  var bit_delta \x3d numBits % 32;\n  var len \x3d this.bits_.length + arr_delta + (bit_delta \x3e 0 ? 1 : 0);\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c len; i++) {\n    if (bit_delta \x3e 0) {\n      arr[i] \x3d this.getBits(i - arr_delta) \x3c\x3c bit_delta | this.getBits(i - arr_delta - 1) \x3e\x3e\x3e 32 - bit_delta;\n    } else {\n      arr[i] \x3d this.getBits(i - arr_delta);\n    }\n  }\n  return new goog.math.Integer(arr, this.sign_);\n};\ngoog.math.Integer.prototype.shiftRight \x3d function(numBits) {\n  var arr_delta \x3d numBits \x3e\x3e 5;\n  var bit_delta \x3d numBits % 32;\n  var len \x3d this.bits_.length - arr_delta;\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c len; i++) {\n    if (bit_delta \x3e 0) {\n      arr[i] \x3d this.getBits(i + arr_delta) \x3e\x3e\x3e bit_delta | this.getBits(i + arr_delta + 1) \x3c\x3c 32 - bit_delta;\n    } else {\n      arr[i] \x3d this.getBits(i + arr_delta);\n    }\n  }\n  return new goog.math.Integer(arr, this.sign_);\n};\n");
SHADOW_ENV.evalLoad("goog.dom.htmlelement.js", true, "goog.provide(\x22goog.dom.HtmlElement\x22);\ngoog.dom.HtmlElement \x3d function() {\n};\n");
SHADOW_ENV.evalLoad("goog.dom.tagname.js", true, "goog.provide(\x22goog.dom.TagName\x22);\ngoog.require(\x22goog.dom.HtmlElement\x22);\ngoog.dom.TagName \x3d class {\n  static cast(name, type) {\n    return name;\n  }\n  constructor() {\n    this.googDomTagName_doNotImplementThisTypeOrElse_;\n    this.ensureTypeScriptRemembersTypeT_;\n  }\n  toString() {\n  }\n};\ngoog.dom.TagName.A \x3d \x22A\x22;\ngoog.dom.TagName.ABBR \x3d \x22ABBR\x22;\ngoog.dom.TagName.ACRONYM \x3d \x22ACRONYM\x22;\ngoog.dom.TagName.ADDRESS \x3d \x22ADDRESS\x22;\ngoog.dom.TagName.APPLET \x3d \x22APPLET\x22;\ngoog.dom.TagName.AREA \x3d \x22AREA\x22;\ngoog.dom.TagName.ARTICLE \x3d \x22ARTICLE\x22;\ngoog.dom.TagName.ASIDE \x3d \x22ASIDE\x22;\ngoog.dom.TagName.AUDIO \x3d \x22AUDIO\x22;\ngoog.dom.TagName.B \x3d \x22B\x22;\ngoog.dom.TagName.BASE \x3d \x22BASE\x22;\ngoog.dom.TagName.BASEFONT \x3d \x22BASEFONT\x22;\ngoog.dom.TagName.BDI \x3d \x22BDI\x22;\ngoog.dom.TagName.BDO \x3d \x22BDO\x22;\ngoog.dom.TagName.BIG \x3d \x22BIG\x22;\ngoog.dom.TagName.BLOCKQUOTE \x3d \x22BLOCKQUOTE\x22;\ngoog.dom.TagName.BODY \x3d \x22BODY\x22;\ngoog.dom.TagName.BR \x3d \x22BR\x22;\ngoog.dom.TagName.BUTTON \x3d \x22BUTTON\x22;\ngoog.dom.TagName.CANVAS \x3d \x22CANVAS\x22;\ngoog.dom.TagName.CAPTION \x3d \x22CAPTION\x22;\ngoog.dom.TagName.CENTER \x3d \x22CENTER\x22;\ngoog.dom.TagName.CITE \x3d \x22CITE\x22;\ngoog.dom.TagName.CODE \x3d \x22CODE\x22;\ngoog.dom.TagName.COL \x3d \x22COL\x22;\ngoog.dom.TagName.COLGROUP \x3d \x22COLGROUP\x22;\ngoog.dom.TagName.COMMAND \x3d \x22COMMAND\x22;\ngoog.dom.TagName.DATA \x3d \x22DATA\x22;\ngoog.dom.TagName.DATALIST \x3d \x22DATALIST\x22;\ngoog.dom.TagName.DD \x3d \x22DD\x22;\ngoog.dom.TagName.DEL \x3d \x22DEL\x22;\ngoog.dom.TagName.DETAILS \x3d \x22DETAILS\x22;\ngoog.dom.TagName.DFN \x3d \x22DFN\x22;\ngoog.dom.TagName.DIALOG \x3d \x22DIALOG\x22;\ngoog.dom.TagName.DIR \x3d \x22DIR\x22;\ngoog.dom.TagName.DIV \x3d \x22DIV\x22;\ngoog.dom.TagName.DL \x3d \x22DL\x22;\ngoog.dom.TagName.DT \x3d \x22DT\x22;\ngoog.dom.TagName.EM \x3d \x22EM\x22;\ngoog.dom.TagName.EMBED \x3d \x22EMBED\x22;\ngoog.dom.TagName.FIELDSET \x3d \x22FIELDSET\x22;\ngoog.dom.TagName.FIGCAPTION \x3d \x22FIGCAPTION\x22;\ngoog.dom.TagName.FIGURE \x3d \x22FIGURE\x22;\ngoog.dom.TagName.FONT \x3d \x22FONT\x22;\ngoog.dom.TagName.FOOTER \x3d \x22FOOTER\x22;\ngoog.dom.TagName.FORM \x3d \x22FORM\x22;\ngoog.dom.TagName.FRAME \x3d \x22FRAME\x22;\ngoog.dom.TagName.FRAMESET \x3d \x22FRAMESET\x22;\ngoog.dom.TagName.H1 \x3d \x22H1\x22;\ngoog.dom.TagName.H2 \x3d \x22H2\x22;\ngoog.dom.TagName.H3 \x3d \x22H3\x22;\ngoog.dom.TagName.H4 \x3d \x22H4\x22;\ngoog.dom.TagName.H5 \x3d \x22H5\x22;\ngoog.dom.TagName.H6 \x3d \x22H6\x22;\ngoog.dom.TagName.HEAD \x3d \x22HEAD\x22;\ngoog.dom.TagName.HEADER \x3d \x22HEADER\x22;\ngoog.dom.TagName.HGROUP \x3d \x22HGROUP\x22;\ngoog.dom.TagName.HR \x3d \x22HR\x22;\ngoog.dom.TagName.HTML \x3d \x22HTML\x22;\ngoog.dom.TagName.I \x3d \x22I\x22;\ngoog.dom.TagName.IFRAME \x3d \x22IFRAME\x22;\ngoog.dom.TagName.IMG \x3d \x22IMG\x22;\ngoog.dom.TagName.INPUT \x3d \x22INPUT\x22;\ngoog.dom.TagName.INS \x3d \x22INS\x22;\ngoog.dom.TagName.ISINDEX \x3d \x22ISINDEX\x22;\ngoog.dom.TagName.KBD \x3d \x22KBD\x22;\ngoog.dom.TagName.KEYGEN \x3d \x22KEYGEN\x22;\ngoog.dom.TagName.LABEL \x3d \x22LABEL\x22;\ngoog.dom.TagName.LEGEND \x3d \x22LEGEND\x22;\ngoog.dom.TagName.LI \x3d \x22LI\x22;\ngoog.dom.TagName.LINK \x3d \x22LINK\x22;\ngoog.dom.TagName.MAIN \x3d \x22MAIN\x22;\ngoog.dom.TagName.MAP \x3d \x22MAP\x22;\ngoog.dom.TagName.MARK \x3d \x22MARK\x22;\ngoog.dom.TagName.MATH \x3d \x22MATH\x22;\ngoog.dom.TagName.MENU \x3d \x22MENU\x22;\ngoog.dom.TagName.MENUITEM \x3d \x22MENUITEM\x22;\ngoog.dom.TagName.META \x3d \x22META\x22;\ngoog.dom.TagName.METER \x3d \x22METER\x22;\ngoog.dom.TagName.NAV \x3d \x22NAV\x22;\ngoog.dom.TagName.NOFRAMES \x3d \x22NOFRAMES\x22;\ngoog.dom.TagName.NOSCRIPT \x3d \x22NOSCRIPT\x22;\ngoog.dom.TagName.OBJECT \x3d \x22OBJECT\x22;\ngoog.dom.TagName.OL \x3d \x22OL\x22;\ngoog.dom.TagName.OPTGROUP \x3d \x22OPTGROUP\x22;\ngoog.dom.TagName.OPTION \x3d \x22OPTION\x22;\ngoog.dom.TagName.OUTPUT \x3d \x22OUTPUT\x22;\ngoog.dom.TagName.P \x3d \x22P\x22;\ngoog.dom.TagName.PARAM \x3d \x22PARAM\x22;\ngoog.dom.TagName.PICTURE \x3d \x22PICTURE\x22;\ngoog.dom.TagName.PRE \x3d \x22PRE\x22;\ngoog.dom.TagName.PROGRESS \x3d \x22PROGRESS\x22;\ngoog.dom.TagName.Q \x3d \x22Q\x22;\ngoog.dom.TagName.RP \x3d \x22RP\x22;\ngoog.dom.TagName.RT \x3d \x22RT\x22;\ngoog.dom.TagName.RTC \x3d \x22RTC\x22;\ngoog.dom.TagName.RUBY \x3d \x22RUBY\x22;\ngoog.dom.TagName.S \x3d \x22S\x22;\ngoog.dom.TagName.SAMP \x3d \x22SAMP\x22;\ngoog.dom.TagName.SCRIPT \x3d \x22SCRIPT\x22;\ngoog.dom.TagName.SECTION \x3d \x22SECTION\x22;\ngoog.dom.TagName.SELECT \x3d \x22SELECT\x22;\ngoog.dom.TagName.SMALL \x3d \x22SMALL\x22;\ngoog.dom.TagName.SOURCE \x3d \x22SOURCE\x22;\ngoog.dom.TagName.SPAN \x3d \x22SPAN\x22;\ngoog.dom.TagName.STRIKE \x3d \x22STRIKE\x22;\ngoog.dom.TagName.STRONG \x3d \x22STRONG\x22;\ngoog.dom.TagName.STYLE \x3d \x22STYLE\x22;\ngoog.dom.TagName.SUB \x3d \x22SUB\x22;\ngoog.dom.TagName.SUMMARY \x3d \x22SUMMARY\x22;\ngoog.dom.TagName.SUP \x3d \x22SUP\x22;\ngoog.dom.TagName.SVG \x3d \x22SVG\x22;\ngoog.dom.TagName.TABLE \x3d \x22TABLE\x22;\ngoog.dom.TagName.TBODY \x3d \x22TBODY\x22;\ngoog.dom.TagName.TD \x3d \x22TD\x22;\ngoog.dom.TagName.TEMPLATE \x3d \x22TEMPLATE\x22;\ngoog.dom.TagName.TEXTAREA \x3d \x22TEXTAREA\x22;\ngoog.dom.TagName.TFOOT \x3d \x22TFOOT\x22;\ngoog.dom.TagName.TH \x3d \x22TH\x22;\ngoog.dom.TagName.THEAD \x3d \x22THEAD\x22;\ngoog.dom.TagName.TIME \x3d \x22TIME\x22;\ngoog.dom.TagName.TITLE \x3d \x22TITLE\x22;\ngoog.dom.TagName.TR \x3d \x22TR\x22;\ngoog.dom.TagName.TRACK \x3d \x22TRACK\x22;\ngoog.dom.TagName.TT \x3d \x22TT\x22;\ngoog.dom.TagName.U \x3d \x22U\x22;\ngoog.dom.TagName.UL \x3d \x22UL\x22;\ngoog.dom.TagName.VAR \x3d \x22VAR\x22;\ngoog.dom.TagName.VIDEO \x3d \x22VIDEO\x22;\ngoog.dom.TagName.WBR \x3d \x22WBR\x22;\n");
SHADOW_ENV.evalLoad("goog.dom.element.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.dom.element\x22);\n  goog.module.declareLegacyNamespace();\n  const NodeType \x3d goog.require(\x22goog.dom.NodeType\x22);\n  const TagName \x3d goog.require(\x22goog.dom.TagName\x22);\n  const HTML_NAMESPACE \x3d \x22http://www.w3.org/1999/xhtml\x22;\n  const isElement \x3d value \x3d\x3e {\n    return goog.isObject(value) \x26\x26 value.nodeType \x3d\x3d\x3d NodeType.ELEMENT;\n  };\n  const isHtmlElement \x3d value \x3d\x3e {\n    return goog.isObject(value) \x26\x26 isElement(value) \x26\x26 (!value.namespaceURI || value.namespaceURI \x3d\x3d\x3d HTML_NAMESPACE);\n  };\n  const isHtmlElementOfType \x3d (value, tagName) \x3d\x3e {\n    return goog.isObject(value) \x26\x26 isHtmlElement(value) \x26\x26 value.tagName.toUpperCase() \x3d\x3d\x3d tagName.toString();\n  };\n  const isHtmlAnchorElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.A);\n  };\n  const isHtmlButtonElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.BUTTON);\n  };\n  const isHtmlLinkElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.LINK);\n  };\n  const isHtmlImageElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.IMG);\n  };\n  const isHtmlAudioElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.AUDIO);\n  };\n  const isHtmlVideoElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.VIDEO);\n  };\n  const isHtmlInputElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.INPUT);\n  };\n  const isHtmlTextAreaElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.TEXTAREA);\n  };\n  const isHtmlCanvasElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.CANVAS);\n  };\n  const isHtmlEmbedElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.EMBED);\n  };\n  const isHtmlFormElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.FORM);\n  };\n  const isHtmlFrameElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.FRAME);\n  };\n  const isHtmlIFrameElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.IFRAME);\n  };\n  const isHtmlObjectElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.OBJECT);\n  };\n  const isHtmlScriptElement \x3d value \x3d\x3e {\n    return isHtmlElementOfType(value, TagName.SCRIPT);\n  };\n  exports \x3d {isElement, isHtmlElement, isHtmlElementOfType, isHtmlAnchorElement, isHtmlButtonElement, isHtmlLinkElement, isHtmlImageElement, isHtmlAudioElement, isHtmlVideoElement, isHtmlInputElement, isHtmlTextAreaElement, isHtmlCanvasElement, isHtmlEmbedElement, isHtmlFormElement, isHtmlFrameElement, isHtmlIFrameElement, isHtmlObjectElement, isHtmlScriptElement};\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.asserts.dom.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.asserts.dom\x22);\n  goog.module.declareLegacyNamespace();\n  const TagName \x3d goog.require(\x22goog.dom.TagName\x22);\n  const asserts \x3d goog.require(\x22goog.asserts\x22);\n  const element \x3d goog.require(\x22goog.dom.element\x22);\n  const assertIsElement \x3d value \x3d\x3e {\n    if (asserts.ENABLE_ASSERTS \x26\x26 !element.isElement(value)) {\n      asserts.fail(`Argument is not an Element; got: ${debugStringForType(value)}`);\n    }\n    return value;\n  };\n  const assertIsHtmlElement \x3d value \x3d\x3e {\n    if (asserts.ENABLE_ASSERTS \x26\x26 !element.isHtmlElement(value)) {\n      asserts.fail(`Argument is not an HTML Element; got: ${debugStringForType(value)}`);\n    }\n    return value;\n  };\n  const assertIsHtmlElementOfType \x3d (value, tagName) \x3d\x3e {\n    if (asserts.ENABLE_ASSERTS \x26\x26 !element.isHtmlElementOfType(value, tagName)) {\n      asserts.fail(`Argument is not an HTML Element with tag name ` + `${tagName.toString()}; got: ${debugStringForType(value)}`);\n    }\n    return value;\n  };\n  const assertIsHtmlAnchorElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.A);\n  };\n  const assertIsHtmlButtonElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.BUTTON);\n  };\n  const assertIsHtmlLinkElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.LINK);\n  };\n  const assertIsHtmlImageElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.IMG);\n  };\n  const assertIsHtmlAudioElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.AUDIO);\n  };\n  const assertIsHtmlVideoElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.VIDEO);\n  };\n  const assertIsHtmlInputElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.INPUT);\n  };\n  const assertIsHtmlTextAreaElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.TEXTAREA);\n  };\n  const assertIsHtmlCanvasElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.CANVAS);\n  };\n  const assertIsHtmlEmbedElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.EMBED);\n  };\n  const assertIsHtmlFormElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.FORM);\n  };\n  const assertIsHtmlFrameElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.FRAME);\n  };\n  const assertIsHtmlIFrameElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.IFRAME);\n  };\n  const assertIsHtmlObjectElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.OBJECT);\n  };\n  const assertIsHtmlScriptElement \x3d value \x3d\x3e {\n    return assertIsHtmlElementOfType(value, TagName.SCRIPT);\n  };\n  const debugStringForType \x3d value \x3d\x3e {\n    if (goog.isObject(value)) {\n      try {\n        return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);\n      } catch (e) {\n        return \x22\\x3cobject could not be stringified\\x3e\x22;\n      }\n    } else {\n      return value \x3d\x3d\x3d undefined ? \x22undefined\x22 : value \x3d\x3d\x3d null ? \x22null\x22 : typeof value;\n    }\n  };\n  exports \x3d {assertIsElement, assertIsHtmlElement, assertIsHtmlElementOfType, assertIsHtmlAnchorElement, assertIsHtmlButtonElement, assertIsHtmlLinkElement, assertIsHtmlImageElement, assertIsHtmlAudioElement, assertIsHtmlVideoElement, assertIsHtmlInputElement, assertIsHtmlTextAreaElement, assertIsHtmlCanvasElement, assertIsHtmlEmbedElement, assertIsHtmlFormElement, assertIsHtmlFrameElement, assertIsHtmlIFrameElement, assertIsHtmlObjectElement, assertIsHtmlScriptElement};\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.dom.asserts.js", true, "goog.provide(\x22goog.dom.asserts\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.dom.asserts.assertIsLocation \x3d function(o) {\n  if (goog.asserts.ENABLE_ASSERTS) {\n    var win \x3d goog.dom.asserts.getWindow_(o);\n    if (win) {\n      if (!o || !(o instanceof win.Location) \x26\x26 o instanceof win.Element) {\n        goog.asserts.fail(\x22Argument is not a Location (or a non-Element mock); got: %s\x22, goog.dom.asserts.debugStringForType_(o));\n      }\n    }\n  }\n  return o;\n};\ngoog.dom.asserts.debugStringForType_ \x3d function(value) {\n  if (goog.isObject(value)) {\n    try {\n      return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);\n    } catch (e) {\n      return \x22\\x3cobject could not be stringified\\x3e\x22;\n    }\n  } else {\n    return value \x3d\x3d\x3d undefined ? \x22undefined\x22 : value \x3d\x3d\x3d null ? \x22null\x22 : typeof value;\n  }\n};\ngoog.dom.asserts.getWindow_ \x3d function(o) {\n  try {\n    var doc \x3d o \x26\x26 o.ownerDocument;\n    var win \x3d doc \x26\x26 (doc.defaultView || doc.parentWindow);\n    win \x3d win || goog.global;\n    if (win.Element \x26\x26 win.Location) {\n      return win;\n    }\n  } catch (ex) {\n  }\n  return null;\n};\n");
SHADOW_ENV.evalLoad("goog.functions.functions.js", true, "goog.provide(\x22goog.functions\x22);\ngoog.functions.constant \x3d function(retValue) {\n  return function() {\n    return retValue;\n  };\n};\ngoog.functions.FALSE \x3d function() {\n  return false;\n};\ngoog.functions.TRUE \x3d function() {\n  return true;\n};\ngoog.functions.NULL \x3d function() {\n  return null;\n};\ngoog.functions.UNDEFINED \x3d function() {\n  return undefined;\n};\ngoog.functions.EMPTY \x3d goog.functions.UNDEFINED;\ngoog.functions.identity \x3d function(opt_returnValue, var_args) {\n  return opt_returnValue;\n};\ngoog.functions.error \x3d function(message) {\n  return function() {\n    throw new Error(message);\n  };\n};\ngoog.functions.fail \x3d function(err) {\n  return function() {\n    throw err;\n  };\n};\ngoog.functions.lock \x3d function(f, opt_numArgs) {\n  opt_numArgs \x3d opt_numArgs || 0;\n  return function() {\n    const self \x3d this;\n    return f.apply(self, Array.prototype.slice.call(arguments, 0, opt_numArgs));\n  };\n};\ngoog.functions.nth \x3d function(n) {\n  return function() {\n    return arguments[n];\n  };\n};\ngoog.functions.partialRight \x3d function(fn, var_args) {\n  const rightArgs \x3d Array.prototype.slice.call(arguments, 1);\n  return function() {\n    let self \x3d this;\n    if (self \x3d\x3d\x3d goog.global) {\n      self \x3d undefined;\n    }\n    const newArgs \x3d Array.prototype.slice.call(arguments);\n    newArgs.push.apply(newArgs, rightArgs);\n    return fn.apply(self, newArgs);\n  };\n};\ngoog.functions.withReturnValue \x3d function(f, retValue) {\n  return goog.functions.sequence(f, goog.functions.constant(retValue));\n};\ngoog.functions.equalTo \x3d function(value, opt_useLooseComparison) {\n  return function(other) {\n    return opt_useLooseComparison ? value \x3d\x3d other : value \x3d\x3d\x3d other;\n  };\n};\ngoog.functions.compose \x3d function(fn, var_args) {\n  const functions \x3d arguments;\n  const length \x3d functions.length;\n  return function() {\n    const self \x3d this;\n    let result;\n    if (length) {\n      result \x3d functions[length - 1].apply(self, arguments);\n    }\n    for (let i \x3d length - 2; i \x3e\x3d 0; i--) {\n      result \x3d functions[i].call(self, result);\n    }\n    return result;\n  };\n};\ngoog.functions.sequence \x3d function(var_args) {\n  const functions \x3d arguments;\n  const length \x3d functions.length;\n  return function() {\n    const self \x3d this;\n    let result;\n    for (let i \x3d 0; i \x3c length; i++) {\n      result \x3d functions[i].apply(self, arguments);\n    }\n    return result;\n  };\n};\ngoog.functions.and \x3d function(var_args) {\n  const functions \x3d arguments;\n  const length \x3d functions.length;\n  return function() {\n    const self \x3d this;\n    for (let i \x3d 0; i \x3c length; i++) {\n      if (!functions[i].apply(self, arguments)) {\n        return false;\n      }\n    }\n    return true;\n  };\n};\ngoog.functions.or \x3d function(var_args) {\n  const functions \x3d arguments;\n  const length \x3d functions.length;\n  return function() {\n    const self \x3d this;\n    for (let i \x3d 0; i \x3c length; i++) {\n      if (functions[i].apply(self, arguments)) {\n        return true;\n      }\n    }\n    return false;\n  };\n};\ngoog.functions.not \x3d function(f) {\n  return function() {\n    const self \x3d this;\n    return !f.apply(self, arguments);\n  };\n};\ngoog.functions.create \x3d function(constructor, var_args) {\n  const temp \x3d function() {\n  };\n  temp.prototype \x3d constructor.prototype;\n  const obj \x3d new temp();\n  constructor.apply(obj, Array.prototype.slice.call(arguments, 1));\n  return obj;\n};\ngoog.functions.CACHE_RETURN_VALUE \x3d goog.define(\x22goog.functions.CACHE_RETURN_VALUE\x22, true);\ngoog.functions.cacheReturnValue \x3d function(fn) {\n  let called \x3d false;\n  let value;\n  return function() {\n    if (!goog.functions.CACHE_RETURN_VALUE) {\n      return fn();\n    }\n    if (!called) {\n      value \x3d fn();\n      called \x3d true;\n    }\n    return value;\n  };\n};\ngoog.functions.once \x3d function(f) {\n  let inner \x3d f;\n  return function() {\n    if (inner) {\n      const tmp \x3d inner;\n      inner \x3d null;\n      tmp();\n    }\n  };\n};\ngoog.functions.debounce \x3d function(f, interval, opt_scope) {\n  let timeout \x3d 0;\n  return function(var_args) {\n    goog.global.clearTimeout(timeout);\n    const args \x3d arguments;\n    timeout \x3d goog.global.setTimeout(function() {\n      f.apply(opt_scope, args);\n    }, interval);\n  };\n};\ngoog.functions.throttle \x3d function(f, interval, opt_scope) {\n  let timeout \x3d 0;\n  let shouldFire \x3d false;\n  let storedArgs \x3d [];\n  const handleTimeout \x3d function() {\n    timeout \x3d 0;\n    if (shouldFire) {\n      shouldFire \x3d false;\n      fire();\n    }\n  };\n  const fire \x3d function() {\n    timeout \x3d goog.global.setTimeout(handleTimeout, interval);\n    let args \x3d storedArgs;\n    storedArgs \x3d [];\n    f.apply(opt_scope, args);\n  };\n  return function(var_args) {\n    storedArgs \x3d arguments;\n    if (!timeout) {\n      fire();\n    } else {\n      shouldFire \x3d true;\n    }\n  };\n};\ngoog.functions.rateLimit \x3d function(f, interval, opt_scope) {\n  let timeout \x3d 0;\n  const handleTimeout \x3d function() {\n    timeout \x3d 0;\n  };\n  return function(var_args) {\n    if (!timeout) {\n      timeout \x3d goog.global.setTimeout(handleTimeout, interval);\n      f.apply(opt_scope, arguments);\n    }\n  };\n};\ngoog.functions.isFunction \x3d val \x3d\x3e {\n  return typeof val \x3d\x3d\x3d \x22function\x22;\n};\n");
SHADOW_ENV.evalLoad("goog.string.typedstring.js", true, "goog.provide(\x22goog.string.TypedString\x22);\ngoog.string.TypedString \x3d function() {\n};\ngoog.string.TypedString.prototype.implementsGoogStringTypedString;\ngoog.string.TypedString.prototype.getTypedStringValue;\n");
SHADOW_ENV.evalLoad("goog.string.const.js", true, "goog.provide(\x22goog.string.Const\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.string.TypedString\x22);\ngoog.string.Const \x3d function(opt_token, opt_content) {\n  this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ \x3d opt_token \x3d\x3d\x3d goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_ \x26\x26 opt_content || \x22\x22;\n  this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ \x3d goog.string.Const.TYPE_MARKER_;\n};\ngoog.string.Const.prototype.implementsGoogStringTypedString \x3d true;\ngoog.string.Const.prototype.getTypedStringValue \x3d function() {\n  return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_;\n};\nif (goog.DEBUG) {\n  goog.string.Const.prototype.toString \x3d function() {\n    return \x22Const{\x22 + this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ + \x22}\x22;\n  };\n}\ngoog.string.Const.unwrap \x3d function(stringConst) {\n  if (stringConst instanceof goog.string.Const \x26\x26 stringConst.constructor \x3d\x3d\x3d goog.string.Const \x26\x26 stringConst.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ \x3d\x3d\x3d goog.string.Const.TYPE_MARKER_) {\n    return stringConst.stringConstValueWithSecurityContract__googStringSecurityPrivate_;\n  } else {\n    goog.asserts.fail(\x22expected object of type Const, got \x27\x22 + stringConst + \x22\x27\x22);\n    return \x22type_error:Const\x22;\n  }\n};\ngoog.string.Const.from \x3d function(s) {\n  return new goog.string.Const(goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_, s);\n};\ngoog.string.Const.TYPE_MARKER_ \x3d {};\ngoog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_ \x3d {};\ngoog.string.Const.EMPTY \x3d goog.string.Const.from(\x22\x22);\n");
SHADOW_ENV.evalLoad("goog.html.trustedtypes.js", true, "goog.provide(\x22goog.html.trustedtypes\x22);\ngoog.html.trustedtypes.POLICY_NAME \x3d goog.define(\x22goog.html.trustedtypes.POLICY_NAME\x22, goog.TRUSTED_TYPES_POLICY_NAME ? goog.TRUSTED_TYPES_POLICY_NAME + \x22#html\x22 : \x22\x22);\ngoog.html.trustedtypes.cachedPolicy_;\ngoog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse \x3d function() {\n  if (!goog.html.trustedtypes.POLICY_NAME) {\n    return null;\n  }\n  if (goog.html.trustedtypes.cachedPolicy_ \x3d\x3d\x3d undefined) {\n    goog.html.trustedtypes.cachedPolicy_ \x3d goog.createTrustedTypesPolicy(goog.html.trustedtypes.POLICY_NAME);\n  }\n  return goog.html.trustedtypes.cachedPolicy_;\n};\n");
SHADOW_ENV.evalLoad("goog.html.safescript.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.html.SafeScript\x22);\n  goog.module.declareLegacyNamespace();\n  const Const \x3d goog.require(\x22goog.string.Const\x22);\n  const TypedString \x3d goog.require(\x22goog.string.TypedString\x22);\n  const trustedtypes \x3d goog.require(\x22goog.html.trustedtypes\x22);\n  const {fail} \x3d goog.require(\x22goog.asserts\x22);\n  const CONSTRUCTOR_TOKEN_PRIVATE \x3d {};\n  class SafeScript {\n    constructor(value, token) {\n      this.privateDoNotAccessOrElseSafeScriptWrappedValue_ \x3d token \x3d\x3d\x3d CONSTRUCTOR_TOKEN_PRIVATE ? value : \x22\x22;\n      this.implementsGoogStringTypedString \x3d true;\n    }\n    toString() {\n      return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString();\n    }\n    static fromConstant(script) {\n      const scriptString \x3d Const.unwrap(script);\n      if (scriptString.length \x3d\x3d\x3d 0) {\n        return SafeScript.EMPTY;\n      }\n      return SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(scriptString);\n    }\n    static fromJson(val) {\n      return SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(SafeScript.stringify_(val));\n    }\n    getTypedStringValue() {\n      return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString();\n    }\n    static unwrap(safeScript) {\n      return SafeScript.unwrapTrustedScript(safeScript).toString();\n    }\n    static unwrapTrustedScript(safeScript) {\n      if (safeScript instanceof SafeScript \x26\x26 safeScript.constructor \x3d\x3d\x3d SafeScript) {\n        return safeScript.privateDoNotAccessOrElseSafeScriptWrappedValue_;\n      } else {\n        fail(\x22expected object of type SafeScript, got \x27\x22 + safeScript + \x22\x27 of type \x22 + goog.typeOf(safeScript));\n        return \x22type_error:SafeScript\x22;\n      }\n    }\n    static stringify_(val) {\n      const json \x3d JSON.stringify(val);\n      return json.replace(/\x3c/g, \x22\\\\x3c\x22);\n    }\n    static createSafeScriptSecurityPrivateDoNotAccessOrElse(script) {\n      const noinlineScript \x3d script;\n      const policy \x3d trustedtypes.getPolicyPrivateDoNotAccessOrElse();\n      const trustedScript \x3d policy ? policy.createScript(noinlineScript) : noinlineScript;\n      return new SafeScript(trustedScript, CONSTRUCTOR_TOKEN_PRIVATE);\n    }\n  }\n  SafeScript.EMPTY \x3d {valueOf:function() {\n    return SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(\x22\x22);\n  }}.valueOf();\n  exports \x3d SafeScript;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.fs.url.js", true, "goog.provide(\x22goog.fs.url\x22);\ngoog.fs.url.createObjectUrl \x3d function(obj) {\n  return goog.fs.url.getUrlObject_().createObjectURL(obj);\n};\ngoog.fs.url.revokeObjectUrl \x3d function(url) {\n  goog.fs.url.getUrlObject_().revokeObjectURL(url);\n};\ngoog.fs.url.UrlObject_ \x3d function() {\n};\ngoog.fs.url.UrlObject_.prototype.createObjectURL \x3d function(arg) {\n};\ngoog.fs.url.UrlObject_.prototype.revokeObjectURL \x3d function(s) {\n};\ngoog.fs.url.getUrlObject_ \x3d function() {\n  const urlObject \x3d goog.fs.url.findUrlObject_();\n  if (urlObject !\x3d null) {\n    return urlObject;\n  } else {\n    throw new Error(\x22This browser doesn\x27t seem to support blob URLs\x22);\n  }\n};\ngoog.fs.url.findUrlObject_ \x3d function() {\n  if (goog.global.URL !\x3d\x3d undefined \x26\x26 goog.global.URL.createObjectURL !\x3d\x3d undefined) {\n    return goog.global.URL;\n  } else if (goog.global.createObjectURL !\x3d\x3d undefined) {\n    return goog.global;\n  } else {\n    return null;\n  }\n};\ngoog.fs.url.browserSupportsObjectUrls \x3d function() {\n  return goog.fs.url.findUrlObject_() !\x3d null;\n};\n");
SHADOW_ENV.evalLoad("goog.fs.blob.js", true, "goog.provide(\x22goog.fs.blob\x22);\ngoog.fs.blob.getBlob \x3d function(var_args) {\n  const BlobBuilder \x3d goog.global.BlobBuilder || goog.global.WebKitBlobBuilder;\n  if (BlobBuilder !\x3d\x3d undefined) {\n    const bb \x3d new BlobBuilder();\n    for (let i \x3d 0; i \x3c arguments.length; i++) {\n      bb.append(arguments[i]);\n    }\n    return bb.getBlob();\n  } else {\n    return goog.fs.blob.getBlobWithProperties(Array.prototype.slice.call(arguments));\n  }\n};\ngoog.fs.blob.getBlobWithProperties \x3d function(parts, opt_type, opt_endings) {\n  const BlobBuilder \x3d goog.global.BlobBuilder || goog.global.WebKitBlobBuilder;\n  if (BlobBuilder !\x3d\x3d undefined) {\n    const bb \x3d new BlobBuilder();\n    for (let i \x3d 0; i \x3c parts.length; i++) {\n      bb.append(parts[i], opt_endings);\n    }\n    return bb.getBlob(opt_type);\n  } else if (goog.global.Blob !\x3d\x3d undefined) {\n    const properties \x3d {};\n    if (opt_type) {\n      properties[\x22type\x22] \x3d opt_type;\n    }\n    if (opt_endings) {\n      properties[\x22endings\x22] \x3d opt_endings;\n    }\n    return new Blob(parts, properties);\n  } else {\n    throw new Error(\x22This browser doesn\x27t seem to support creating Blobs\x22);\n  }\n};\n");
SHADOW_ENV.evalLoad("goog.html.trustedresourceurl.js", true, "goog.provide(\x22goog.html.TrustedResourceUrl\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.fs.blob\x22);\ngoog.require(\x22goog.fs.url\x22);\ngoog.require(\x22goog.html.SafeScript\x22);\ngoog.require(\x22goog.html.trustedtypes\x22);\ngoog.require(\x22goog.string.Const\x22);\ngoog.require(\x22goog.string.TypedString\x22);\ngoog.html.TrustedResourceUrl \x3d class {\n  constructor(value, token) {\n    this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ \x3d token \x3d\x3d\x3d goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_ ? value : \x22\x22;\n  }\n  toString() {\n    return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ + \x22\x22;\n  }\n};\ngoog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString \x3d true;\ngoog.html.TrustedResourceUrl.prototype.getTypedStringValue \x3d function() {\n  return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_.toString();\n};\ngoog.html.TrustedResourceUrl.prototype.cloneWithParams \x3d function(searchParams, opt_hashParams) {\n  var url \x3d goog.html.TrustedResourceUrl.unwrap(this);\n  var parts \x3d goog.html.TrustedResourceUrl.URL_PARAM_PARSER_.exec(url);\n  var urlBase \x3d parts[1];\n  var urlSearch \x3d parts[2] || \x22\x22;\n  var urlHash \x3d parts[3] || \x22\x22;\n  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(urlBase + goog.html.TrustedResourceUrl.stringifyParams_(\x22?\x22, urlSearch, searchParams) + goog.html.TrustedResourceUrl.stringifyParams_(\x22#\x22, urlHash, opt_hashParams));\n};\ngoog.html.TrustedResourceUrl.unwrap \x3d function(trustedResourceUrl) {\n  return goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(trustedResourceUrl).toString();\n};\ngoog.html.TrustedResourceUrl.unwrapTrustedScriptURL \x3d function(trustedResourceUrl) {\n  if (trustedResourceUrl instanceof goog.html.TrustedResourceUrl \x26\x26 trustedResourceUrl.constructor \x3d\x3d\x3d goog.html.TrustedResourceUrl) {\n    return trustedResourceUrl.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;\n  } else {\n    goog.asserts.fail(\x22expected object of type TrustedResourceUrl, got \x27\x22 + trustedResourceUrl + \x22\x27 of type \x22 + goog.typeOf(trustedResourceUrl));\n    return \x22type_error:TrustedResourceUrl\x22;\n  }\n};\ngoog.html.TrustedResourceUrl.format \x3d function(format, args) {\n  var formatStr \x3d goog.string.Const.unwrap(format);\n  if (!goog.html.TrustedResourceUrl.BASE_URL_.test(formatStr)) {\n    throw new Error(\x22Invalid TrustedResourceUrl format: \x22 + formatStr);\n  }\n  var result \x3d formatStr.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_, function(match, id) {\n    if (!Object.prototype.hasOwnProperty.call(args, id)) {\n      throw new Error(\x27Found marker, \x22\x27 + id + \x27\x22, in format string, \x22\x27 + formatStr + \x27\x22, but no valid label mapping found \x27 + \x22in args: \x22 + JSON.stringify(args));\n    }\n    var arg \x3d args[id];\n    if (arg instanceof goog.string.Const) {\n      return goog.string.Const.unwrap(arg);\n    } else {\n      return encodeURIComponent(String(arg));\n    }\n  });\n  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(result);\n};\ngoog.html.TrustedResourceUrl.FORMAT_MARKER_ \x3d /%{(\\w+)}/g;\ngoog.html.TrustedResourceUrl.BASE_URL_ \x3d new RegExp(\x22^((https:)?//[0-9a-z.:[\\\\]-]+/\x22 + \x22|/[^/\\\\\\\\]\x22 + \x22|[^:/\\\\\\\\%]+/\x22 + \x22|[^:/\\\\\\\\%]*[?#]\x22 + \x22|about:blank#\x22 + \x22)\x22, \x22i\x22);\ngoog.html.TrustedResourceUrl.URL_PARAM_PARSER_ \x3d /^([^?#]*)(\\?[^#]*)?(#[\\s\\S]*)?/;\ngoog.html.TrustedResourceUrl.formatWithParams \x3d function(format, args, searchParams, opt_hashParams) {\n  var url \x3d goog.html.TrustedResourceUrl.format(format, args);\n  return url.cloneWithParams(searchParams, opt_hashParams);\n};\ngoog.html.TrustedResourceUrl.fromConstant \x3d function(url) {\n  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(url));\n};\ngoog.html.TrustedResourceUrl.fromConstants \x3d function(parts) {\n  var unwrapped \x3d \x22\x22;\n  var i \x3d 0;\n  for (; i \x3c parts.length; i++) {\n    unwrapped \x3d unwrapped + goog.string.Const.unwrap(parts[i]);\n  }\n  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(unwrapped);\n};\ngoog.html.TrustedResourceUrl.fromSafeScript \x3d function(safeScript) {\n  var blob \x3d goog.fs.blob.getBlobWithProperties([goog.html.SafeScript.unwrap(safeScript)], \x22text/javascript\x22);\n  var url \x3d goog.fs.url.createObjectUrl(blob);\n  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_ \x3d {};\ngoog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse \x3d function(url) {\n  const noinlineUrl \x3d url;\n  const policy \x3d goog.html.trustedtypes.getPolicyPrivateDoNotAccessOrElse();\n  const value \x3d policy ? policy.createScriptURL(noinlineUrl) : noinlineUrl;\n  return new goog.html.TrustedResourceUrl(value, goog.html.TrustedResourceUrl.CONSTRUCTOR_TOKEN_PRIVATE_);\n};\ngoog.html.TrustedResourceUrl.stringifyParams_ \x3d function(prefix, currentString, params) {\n  if (params \x3d\x3d null) {\n    return currentString;\n  }\n  if (typeof params \x3d\x3d\x3d \x22string\x22) {\n    return params ? prefix + encodeURIComponent(params) : \x22\x22;\n  }\n  var key;\n  for (key in params) {\n    if (Object.prototype.hasOwnProperty.call(params, key)) {\n      var value \x3d params[key];\n      var outputValues \x3d Array.isArray(value) ? value : [value];\n      var i \x3d 0;\n      for (; i \x3c outputValues.length; i++) {\n        var outputValue \x3d outputValues[i];\n        if (outputValue !\x3d null) {\n          if (!currentString) {\n            currentString \x3d prefix;\n          }\n          currentString \x3d currentString + ((currentString.length \x3e prefix.length ? \x22\\x26\x22 : \x22\x22) + encodeURIComponent(key) + \x22\\x3d\x22 + encodeURIComponent(String(outputValue)));\n        }\n      }\n    }\n  }\n  return currentString;\n};\n");
SHADOW_ENV.evalLoad("goog.string.internal.js", true, "goog.provide(\x22goog.string.internal\x22);\ngoog.string.internal.startsWith \x3d function(str, prefix) {\n  return str.lastIndexOf(prefix, 0) \x3d\x3d 0;\n};\ngoog.string.internal.endsWith \x3d function(str, suffix) {\n  const l \x3d str.length - suffix.length;\n  return l \x3e\x3d 0 \x26\x26 str.indexOf(suffix, l) \x3d\x3d l;\n};\ngoog.string.internal.caseInsensitiveStartsWith \x3d function(str, prefix) {\n  return goog.string.internal.caseInsensitiveCompare(prefix, str.slice(0, prefix.length)) \x3d\x3d 0;\n};\ngoog.string.internal.caseInsensitiveEndsWith \x3d function(str, suffix) {\n  return goog.string.internal.caseInsensitiveCompare(suffix, str.slice(str.length - suffix.length)) \x3d\x3d 0;\n};\ngoog.string.internal.caseInsensitiveEquals \x3d function(str1, str2) {\n  return str1.toLowerCase() \x3d\x3d str2.toLowerCase();\n};\ngoog.string.internal.isEmptyOrWhitespace \x3d function(str) {\n  return /^[\\s\\xa0]*$/.test(str);\n};\ngoog.string.internal.trim \x3d goog.TRUSTED_SITE \x26\x26 String.prototype.trim ? function(str) {\n  return str.trim();\n} : function(str) {\n  return /^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(str)[1];\n};\ngoog.string.internal.caseInsensitiveCompare \x3d function(str1, str2) {\n  const test1 \x3d String(str1).toLowerCase();\n  const test2 \x3d String(str2).toLowerCase();\n  if (test1 \x3c test2) {\n    return -1;\n  } else if (test1 \x3d\x3d test2) {\n    return 0;\n  } else {\n    return 1;\n  }\n};\ngoog.string.internal.newLineToBr \x3d function(str, opt_xml) {\n  return str.replace(/(\\r\\n|\\r|\\n)/g, opt_xml ? \x22\\x3cbr /\\x3e\x22 : \x22\\x3cbr\\x3e\x22);\n};\ngoog.string.internal.htmlEscape \x3d function(str, opt_isLikelyToContainHtmlChars) {\n  if (opt_isLikelyToContainHtmlChars) {\n    str \x3d str.replace(goog.string.internal.AMP_RE_, \x22\\x26amp;\x22).replace(goog.string.internal.LT_RE_, \x22\\x26lt;\x22).replace(goog.string.internal.GT_RE_, \x22\\x26gt;\x22).replace(goog.string.internal.QUOT_RE_, \x22\\x26quot;\x22).replace(goog.string.internal.SINGLE_QUOTE_RE_, \x22\\x26#39;\x22).replace(goog.string.internal.NULL_RE_, \x22\\x26#0;\x22);\n    return str;\n  } else {\n    if (!goog.string.internal.ALL_RE_.test(str)) {\n      return str;\n    }\n    if (str.indexOf(\x22\\x26\x22) !\x3d -1) {\n      str \x3d str.replace(goog.string.internal.AMP_RE_, \x22\\x26amp;\x22);\n    }\n    if (str.indexOf(\x22\\x3c\x22) !\x3d -1) {\n      str \x3d str.replace(goog.string.internal.LT_RE_, \x22\\x26lt;\x22);\n    }\n    if (str.indexOf(\x22\\x3e\x22) !\x3d -1) {\n      str \x3d str.replace(goog.string.internal.GT_RE_, \x22\\x26gt;\x22);\n    }\n    if (str.indexOf(\x27\x22\x27) !\x3d -1) {\n      str \x3d str.replace(goog.string.internal.QUOT_RE_, \x22\\x26quot;\x22);\n    }\n    if (str.indexOf(\x22\x27\x22) !\x3d -1) {\n      str \x3d str.replace(goog.string.internal.SINGLE_QUOTE_RE_, \x22\\x26#39;\x22);\n    }\n    if (str.indexOf(\x22\\x00\x22) !\x3d -1) {\n      str \x3d str.replace(goog.string.internal.NULL_RE_, \x22\\x26#0;\x22);\n    }\n    return str;\n  }\n};\ngoog.string.internal.AMP_RE_ \x3d /\x26/g;\ngoog.string.internal.LT_RE_ \x3d /\x3c/g;\ngoog.string.internal.GT_RE_ \x3d /\x3e/g;\ngoog.string.internal.QUOT_RE_ \x3d /\x22/g;\ngoog.string.internal.SINGLE_QUOTE_RE_ \x3d /\x27/g;\ngoog.string.internal.NULL_RE_ \x3d /\\x00/g;\ngoog.string.internal.ALL_RE_ \x3d /[\\x00\x26\x3c\x3e\x22\x27]/;\ngoog.string.internal.whitespaceEscape \x3d function(str, opt_xml) {\n  return goog.string.internal.newLineToBr(str.replace(/  /g, \x22 \\x26#160;\x22), opt_xml);\n};\ngoog.string.internal.contains \x3d function(str, subString) {\n  return str.indexOf(subString) !\x3d -1;\n};\ngoog.string.internal.caseInsensitiveContains \x3d function(str, subString) {\n  return goog.string.internal.contains(str.toLowerCase(), subString.toLowerCase());\n};\ngoog.string.internal.compareVersions \x3d function(version1, version2) {\n  let order \x3d 0;\n  const v1Subs \x3d goog.string.internal.trim(String(version1)).split(\x22.\x22);\n  const v2Subs \x3d goog.string.internal.trim(String(version2)).split(\x22.\x22);\n  const subCount \x3d Math.max(v1Subs.length, v2Subs.length);\n  for (let subIdx \x3d 0; order \x3d\x3d 0 \x26\x26 subIdx \x3c subCount; subIdx++) {\n    let v1Sub \x3d v1Subs[subIdx] || \x22\x22;\n    let v2Sub \x3d v2Subs[subIdx] || \x22\x22;\n    do {\n      const v1Comp \x3d /(\\d*)(\\D*)(.*)/.exec(v1Sub) || [\x22\x22, \x22\x22, \x22\x22, \x22\x22];\n      const v2Comp \x3d /(\\d*)(\\D*)(.*)/.exec(v2Sub) || [\x22\x22, \x22\x22, \x22\x22, \x22\x22];\n      if (v1Comp[0].length \x3d\x3d 0 \x26\x26 v2Comp[0].length \x3d\x3d 0) {\n        break;\n      }\n      const v1CompNum \x3d v1Comp[1].length \x3d\x3d 0 ? 0 : parseInt(v1Comp[1], 10);\n      const v2CompNum \x3d v2Comp[1].length \x3d\x3d 0 ? 0 : parseInt(v2Comp[1], 10);\n      order \x3d goog.string.internal.compareElements_(v1CompNum, v2CompNum) || goog.string.internal.compareElements_(v1Comp[2].length \x3d\x3d 0, v2Comp[2].length \x3d\x3d 0) || goog.string.internal.compareElements_(v1Comp[2], v2Comp[2]);\n      v1Sub \x3d v1Comp[3];\n      v2Sub \x3d v2Comp[3];\n    } while (order \x3d\x3d 0);\n  }\n  return order;\n};\ngoog.string.internal.compareElements_ \x3d function(left, right) {\n  if (left \x3c right) {\n    return -1;\n  } else if (left \x3e right) {\n    return 1;\n  }\n  return 0;\n};\n");
SHADOW_ENV.evalLoad("goog.html.safeurl.js", true, "goog.provide(\x22goog.html.SafeUrl\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.fs.url\x22);\ngoog.require(\x22goog.html.TrustedResourceUrl\x22);\ngoog.require(\x22goog.string.Const\x22);\ngoog.require(\x22goog.string.TypedString\x22);\ngoog.require(\x22goog.string.internal\x22);\ngoog.html.SafeUrl \x3d class {\n  constructor(value, token) {\n    this.privateDoNotAccessOrElseSafeUrlWrappedValue_ \x3d token \x3d\x3d\x3d goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_ ? value : \x22\x22;\n  }\n  toString() {\n    return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString();\n  }\n};\ngoog.html.SafeUrl.INNOCUOUS_STRING \x3d \x22about:invalid#zClosurez\x22;\ngoog.html.SafeUrl.prototype.implementsGoogStringTypedString \x3d true;\ngoog.html.SafeUrl.prototype.getTypedStringValue \x3d function() {\n  return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString();\n};\ngoog.html.SafeUrl.unwrap \x3d function(safeUrl) {\n  if (safeUrl instanceof goog.html.SafeUrl \x26\x26 safeUrl.constructor \x3d\x3d\x3d goog.html.SafeUrl) {\n    return safeUrl.privateDoNotAccessOrElseSafeUrlWrappedValue_;\n  } else {\n    goog.asserts.fail(\x22expected object of type SafeUrl, got \x27\x22 + safeUrl + \x22\x27 of type \x22 + goog.typeOf(safeUrl));\n    return \x22type_error:SafeUrl\x22;\n  }\n};\ngoog.html.SafeUrl.fromConstant \x3d function(url) {\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(url));\n};\ngoog.html.SAFE_MIME_TYPE_PATTERN_ \x3d new RegExp(\x22^(?:audio/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-matroska|x-wav|wav|webm)|\x22 + \x22font/\\\\w+|\x22 + \x22image/(?:bmp|gif|jpeg|jpg|png|tiff|webp|x-icon|heic|heif)|\x22 + \x22video/(?:mpeg|mp4|ogg|webm|quicktime|x-matroska))\x22 + \x27(?:;\\\\w+\\x3d(?:\\\\w+|\x22[\\\\w;,\\x3d ]+\x22))*$\x27, \x22i\x22);\ngoog.html.SafeUrl.isSafeMimeType \x3d function(mimeType) {\n  return goog.html.SAFE_MIME_TYPE_PATTERN_.test(mimeType);\n};\ngoog.html.SafeUrl.fromBlob \x3d function(blob) {\n  var url \x3d goog.html.SafeUrl.isSafeMimeType(blob.type) ? goog.fs.url.createObjectUrl(blob) : goog.html.SafeUrl.INNOCUOUS_STRING;\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.SafeUrl.revokeObjectUrl \x3d function(safeUrl) {\n  var url \x3d safeUrl.getTypedStringValue();\n  if (url !\x3d\x3d goog.html.SafeUrl.INNOCUOUS_STRING) {\n    goog.fs.url.revokeObjectUrl(url);\n  }\n};\ngoog.html.SafeUrl.fromMediaSource \x3d function(mediaSource) {\n  goog.asserts.assert(\x22MediaSource\x22 in goog.global, \x22No support for MediaSource\x22);\n  const url \x3d mediaSource instanceof MediaSource ? goog.fs.url.createObjectUrl(mediaSource) : goog.html.SafeUrl.INNOCUOUS_STRING;\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.DATA_URL_PATTERN_ \x3d /^data:(.*);base64,[a-z0-9+\\/]+\x3d*$/i;\ngoog.html.SafeUrl.tryFromDataUrl \x3d function(dataUrl) {\n  dataUrl \x3d String(dataUrl);\n  var filteredDataUrl \x3d dataUrl.replace(/(%0A|%0D)/g, \x22\x22);\n  var match \x3d filteredDataUrl.match(goog.html.DATA_URL_PATTERN_);\n  if (match) {\n    return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(filteredDataUrl);\n  }\n  return null;\n};\ngoog.html.SafeUrl.fromDataUrl \x3d function(dataUrl) {\n  return goog.html.SafeUrl.tryFromDataUrl(dataUrl) || goog.html.SafeUrl.INNOCUOUS_URL;\n};\ngoog.html.SafeUrl.fromTelUrl \x3d function(telUrl) {\n  if (!goog.string.internal.caseInsensitiveStartsWith(telUrl, \x22tel:\x22)) {\n    telUrl \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(telUrl);\n};\ngoog.html.SIP_URL_PATTERN_ \x3d new RegExp(\x22^sip[s]?:[+a-z0-9_.!$%\\x26\x27*\\\\/\\x3d^`{|}~-]+@([a-z0-9-]+\\\\.)+[a-z0-9]{2,63}$\x22, \x22i\x22);\ngoog.html.SafeUrl.fromSipUrl \x3d function(sipUrl) {\n  if (!goog.html.SIP_URL_PATTERN_.test(decodeURIComponent(sipUrl))) {\n    sipUrl \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(sipUrl);\n};\ngoog.html.SafeUrl.fromFacebookMessengerUrl \x3d function(facebookMessengerUrl) {\n  if (!goog.string.internal.caseInsensitiveStartsWith(facebookMessengerUrl, \x22fb-messenger://share\x22)) {\n    facebookMessengerUrl \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(facebookMessengerUrl);\n};\ngoog.html.SafeUrl.fromWhatsAppUrl \x3d function(whatsAppUrl) {\n  if (!goog.string.internal.caseInsensitiveStartsWith(whatsAppUrl, \x22whatsapp://send\x22)) {\n    whatsAppUrl \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(whatsAppUrl);\n};\ngoog.html.SafeUrl.fromSmsUrl \x3d function(smsUrl) {\n  if (!goog.string.internal.caseInsensitiveStartsWith(smsUrl, \x22sms:\x22) || !goog.html.SafeUrl.isSmsUrlBodyValid_(smsUrl)) {\n    smsUrl \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(smsUrl);\n};\ngoog.html.SafeUrl.isSmsUrlBodyValid_ \x3d function(smsUrl) {\n  var hash \x3d smsUrl.indexOf(\x22#\x22);\n  if (hash \x3e 0) {\n    smsUrl \x3d smsUrl.substring(0, hash);\n  }\n  var bodyParams \x3d smsUrl.match(/[?\x26]body\x3d/gi);\n  if (!bodyParams) {\n    return true;\n  }\n  if (bodyParams.length \x3e 1) {\n    return false;\n  }\n  var bodyValue \x3d smsUrl.match(/[?\x26]body\x3d([^\x26]*)/)[1];\n  if (!bodyValue) {\n    return true;\n  }\n  try {\n    decodeURIComponent(bodyValue);\n  } catch (error) {\n    return false;\n  }\n  return /^(?:[a-z0-9\\-_.~]|%[0-9a-f]{2})+$/i.test(bodyValue);\n};\ngoog.html.SafeUrl.fromSshUrl \x3d function(sshUrl) {\n  if (!goog.string.internal.caseInsensitiveStartsWith(sshUrl, \x22ssh://\x22)) {\n    sshUrl \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(sshUrl);\n};\ngoog.html.SafeUrl.sanitizeChromeExtensionUrl \x3d function(url, extensionId) {\n  return goog.html.SafeUrl.sanitizeExtensionUrl_(/^chrome-extension:\\/\\/([^\\/]+)\\//, url, extensionId);\n};\ngoog.html.SafeUrl.sanitizeFirefoxExtensionUrl \x3d function(url, extensionId) {\n  return goog.html.SafeUrl.sanitizeExtensionUrl_(/^moz-extension:\\/\\/([^\\/]+)\\//, url, extensionId);\n};\ngoog.html.SafeUrl.sanitizeEdgeExtensionUrl \x3d function(url, extensionId) {\n  return goog.html.SafeUrl.sanitizeExtensionUrl_(/^ms-browser-extension:\\/\\/([^\\/]+)\\//, url, extensionId);\n};\ngoog.html.SafeUrl.sanitizeExtensionUrl_ \x3d function(scheme, url, extensionId) {\n  var matches \x3d scheme.exec(url);\n  if (!matches) {\n    url \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  } else {\n    var extractedExtensionId \x3d matches[1];\n    var acceptedExtensionIds;\n    if (extensionId instanceof goog.string.Const) {\n      acceptedExtensionIds \x3d [goog.string.Const.unwrap(extensionId)];\n    } else {\n      acceptedExtensionIds \x3d extensionId.map(function unwrap(x) {\n        return goog.string.Const.unwrap(x);\n      });\n    }\n    if (acceptedExtensionIds.indexOf(extractedExtensionId) \x3d\x3d -1) {\n      url \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n    }\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.SafeUrl.fromTrustedResourceUrl \x3d function(trustedResourceUrl) {\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.TrustedResourceUrl.unwrap(trustedResourceUrl));\n};\ngoog.html.SAFE_URL_PATTERN_ \x3d /^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;\ngoog.html.SafeUrl.SAFE_URL_PATTERN \x3d goog.html.SAFE_URL_PATTERN_;\ngoog.html.SafeUrl.trySanitize \x3d function(url) {\n  if (url instanceof goog.html.SafeUrl) {\n    return url;\n  }\n  if (typeof url \x3d\x3d \x22object\x22 \x26\x26 url.implementsGoogStringTypedString) {\n    url \x3d url.getTypedStringValue();\n  } else {\n    url \x3d String(url);\n  }\n  if (!goog.html.SAFE_URL_PATTERN_.test(url)) {\n    return goog.html.SafeUrl.tryFromDataUrl(url);\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.SafeUrl.sanitize \x3d function(url) {\n  return goog.html.SafeUrl.trySanitize(url) || goog.html.SafeUrl.INNOCUOUS_URL;\n};\ngoog.html.SafeUrl.sanitizeAssertUnchanged \x3d function(url, opt_allowDataUrl) {\n  if (url instanceof goog.html.SafeUrl) {\n    return url;\n  } else if (typeof url \x3d\x3d \x22object\x22 \x26\x26 url.implementsGoogStringTypedString) {\n    url \x3d url.getTypedStringValue();\n  } else {\n    url \x3d String(url);\n  }\n  if (opt_allowDataUrl \x26\x26 /^data:/i.test(url)) {\n    var safeUrl \x3d goog.html.SafeUrl.fromDataUrl(url);\n    if (safeUrl.getTypedStringValue() \x3d\x3d url) {\n      return safeUrl;\n    }\n  }\n  if (!goog.asserts.assert(goog.html.SAFE_URL_PATTERN_.test(url), \x22%s does not match the safe URL pattern\x22, url)) {\n    url \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.SafeUrl.extractScheme \x3d function(url) {\n  let parsedUrl;\n  try {\n    parsedUrl \x3d new URL(url);\n  } catch (e) {\n    return \x22https:\x22;\n  }\n  return parsedUrl.protocol;\n};\ngoog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged \x3d function(url) {\n  if (url instanceof goog.html.SafeUrl) {\n    return url;\n  } else if (typeof url \x3d\x3d \x22object\x22 \x26\x26 url.implementsGoogStringTypedString) {\n    url \x3d url.getTypedStringValue();\n  } else {\n    url \x3d String(url);\n  }\n  const parsedScheme \x3d goog.html.SafeUrl.extractScheme(url);\n  if (!goog.asserts.assert(parsedScheme !\x3d\x3d \x22javascript:\x22, \x22%s is a javascript: URL\x22, url)) {\n    url \x3d goog.html.SafeUrl.INNOCUOUS_STRING;\n  }\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_ \x3d {};\ngoog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse \x3d function(url) {\n  return new goog.html.SafeUrl(url, goog.html.SafeUrl.CONSTRUCTOR_TOKEN_PRIVATE_);\n};\ngoog.html.SafeUrl.INNOCUOUS_URL \x3d goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.SafeUrl.INNOCUOUS_STRING);\ngoog.html.SafeUrl.ABOUT_BLANK \x3d goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(\x22about:blank\x22);\n");
SHADOW_ENV.evalLoad("goog.html.safestyle.js", true, "goog.loadModule(function(exports) {\n  function sanitizePropertyValue(value) {\n    if (value instanceof SafeUrl) {\n      const url \x3d SafeUrl.unwrap(value);\n      return \x27url(\x22\x27 + url.replace(/\x3c/g, \x22%3c\x22).replace(/[\\\\\x22]/g, \x22\\\\$\\x26\x22) + \x27\x22)\x27;\n    }\n    const result \x3d value instanceof Const ? Const.unwrap(value) : sanitizePropertyValueString(String(value));\n    if (/[{;}]/.test(result)) {\n      throw new AssertionError(\x22Value does not allow [{;}], got: %s.\x22, [result]);\n    }\n    return result;\n  }\n  function sanitizePropertyValueString(value) {\n    const valueWithoutFunctions \x3d value.replace(FUNCTIONS_RE, \x22$1\x22).replace(FUNCTIONS_RE, \x22$1\x22).replace(URL_RE, \x22url\x22);\n    if (!VALUE_RE.test(valueWithoutFunctions)) {\n      fail(`String value allows only ${VALUE_ALLOWED_CHARS}` + \x22 and simple functions, got: \x22 + value);\n      return SafeStyle.INNOCUOUS_STRING;\n    } else if (COMMENT_RE.test(value)) {\n      fail(`String value disallows comments, got: ${value}`);\n      return SafeStyle.INNOCUOUS_STRING;\n    } else if (!hasBalancedQuotes(value)) {\n      fail(`String value requires balanced quotes, got: ${value}`);\n      return SafeStyle.INNOCUOUS_STRING;\n    } else if (!hasBalancedSquareBrackets(value)) {\n      fail(\x22String value requires balanced square brackets and one\x22 + \x22 identifier per pair of brackets, got: \x22 + value);\n      return SafeStyle.INNOCUOUS_STRING;\n    }\n    return sanitizeUrl(value);\n  }\n  function hasBalancedQuotes(value) {\n    let outsideSingle \x3d true;\n    let outsideDouble \x3d true;\n    for (let i \x3d 0; i \x3c value.length; i++) {\n      const c \x3d value.charAt(i);\n      if (c \x3d\x3d \x22\x27\x22 \x26\x26 outsideDouble) {\n        outsideSingle \x3d !outsideSingle;\n      } else if (c \x3d\x3d \x27\x22\x27 \x26\x26 outsideSingle) {\n        outsideDouble \x3d !outsideDouble;\n      }\n    }\n    return outsideSingle \x26\x26 outsideDouble;\n  }\n  function hasBalancedSquareBrackets(value) {\n    let outside \x3d true;\n    const tokenRe \x3d /^[-_a-zA-Z0-9]$/;\n    for (let i \x3d 0; i \x3c value.length; i++) {\n      const c \x3d value.charAt(i);\n      if (c \x3d\x3d \x22]\x22) {\n        if (outside) {\n          return false;\n        }\n        outside \x3d true;\n      } else if (c \x3d\x3d \x22[\x22) {\n        if (!outside) {\n          return false;\n        }\n        outside \x3d false;\n      } else if (!outside \x26\x26 !tokenRe.test(c)) {\n        return false;\n      }\n    }\n    return outside;\n  }\n  function sanitizeUrl(value) {\n    return value.replace(URL_RE, (match, before, url, after) \x3d\x3e {\n      let quote \x3d \x22\x22;\n      url \x3d url.replace(/^([\x27\x22])(.*)\\1$/, (match, start, inside) \x3d\x3e {\n        quote \x3d start;\n        return inside;\n      });\n      const sanitized \x3d SafeUrl.sanitize(url).getTypedStringValue();\n      return before + quote + sanitized + quote + after;\n    });\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.html.SafeStyle\x22);\n  goog.module.declareLegacyNamespace();\n  const Const \x3d goog.require(\x22goog.string.Const\x22);\n  const SafeUrl \x3d goog.require(\x22goog.html.SafeUrl\x22);\n  const TypedString \x3d goog.require(\x22goog.string.TypedString\x22);\n  const {AssertionError, assert, fail} \x3d goog.require(\x22goog.asserts\x22);\n  const {contains, endsWith} \x3d goog.require(\x22goog.string.internal\x22);\n  const CONSTRUCTOR_TOKEN_PRIVATE \x3d {};\n  class SafeStyle {\n    constructor(value, token) {\n      this.privateDoNotAccessOrElseSafeStyleWrappedValue_ \x3d token \x3d\x3d\x3d CONSTRUCTOR_TOKEN_PRIVATE ? value : \x22\x22;\n      this.implementsGoogStringTypedString \x3d true;\n    }\n    static fromConstant(style) {\n      const styleString \x3d Const.unwrap(style);\n      if (styleString.length \x3d\x3d\x3d 0) {\n        return SafeStyle.EMPTY;\n      }\n      assert(endsWith(styleString, \x22;\x22), `Last character of style string is not \x27;\x27: ${styleString}`);\n      assert(contains(styleString, \x22:\x22), \x22Style string must contain at least one \x27:\x27, to \x22 + \x27specify a \x22name: value\x22 pair: \x27 + styleString);\n      return SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(styleString);\n    }\n    getTypedStringValue() {\n      return this.privateDoNotAccessOrElseSafeStyleWrappedValue_;\n    }\n    toString() {\n      return this.privateDoNotAccessOrElseSafeStyleWrappedValue_.toString();\n    }\n    static unwrap(safeStyle) {\n      if (safeStyle instanceof SafeStyle \x26\x26 safeStyle.constructor \x3d\x3d\x3d SafeStyle) {\n        return safeStyle.privateDoNotAccessOrElseSafeStyleWrappedValue_;\n      } else {\n        fail(`expected object of type SafeStyle, got \x27${safeStyle}` + \x22\x27 of type \x22 + goog.typeOf(safeStyle));\n        return \x22type_error:SafeStyle\x22;\n      }\n    }\n    static createSafeStyleSecurityPrivateDoNotAccessOrElse(style) {\n      return new SafeStyle(style, CONSTRUCTOR_TOKEN_PRIVATE);\n    }\n    static create(map) {\n      let style \x3d \x22\x22;\n      for (let name in map) {\n        if (Object.prototype.hasOwnProperty.call(map, name)) {\n          if (!/^[-_a-zA-Z0-9]+$/.test(name)) {\n            throw new Error(`Name allows only [-_a-zA-Z0-9], got: ${name}`);\n          }\n          let value \x3d map[name];\n          if (value \x3d\x3d null) {\n            continue;\n          }\n          if (Array.isArray(value)) {\n            value \x3d value.map(sanitizePropertyValue).join(\x22 \x22);\n          } else {\n            value \x3d sanitizePropertyValue(value);\n          }\n          style \x3d style + `${name}:${value};`;\n        }\n      }\n      if (!style) {\n        return SafeStyle.EMPTY;\n      }\n      return SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(style);\n    }\n    static concat(var_args) {\n      let style \x3d \x22\x22;\n      const addArgument \x3d argument \x3d\x3e {\n        if (Array.isArray(argument)) {\n          argument.forEach(addArgument);\n        } else {\n          style \x3d style + SafeStyle.unwrap(argument);\n        }\n      };\n      Array.prototype.forEach.call(arguments, addArgument);\n      if (!style) {\n        return SafeStyle.EMPTY;\n      }\n      return SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(style);\n    }\n  }\n  SafeStyle.EMPTY \x3d SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(\x22\x22);\n  SafeStyle.INNOCUOUS_STRING \x3d \x22zClosurez\x22;\n  SafeStyle.PropertyValue;\n  SafeStyle.PropertyMap;\n  const VALUE_ALLOWED_CHARS \x3d \x22[-+,.\\\x22\x27%_!#/ a-zA-Z0-9\\\\[\\\\]]\x22;\n  const VALUE_RE \x3d new RegExp(`^${VALUE_ALLOWED_CHARS}+\\$`);\n  const URL_RE \x3d new RegExp(\x22\\\\b(url\\\\([ \\t\\n]*)(\x22 + \x22\x27[ -\\x26(-\\\\[\\\\]-~]*\x27\x22 + \x27|\x22[ !#-\\\\[\\\\]-~]*\x22\x27 + \x22|[!#-\\x26*-\\\\[\\\\]-~]*\x22 + \x22)([ \\t\\n]*\\\\))\x22, \x22g\x22);\n  const ALLOWED_FUNCTIONS \x3d [\x22calc\x22, \x22cubic-bezier\x22, \x22fit-content\x22, \x22hsl\x22, \x22hsla\x22, \x22linear-gradient\x22, \x22matrix\x22, \x22minmax\x22, \x22radial-gradient\x22, \x22repeat\x22, \x22rgb\x22, \x22rgba\x22, \x22(rotate|scale|translate)(X|Y|Z|3d)?\x22, \x22steps\x22, \x22var\x22];\n  const FUNCTIONS_RE \x3d new RegExp(\x22\\\\b(\x22 + ALLOWED_FUNCTIONS.join(\x22|\x22) + \x22)\x22 + \x22\\\\([-+*/0-9a-zA-Z.%#\\\\[\\\\], ]+\\\\)\x22, \x22g\x22);\n  const COMMENT_RE \x3d /\\/\\*/;\n  exports \x3d SafeStyle;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.object.object.js", true, "goog.loadModule(function(exports) {\n  function forEach(obj, f, opt_obj) {\n    for (const key in obj) {\n      f.call(opt_obj, obj[key], key, obj);\n    }\n  }\n  function filter(obj, f, opt_obj) {\n    const res \x3d {};\n    for (const key in obj) {\n      if (f.call(opt_obj, obj[key], key, obj)) {\n        res[key] \x3d obj[key];\n      }\n    }\n    return res;\n  }\n  function map(obj, f, opt_obj) {\n    const res \x3d {};\n    for (const key in obj) {\n      res[key] \x3d f.call(opt_obj, obj[key], key, obj);\n    }\n    return res;\n  }\n  function some(obj, f, opt_obj) {\n    for (const key in obj) {\n      if (f.call(opt_obj, obj[key], key, obj)) {\n        return true;\n      }\n    }\n    return false;\n  }\n  function every(obj, f, opt_obj) {\n    for (const key in obj) {\n      if (!f.call(opt_obj, obj[key], key, obj)) {\n        return false;\n      }\n    }\n    return true;\n  }\n  function getCount(obj) {\n    let rv \x3d 0;\n    for (const key in obj) {\n      rv++;\n    }\n    return rv;\n  }\n  function getAnyKey(obj) {\n    for (const key in obj) {\n      return key;\n    }\n  }\n  function getAnyValue(obj) {\n    for (const key in obj) {\n      return obj[key];\n    }\n  }\n  function contains(obj, val) {\n    return containsValue(obj, val);\n  }\n  function getValues(obj) {\n    const res \x3d [];\n    let i \x3d 0;\n    for (const key in obj) {\n      res[i++] \x3d obj[key];\n    }\n    return res;\n  }\n  function getKeys(obj) {\n    const res \x3d [];\n    let i \x3d 0;\n    for (const key in obj) {\n      res[i++] \x3d key;\n    }\n    return res;\n  }\n  function getValueByKeys(obj, var_args) {\n    const isArrayLike \x3d goog.isArrayLike(var_args);\n    const keys \x3d isArrayLike ? var_args : arguments;\n    for (let i \x3d isArrayLike ? 0 : 1; i \x3c keys.length; i++) {\n      if (obj \x3d\x3d null) {\n        return undefined;\n      }\n      obj \x3d obj[keys[i]];\n    }\n    return obj;\n  }\n  function containsKey(obj, key) {\n    return obj !\x3d\x3d null \x26\x26 key in obj;\n  }\n  function containsValue(obj, val) {\n    for (const key in obj) {\n      if (obj[key] \x3d\x3d val) {\n        return true;\n      }\n    }\n    return false;\n  }\n  function findKey(obj, f, thisObj \x3d undefined) {\n    for (const key in obj) {\n      if (f.call(thisObj, obj[key], key, obj)) {\n        return key;\n      }\n    }\n    return undefined;\n  }\n  function findValue(obj, f, thisObj \x3d undefined) {\n    const key \x3d findKey(obj, f, thisObj);\n    return key \x26\x26 obj[key];\n  }\n  function isEmpty(obj) {\n    for (const key in obj) {\n      return false;\n    }\n    return true;\n  }\n  function clear(obj) {\n    for (const i in obj) {\n      delete obj[i];\n    }\n  }\n  function remove(obj, key) {\n    let rv;\n    if (rv \x3d key in obj) {\n      delete obj[key];\n    }\n    return rv;\n  }\n  function add(obj, key, val) {\n    if (obj !\x3d\x3d null \x26\x26 key in obj) {\n      throw new Error(`The object already contains the key \x22${key}\x22`);\n    }\n    set(obj, key, val);\n  }\n  function get(obj, key, val \x3d undefined) {\n    if (obj !\x3d\x3d null \x26\x26 key in obj) {\n      return obj[key];\n    }\n    return val;\n  }\n  function set(obj, key, value) {\n    obj[key] \x3d value;\n  }\n  function setIfUndefined(obj, key, value) {\n    return key in obj ? obj[key] : obj[key] \x3d value;\n  }\n  function setWithReturnValueIfNotSet(obj, key, f) {\n    if (key in obj) {\n      return obj[key];\n    }\n    const val \x3d f();\n    obj[key] \x3d val;\n    return val;\n  }\n  function equals(a, b) {\n    for (const k in a) {\n      if (!(k in b) || a[k] !\x3d\x3d b[k]) {\n        return false;\n      }\n    }\n    for (const k in b) {\n      if (!(k in a)) {\n        return false;\n      }\n    }\n    return true;\n  }\n  function clone(obj) {\n    const res \x3d {};\n    for (const key in obj) {\n      res[key] \x3d obj[key];\n    }\n    return res;\n  }\n  function unsafeClone(obj) {\n    if (!obj || typeof obj !\x3d\x3d \x22object\x22) {\n      return obj;\n    }\n    if (typeof obj.clone \x3d\x3d\x3d \x22function\x22) {\n      return obj.clone();\n    }\n    if (typeof Map !\x3d\x3d \x22undefined\x22 \x26\x26 obj instanceof Map) {\n      return new Map(obj);\n    } else if (typeof Set !\x3d\x3d \x22undefined\x22 \x26\x26 obj instanceof Set) {\n      return new Set(obj);\n    } else if (obj instanceof Date) {\n      return new Date(obj.getTime());\n    }\n    const clone \x3d Array.isArray(obj) ? [] : typeof ArrayBuffer \x3d\x3d\x3d \x22function\x22 \x26\x26 typeof ArrayBuffer.isView \x3d\x3d\x3d \x22function\x22 \x26\x26 ArrayBuffer.isView(obj) \x26\x26 !(obj instanceof DataView) ? new obj.constructor(obj.length) : {};\n    for (const key in obj) {\n      clone[key] \x3d unsafeClone(obj[key]);\n    }\n    return clone;\n  }\n  function transpose(obj) {\n    const transposed \x3d {};\n    for (const key in obj) {\n      transposed[obj[key]] \x3d key;\n    }\n    return transposed;\n  }\n  function extend(target, var_args) {\n    let key;\n    let source;\n    for (let i \x3d 1; i \x3c arguments.length; i++) {\n      source \x3d arguments[i];\n      for (key in source) {\n        target[key] \x3d source[key];\n      }\n      for (let j \x3d 0; j \x3c PROTOTYPE_FIELDS.length; j++) {\n        key \x3d PROTOTYPE_FIELDS[j];\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] \x3d source[key];\n        }\n      }\n    }\n  }\n  function create(var_args) {\n    const argLength \x3d arguments.length;\n    if (argLength \x3d\x3d 1 \x26\x26 Array.isArray(arguments[0])) {\n      return create.apply(null, arguments[0]);\n    }\n    if (argLength % 2) {\n      throw new Error(\x22Uneven number of arguments\x22);\n    }\n    const rv \x3d {};\n    for (let i \x3d 0; i \x3c argLength; i \x3d i + 2) {\n      rv[arguments[i]] \x3d arguments[i + 1];\n    }\n    return rv;\n  }\n  function createSet(var_args) {\n    const argLength \x3d arguments.length;\n    if (argLength \x3d\x3d 1 \x26\x26 Array.isArray(arguments[0])) {\n      return createSet.apply(null, arguments[0]);\n    }\n    const rv \x3d {};\n    for (let i \x3d 0; i \x3c argLength; i++) {\n      rv[arguments[i]] \x3d true;\n    }\n    return rv;\n  }\n  function createImmutableView(obj) {\n    let result \x3d obj;\n    if (Object.isFrozen \x26\x26 !Object.isFrozen(obj)) {\n      result \x3d Object.create(obj);\n      Object.freeze(result);\n    }\n    return result;\n  }\n  function isImmutableView(obj) {\n    return !!Object.isFrozen \x26\x26 Object.isFrozen(obj);\n  }\n  function getAllPropertyNames(obj, includeObjectPrototype \x3d undefined, includeFunctionPrototype \x3d undefined) {\n    if (!obj) {\n      return [];\n    }\n    if (!Object.getOwnPropertyNames || !Object.getPrototypeOf) {\n      return getKeys(obj);\n    }\n    const visitedSet \x3d {};\n    let proto \x3d obj;\n    for (; proto \x26\x26 (proto !\x3d\x3d Object.prototype || !!includeObjectPrototype) \x26\x26 (proto !\x3d\x3d Function.prototype || !!includeFunctionPrototype);) {\n      const names \x3d Object.getOwnPropertyNames(proto);\n      for (let i \x3d 0; i \x3c names.length; i++) {\n        visitedSet[names[i]] \x3d true;\n      }\n      proto \x3d Object.getPrototypeOf(proto);\n    }\n    return getKeys(visitedSet);\n  }\n  function getSuperClass(constructor) {\n    const proto \x3d Object.getPrototypeOf(constructor.prototype);\n    return proto \x26\x26 proto.constructor;\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.object\x22);\n  goog.module.declareLegacyNamespace();\n  const PROTOTYPE_FIELDS \x3d [\x22constructor\x22, \x22hasOwnProperty\x22, \x22isPrototypeOf\x22, \x22propertyIsEnumerable\x22, \x22toLocaleString\x22, \x22toString\x22, \x22valueOf\x22];\n  exports \x3d {add, clear, clone, contains, containsKey, containsValue, create, createImmutableView, createSet, equals, every, extend, filter, findKey, findValue, forEach, get, getAllPropertyNames, getAnyKey, getAnyValue, getCount, getKeys, getSuperClass, getValueByKeys, getValues, isEmpty, isImmutableView, map, remove, set, setIfUndefined, setWithReturnValueIfNotSet, some, transpose, unsafeClone};\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.html.safestylesheet.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.html.SafeStyleSheet\x22);\n  goog.module.declareLegacyNamespace();\n  const Const \x3d goog.require(\x22goog.string.Const\x22);\n  const SafeStyle \x3d goog.require(\x22goog.html.SafeStyle\x22);\n  const TypedString \x3d goog.require(\x22goog.string.TypedString\x22);\n  const googObject \x3d goog.require(\x22goog.object\x22);\n  const {assert, fail} \x3d goog.require(\x22goog.asserts\x22);\n  const {contains} \x3d goog.require(\x22goog.string.internal\x22);\n  const CONSTRUCTOR_TOKEN_PRIVATE \x3d {};\n  class SafeStyleSheet {\n    constructor(value, token) {\n      this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_ \x3d token \x3d\x3d\x3d CONSTRUCTOR_TOKEN_PRIVATE ? value : \x22\x22;\n      this.implementsGoogStringTypedString \x3d true;\n    }\n    toString() {\n      return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_.toString();\n    }\n    static createRule(selector, style) {\n      if (contains(selector, \x22\\x3c\x22)) {\n        throw new Error(`Selector does not allow \x27\x3c\x27, got: ${selector}`);\n      }\n      const selectorToCheck \x3d selector.replace(/(\x27|\x22)((?!\\1)[^\\r\\n\\f\\\\]|\\\\[\\s\\S])*\\1/g, \x22\x22);\n      if (!/^[-_a-zA-Z0-9#.:* ,\x3e+~[\\]()\x3d^$|]+$/.test(selectorToCheck)) {\n        throw new Error(\x22Selector allows only [-_a-zA-Z0-9#.:* ,\\x3e+~[\\\\]()\\x3d^$|] and \x22 + \x22strings, got: \x22 + selector);\n      }\n      if (!SafeStyleSheet.hasBalancedBrackets_(selectorToCheck)) {\n        throw new Error(\x22() and [] in selector must be balanced, got: \x22 + selector);\n      }\n      if (!(style instanceof SafeStyle)) {\n        style \x3d SafeStyle.create(style);\n      }\n      const styleSheet \x3d `${selector}{` + SafeStyle.unwrap(style).replace(/\x3c/g, \x22\\\\3C \x22) + \x22}\x22;\n      return SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheet);\n    }\n    static hasBalancedBrackets_(s) {\n      const brackets \x3d {\x22(\x22:\x22)\x22, \x22[\x22:\x22]\x22};\n      const expectedBrackets \x3d [];\n      for (let i \x3d 0; i \x3c s.length; i++) {\n        const ch \x3d s[i];\n        if (brackets[ch]) {\n          expectedBrackets.push(brackets[ch]);\n        } else if (googObject.contains(brackets, ch)) {\n          if (expectedBrackets.pop() !\x3d ch) {\n            return false;\n          }\n        }\n      }\n      return expectedBrackets.length \x3d\x3d 0;\n    }\n    static concat(var_args) {\n      let result \x3d \x22\x22;\n      const addArgument \x3d argument \x3d\x3e {\n        if (Array.isArray(argument)) {\n          argument.forEach(addArgument);\n        } else {\n          result \x3d result + SafeStyleSheet.unwrap(argument);\n        }\n      };\n      Array.prototype.forEach.call(arguments, addArgument);\n      return SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(result);\n    }\n    static fromConstant(styleSheet) {\n      const styleSheetString \x3d Const.unwrap(styleSheet);\n      if (styleSheetString.length \x3d\x3d\x3d 0) {\n        return SafeStyleSheet.EMPTY;\n      }\n      assert(!contains(styleSheetString, \x22\\x3c\x22), `Forbidden \x27\x3c\x27 character in style sheet string: ${styleSheetString}`);\n      return SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheetString);\n    }\n    getTypedStringValue() {\n      return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;\n    }\n    static unwrap(safeStyleSheet) {\n      if (safeStyleSheet instanceof SafeStyleSheet \x26\x26 safeStyleSheet.constructor \x3d\x3d\x3d SafeStyleSheet) {\n        return safeStyleSheet.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;\n      } else {\n        fail(\x22expected object of type SafeStyleSheet, got \x27\x22 + safeStyleSheet + \x22\x27 of type \x22 + goog.typeOf(safeStyleSheet));\n        return \x22type_error:SafeStyleSheet\x22;\n      }\n    }\n    static createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheet) {\n      return new SafeStyleSheet(styleSheet, CONSTRUCTOR_TOKEN_PRIVATE);\n    }\n  }\n  SafeStyleSheet.EMPTY \x3d SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(\x22\x22);\n  exports \x3d SafeStyleSheet;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.flags.flags.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.flags\x22);\n  goog.module.declareLegacyNamespace();\n  exports.USE_USER_AGENT_CLIENT_HINTS \x3d false;\n  exports.ASYNC_THROW_ON_UNICODE_TO_BYTE \x3d false;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.labs.useragent.useragent.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.labs.userAgent\x22);\n  goog.module.declareLegacyNamespace();\n  const flags \x3d goog.require(\x22goog.flags\x22);\n  const USE_CLIENT_HINTS_OVERRIDE \x3d goog.define(\x22goog.labs.userAgent.USE_CLIENT_HINTS_OVERRIDE\x22, \x22\x22);\n  const USE_CLIENT_HINTS \x3d goog.define(\x22goog.labs.userAgent.USE_CLIENT_HINTS\x22, false);\n  let forceClientHintsInTests \x3d false;\n  exports.setUseClientHintsForTesting \x3d use \x3d\x3e {\n    forceClientHintsInTests \x3d use;\n  };\n  const useClientHintsRuntimeOverride \x3d USE_CLIENT_HINTS_OVERRIDE ? !!goog.getObjectByName(USE_CLIENT_HINTS_OVERRIDE) : false;\n  exports.useClientHints \x3d () \x3d\x3e {\n    return flags.USE_USER_AGENT_CLIENT_HINTS || USE_CLIENT_HINTS || useClientHintsRuntimeOverride || forceClientHintsInTests;\n  };\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.labs.useragent.util.js", true, "goog.loadModule(function(exports) {\n  function getNativeUserAgentString() {\n    const navigator \x3d getNavigator();\n    if (navigator) {\n      const userAgent \x3d navigator.userAgent;\n      if (userAgent) {\n        return userAgent;\n      }\n    }\n    return \x22\x22;\n  }\n  function getNativeUserAgentData() {\n    const navigator \x3d getNavigator();\n    if (navigator) {\n      return navigator.userAgentData || null;\n    }\n    return null;\n  }\n  function getNavigator() {\n    return goog.global.navigator;\n  }\n  function setUserAgent(userAgent \x3d undefined) {\n    userAgentInternal \x3d typeof userAgent \x3d\x3d\x3d \x22string\x22 ? userAgent : getNativeUserAgentString();\n  }\n  function getUserAgent() {\n    return userAgentInternal \x3d\x3d null ? getNativeUserAgentString() : userAgentInternal;\n  }\n  function setUserAgentData(userAgentData) {\n    userAgentDataInternal \x3d userAgentData;\n  }\n  function resetUserAgentData() {\n    userAgentDataInternal \x3d getNativeUserAgentData();\n  }\n  function getUserAgentData() {\n    return userAgentDataInternal;\n  }\n  function matchUserAgentDataBrand(str) {\n    if (!useClientHints()) {\n      return false;\n    }\n    const data \x3d getUserAgentData();\n    if (!data) {\n      return false;\n    }\n    return data.brands.some(({brand}) \x3d\x3e {\n      return brand \x26\x26 contains(brand, str);\n    });\n  }\n  function matchUserAgent(str) {\n    const userAgent \x3d getUserAgent();\n    return contains(userAgent, str);\n  }\n  function matchUserAgentIgnoreCase(str) {\n    const userAgent \x3d getUserAgent();\n    return caseInsensitiveContains(userAgent, str);\n  }\n  function extractVersionTuples(userAgent) {\n    const versionRegExp \x3d new RegExp(\x22([A-Z][\\\\w ]+)\x22 + \x22/\x22 + \x22([^\\\\s]+)\x22 + \x22\\\\s*\x22 + \x22(?:\\\\((.*?)\\\\))?\x22, \x22g\x22);\n    const data \x3d [];\n    let match;\n    for (; match \x3d versionRegExp.exec(userAgent);) {\n      data.push([match[1], match[2], match[3] || undefined]);\n    }\n    return data;\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.labs.userAgent.util\x22);\n  goog.module.declareLegacyNamespace();\n  const {caseInsensitiveContains, contains} \x3d goog.require(\x22goog.string.internal\x22);\n  const {useClientHints} \x3d goog.require(\x22goog.labs.userAgent\x22);\n  const ASSUME_CLIENT_HINTS_SUPPORT \x3d false;\n  let userAgentInternal \x3d null;\n  let userAgentDataInternal \x3d getNativeUserAgentData();\n  exports \x3d {ASSUME_CLIENT_HINTS_SUPPORT, extractVersionTuples, getNativeUserAgentString, getUserAgent, getUserAgentData, matchUserAgent, matchUserAgentDataBrand, matchUserAgentIgnoreCase, resetUserAgentData, setUserAgent, setUserAgentData};\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.labs.useragent.highentropy.highentropyvalue.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.labs.userAgent.highEntropy.highEntropyValue\x22);\n  const util \x3d goog.require(\x22goog.labs.userAgent.util\x22);\n  const {compareVersions} \x3d goog.require(\x22goog.string.internal\x22);\n  class AsyncValue {\n    getIfLoaded() {\n    }\n    load() {\n    }\n  }\n  exports.AsyncValue \x3d AsyncValue;\n  class HighEntropyValue {\n    constructor(key) {\n      this.key_ \x3d key;\n      this.value_ \x3d undefined;\n      this.promise_ \x3d undefined;\n      this.pending_ \x3d false;\n    }\n    getIfLoaded() {\n      const userAgentData \x3d util.getUserAgentData();\n      if (!userAgentData) {\n        return undefined;\n      }\n      return this.value_;\n    }\n    async load() {\n      const userAgentData \x3d util.getUserAgentData();\n      if (!userAgentData) {\n        return undefined;\n      }\n      if (!this.promise_) {\n        this.pending_ \x3d true;\n        this.promise_ \x3d (async() \x3d\x3e {\n          try {\n            const dataValues \x3d await userAgentData.getHighEntropyValues([this.key_]);\n            this.value_ \x3d dataValues[this.key_];\n            return this.value_;\n          } finally {\n            this.pending_ \x3d false;\n          }\n        })();\n      }\n      return await this.promise_;\n    }\n    resetForTesting() {\n      if (this.pending_) {\n        throw new Error(\x22Unsafe call to resetForTesting\x22);\n      }\n      this.promise_ \x3d undefined;\n      this.value_ \x3d undefined;\n      this.pending_ \x3d false;\n    }\n  }\n  exports.HighEntropyValue \x3d HighEntropyValue;\n  class Version {\n    constructor(versionString) {\n      this.versionString_ \x3d versionString;\n    }\n    toVersionStringForLogging() {\n      return this.versionString_;\n    }\n    isAtLeast(version) {\n      return compareVersions(this.versionString_, version) \x3e\x3d 0;\n    }\n  }\n  exports.Version \x3d Version;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.labs.useragent.highentropy.highentropydata.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.labs.userAgent.highEntropy.highEntropyData\x22);\n  const {HighEntropyValue} \x3d goog.require(\x22goog.labs.userAgent.highEntropy.highEntropyValue\x22);\n  const fullVersionList \x3d new HighEntropyValue(\x22fullVersionList\x22);\n  exports.fullVersionList \x3d fullVersionList;\n  const platformVersion \x3d new HighEntropyValue(\x22platformVersion\x22);\n  exports.platformVersion \x3d platformVersion;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.labs.useragent.browser.js", true, "goog.loadModule(function(exports) {\n  function useUserAgentDataBrand(ignoreClientHintsFlag \x3d false) {\n    if (util.ASSUME_CLIENT_HINTS_SUPPORT) {\n      return true;\n    }\n    if (!ignoreClientHintsFlag \x26\x26 !useClientHints()) {\n      return false;\n    }\n    const userAgentData \x3d util.getUserAgentData();\n    return !!userAgentData \x26\x26 userAgentData.brands.length \x3e 0;\n  }\n  function hasFullVersionList() {\n    return isAtLeast(Brand.CHROMIUM, 98);\n  }\n  function matchOpera() {\n    if (useUserAgentDataBrand()) {\n      return false;\n    }\n    return util.matchUserAgent(\x22Opera\x22);\n  }\n  function matchIE() {\n    if (useUserAgentDataBrand()) {\n      return false;\n    }\n    return util.matchUserAgent(\x22Trident\x22) || util.matchUserAgent(\x22MSIE\x22);\n  }\n  function matchEdgeHtml() {\n    if (useUserAgentDataBrand()) {\n      return false;\n    }\n    return util.matchUserAgent(\x22Edge\x22);\n  }\n  function matchEdgeChromium() {\n    if (useUserAgentDataBrand()) {\n      return util.matchUserAgentDataBrand(Brand.EDGE);\n    }\n    return util.matchUserAgent(\x22Edg/\x22);\n  }\n  function matchOperaChromium() {\n    if (useUserAgentDataBrand()) {\n      return util.matchUserAgentDataBrand(Brand.OPERA);\n    }\n    return util.matchUserAgent(\x22OPR\x22);\n  }\n  function matchFirefox() {\n    return util.matchUserAgent(\x22Firefox\x22) || util.matchUserAgent(\x22FxiOS\x22);\n  }\n  function matchSafari() {\n    return util.matchUserAgent(\x22Safari\x22) \x26\x26 !(matchChrome() || matchCoast() || matchOpera() || matchEdgeHtml() || matchEdgeChromium() || matchOperaChromium() || matchFirefox() || isSilk() || util.matchUserAgent(\x22Android\x22));\n  }\n  function matchCoast() {\n    if (useUserAgentDataBrand()) {\n      return false;\n    }\n    return util.matchUserAgent(\x22Coast\x22);\n  }\n  function matchIosWebview() {\n    return (util.matchUserAgent(\x22iPad\x22) || util.matchUserAgent(\x22iPhone\x22)) \x26\x26 !matchSafari() \x26\x26 !matchChrome() \x26\x26 !matchCoast() \x26\x26 !matchFirefox() \x26\x26 util.matchUserAgent(\x22AppleWebKit\x22);\n  }\n  function matchChrome() {\n    if (useUserAgentDataBrand()) {\n      return util.matchUserAgentDataBrand(Brand.CHROMIUM);\n    }\n    return (util.matchUserAgent(\x22Chrome\x22) || util.matchUserAgent(\x22CriOS\x22)) \x26\x26 !matchEdgeHtml() || isSilk();\n  }\n  function matchAndroidBrowser() {\n    return util.matchUserAgent(\x22Android\x22) \x26\x26 !(isChrome() || isFirefox() || isOpera() || isSilk());\n  }\n  function isSilk() {\n    return util.matchUserAgent(\x22Silk\x22);\n  }\n  function createVersionMap(versionTuples) {\n    const versionMap \x3d {};\n    versionTuples.forEach(tuple \x3d\x3e {\n      const key \x3d tuple[0];\n      const value \x3d tuple[1];\n      versionMap[key] \x3d value;\n    });\n    return keys \x3d\x3e {\n      return versionMap[keys.find(key \x3d\x3e {\n        return key in versionMap;\n      })] || \x22\x22;\n    };\n  }\n  function getVersion() {\n    const userAgentString \x3d util.getUserAgent();\n    if (isIE()) {\n      return getIEVersion(userAgentString);\n    }\n    const versionTuples \x3d util.extractVersionTuples(userAgentString);\n    const lookUpValueWithKeys \x3d createVersionMap(versionTuples);\n    if (isOpera()) {\n      return lookUpValueWithKeys([\x22Version\x22, \x22Opera\x22]);\n    }\n    if (isEdge()) {\n      return lookUpValueWithKeys([\x22Edge\x22]);\n    }\n    if (isEdgeChromium()) {\n      return lookUpValueWithKeys([\x22Edg\x22]);\n    }\n    if (isSilk()) {\n      return lookUpValueWithKeys([\x22Silk\x22]);\n    }\n    if (isChrome()) {\n      return lookUpValueWithKeys([\x22Chrome\x22, \x22CriOS\x22, \x22HeadlessChrome\x22]);\n    }\n    const tuple \x3d versionTuples[2];\n    return tuple \x26\x26 tuple[1] || \x22\x22;\n  }\n  function isVersionOrHigher(version) {\n    return compareVersions(getVersion(), version) \x3e\x3d 0;\n  }\n  function getIEVersion(userAgent) {\n    const rv \x3d /rv: *([\\d\\.]*)/.exec(userAgent);\n    if (rv \x26\x26 rv[1]) {\n      return rv[1];\n    }\n    let version \x3d \x22\x22;\n    const msie \x3d /MSIE +([\\d\\.]+)/.exec(userAgent);\n    if (msie \x26\x26 msie[1]) {\n      const tridentVersion \x3d /Trident\\/(\\d.\\d)/.exec(userAgent);\n      if (msie[1] \x3d\x3d \x227.0\x22) {\n        if (tridentVersion \x26\x26 tridentVersion[1]) {\n          switch(tridentVersion[1]) {\n            case \x224.0\x22:\n              version \x3d \x228.0\x22;\n              break;\n            case \x225.0\x22:\n              version \x3d \x229.0\x22;\n              break;\n            case \x226.0\x22:\n              version \x3d \x2210.0\x22;\n              break;\n            case \x227.0\x22:\n              version \x3d \x2211.0\x22;\n              break;\n          }\n        } else {\n          version \x3d \x227.0\x22;\n        }\n      } else {\n        version \x3d msie[1];\n      }\n    }\n    return version;\n  }\n  function getFullVersionFromUserAgentString(browser) {\n    const userAgentString \x3d util.getUserAgent();\n    if (browser \x3d\x3d\x3d Brand.IE) {\n      return isIE() ? getIEVersion(userAgentString) : \x22\x22;\n    }\n    const versionTuples \x3d util.extractVersionTuples(userAgentString);\n    const lookUpValueWithKeys \x3d createVersionMap(versionTuples);\n    switch(browser) {\n      case Brand.OPERA:\n        if (isOpera()) {\n          return lookUpValueWithKeys([\x22Version\x22, \x22Opera\x22]);\n        } else if (isOperaChromium()) {\n          return lookUpValueWithKeys([\x22OPR\x22]);\n        }\n        break;\n      case Brand.EDGE:\n        if (isEdge()) {\n          return lookUpValueWithKeys([\x22Edge\x22]);\n        } else if (isEdgeChromium()) {\n          return lookUpValueWithKeys([\x22Edg\x22]);\n        }\n        break;\n      case Brand.CHROMIUM:\n        if (isChrome()) {\n          return lookUpValueWithKeys([\x22Chrome\x22, \x22CriOS\x22, \x22HeadlessChrome\x22]);\n        }\n        break;\n    }\n    if (browser \x3d\x3d\x3d Brand.FIREFOX \x26\x26 isFirefox() || browser \x3d\x3d\x3d Brand.SAFARI \x26\x26 isSafari() || browser \x3d\x3d\x3d Brand.ANDROID_BROWSER \x26\x26 isAndroidBrowser() || browser \x3d\x3d\x3d Brand.SILK \x26\x26 isSilk()) {\n      const tuple \x3d versionTuples[2];\n      return tuple \x26\x26 tuple[1] || \x22\x22;\n    }\n    return \x22\x22;\n  }\n  function versionOf_(browser) {\n    let versionParts;\n    if (useUserAgentDataBrand() \x26\x26 browser !\x3d\x3d Brand.SILK) {\n      const data \x3d util.getUserAgentData();\n      const matchingBrand \x3d data.brands.find(({brand}) \x3d\x3e {\n        return brand \x3d\x3d\x3d browser;\n      });\n      if (!matchingBrand || !matchingBrand.version) {\n        return NaN;\n      }\n      versionParts \x3d matchingBrand.version.split(\x22.\x22);\n    } else {\n      const fullVersion \x3d getFullVersionFromUserAgentString(browser);\n      if (fullVersion \x3d\x3d\x3d \x22\x22) {\n        return NaN;\n      }\n      versionParts \x3d fullVersion.split(\x22.\x22);\n    }\n    if (versionParts.length \x3d\x3d\x3d 0) {\n      return NaN;\n    }\n    const majorVersion \x3d versionParts[0];\n    return Number(majorVersion);\n  }\n  function isAtLeast(brand, majorVersion) {\n    assert(Math.floor(majorVersion) \x3d\x3d\x3d majorVersion, \x22Major version must be an integer\x22);\n    return versionOf_(brand) \x3e\x3d majorVersion;\n  }\n  function isAtMost(brand, majorVersion) {\n    assert(Math.floor(majorVersion) \x3d\x3d\x3d majorVersion, \x22Major version must be an integer\x22);\n    return versionOf_(brand) \x3c\x3d majorVersion;\n  }\n  async function loadFullVersions() {\n    if (useUserAgentDataBrand(true)) {\n      await fullVersionList.load();\n    }\n    preUachHasLoaded \x3d true;\n  }\n  function fullVersionOf(browser) {\n    let fallbackVersionString \x3d \x22\x22;\n    if (!hasFullVersionList()) {\n      fallbackVersionString \x3d getFullVersionFromUserAgentString(browser);\n    }\n    const useUach \x3d browser !\x3d\x3d Brand.SILK \x26\x26 useUserAgentDataBrand(true);\n    if (useUach) {\n      const data \x3d util.getUserAgentData();\n      if (!data.brands.find(({brand}) \x3d\x3e {\n        return brand \x3d\x3d\x3d browser;\n      })) {\n        return undefined;\n      }\n    } else if (fallbackVersionString \x3d\x3d\x3d \x22\x22) {\n      return undefined;\n    }\n    return new HighEntropyBrandVersion(browser, useUach, fallbackVersionString);\n  }\n  function getVersionStringForLogging(browser) {\n    if (useUserAgentDataBrand(true)) {\n      const fullVersionObj \x3d fullVersionOf(browser);\n      if (fullVersionObj) {\n        const fullVersion \x3d fullVersionObj.getIfLoaded();\n        if (fullVersion) {\n          return fullVersion.toVersionStringForLogging();\n        }\n        const data \x3d util.getUserAgentData();\n        const matchingBrand \x3d data.brands.find(({brand}) \x3d\x3e {\n          return brand \x3d\x3d\x3d browser;\n        });\n        assertExists(matchingBrand);\n        return matchingBrand.version;\n      }\n      return \x22\x22;\n    } else {\n      return getFullVersionFromUserAgentString(browser);\n    }\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.labs.userAgent.browser\x22);\n  goog.module.declareLegacyNamespace();\n  const util \x3d goog.require(\x22goog.labs.userAgent.util\x22);\n  const {AsyncValue, Version} \x3d goog.require(\x22goog.labs.userAgent.highEntropy.highEntropyValue\x22);\n  const {assert, assertExists} \x3d goog.require(\x22goog.asserts\x22);\n  const {compareVersions} \x3d goog.require(\x22goog.string.internal\x22);\n  const {fullVersionList} \x3d goog.require(\x22goog.labs.userAgent.highEntropy.highEntropyData\x22);\n  const {useClientHints} \x3d goog.require(\x22goog.labs.userAgent\x22);\n  const Brand \x3d {ANDROID_BROWSER:\x22Android Browser\x22, CHROMIUM:\x22Chromium\x22, EDGE:\x22Microsoft Edge\x22, FIREFOX:\x22Firefox\x22, IE:\x22Internet Explorer\x22, OPERA:\x22Opera\x22, SAFARI:\x22Safari\x22, SILK:\x22Silk\x22};\n  exports.Brand \x3d Brand;\n  const isOpera \x3d matchOpera;\n  exports.isOpera \x3d isOpera;\n  const isIE \x3d matchIE;\n  exports.isIE \x3d isIE;\n  const isEdge \x3d matchEdgeHtml;\n  exports.isEdge \x3d isEdge;\n  const isEdgeChromium \x3d matchEdgeChromium;\n  exports.isEdgeChromium \x3d isEdgeChromium;\n  const isOperaChromium \x3d matchOperaChromium;\n  exports.isOperaChromium \x3d isOperaChromium;\n  const isFirefox \x3d matchFirefox;\n  exports.isFirefox \x3d isFirefox;\n  const isSafari \x3d matchSafari;\n  exports.isSafari \x3d isSafari;\n  const isCoast \x3d matchCoast;\n  exports.isCoast \x3d isCoast;\n  const isIosWebview \x3d matchIosWebview;\n  exports.isIosWebview \x3d isIosWebview;\n  const isChrome \x3d matchChrome;\n  exports.isChrome \x3d isChrome;\n  const isAndroidBrowser \x3d matchAndroidBrowser;\n  exports.isAndroidBrowser \x3d isAndroidBrowser;\n  exports.isSilk \x3d isSilk;\n  exports.getVersion \x3d getVersion;\n  exports.isVersionOrHigher \x3d isVersionOrHigher;\n  exports.isAtLeast \x3d isAtLeast;\n  exports.isAtMost \x3d isAtMost;\n  class HighEntropyBrandVersion {\n    constructor(brand, useUach, fallbackVersion) {\n      this.brand_ \x3d brand;\n      this.version_ \x3d new Version(fallbackVersion);\n      this.useUach_ \x3d useUach;\n    }\n    getIfLoaded() {\n      if (this.useUach_) {\n        const loadedVersionList \x3d fullVersionList.getIfLoaded();\n        if (loadedVersionList !\x3d\x3d undefined) {\n          const matchingBrand \x3d loadedVersionList.find(({brand}) \x3d\x3e {\n            return this.brand_ \x3d\x3d\x3d brand;\n          });\n          assertExists(matchingBrand);\n          return new Version(matchingBrand.version);\n        }\n      }\n      if (preUachHasLoaded) {\n        return this.version_;\n      }\n      return;\n    }\n    async load() {\n      if (this.useUach_) {\n        const loadedVersionList \x3d await fullVersionList.load();\n        if (loadedVersionList !\x3d\x3d undefined) {\n          const matchingBrand \x3d loadedVersionList.find(({brand}) \x3d\x3e {\n            return this.brand_ \x3d\x3d\x3d brand;\n          });\n          assertExists(matchingBrand);\n          return new Version(matchingBrand.version);\n        }\n      } else {\n        await 0;\n      }\n      preUachHasLoaded \x3d true;\n      return this.version_;\n    }\n  }\n  let preUachHasLoaded \x3d false;\n  exports.loadFullVersions \x3d loadFullVersions;\n  exports.resetForTesting \x3d () \x3d\x3e {\n    preUachHasLoaded \x3d false;\n    fullVersionList.resetForTesting();\n  };\n  exports.fullVersionOf \x3d fullVersionOf;\n  exports.getVersionStringForLogging \x3d getVersionStringForLogging;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.array.array.js", true, "goog.loadModule(function(exports) {\n  function peek(array) {\n    return array[array.length - 1];\n  }\n  function forEachRight(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d l - 1; i \x3e\x3d 0; --i) {\n      if (i in arr2) {\n        f.call(opt_obj, arr2[i], i, arr);\n      }\n    }\n  }\n  function count(arr, f, opt_obj) {\n    let count \x3d 0;\n    forEach(arr, function(element, index, arr) {\n      if (f.call(opt_obj, element, index, arr)) {\n        ++count;\n      }\n    }, opt_obj);\n    return count;\n  }\n  function find(arr, f, opt_obj) {\n    const i \x3d findIndex(arr, f, opt_obj);\n    return i \x3c 0 ? null : typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.charAt(i) : arr[i];\n  }\n  function findIndex(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d 0; i \x3c l; i++) {\n      if (i in arr2 \x26\x26 f.call(opt_obj, arr2[i], i, arr)) {\n        return i;\n      }\n    }\n    return -1;\n  }\n  function findRight(arr, f, opt_obj) {\n    const i \x3d findIndexRight(arr, f, opt_obj);\n    return i \x3c 0 ? null : typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.charAt(i) : arr[i];\n  }\n  function findIndexRight(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d l - 1; i \x3e\x3d 0; i--) {\n      if (i in arr2 \x26\x26 f.call(opt_obj, arr2[i], i, arr)) {\n        return i;\n      }\n    }\n    return -1;\n  }\n  function contains(arr, obj) {\n    return indexOf(arr, obj) \x3e\x3d 0;\n  }\n  function isEmpty(arr) {\n    return arr.length \x3d\x3d 0;\n  }\n  function clear(arr) {\n    if (!Array.isArray(arr)) {\n      for (let i \x3d arr.length - 1; i \x3e\x3d 0; i--) {\n        delete arr[i];\n      }\n    }\n    arr.length \x3d 0;\n  }\n  function insert(arr, obj) {\n    if (!contains(arr, obj)) {\n      arr.push(obj);\n    }\n  }\n  function insertAt(arr, obj, opt_i) {\n    splice(arr, opt_i, 0, obj);\n  }\n  function insertArrayAt(arr, elementsToAdd, opt_i) {\n    goog.partial(splice, arr, opt_i, 0).apply(null, elementsToAdd);\n  }\n  function insertBefore(arr, obj, opt_obj2) {\n    let i;\n    if (arguments.length \x3d\x3d 2 || (i \x3d indexOf(arr, opt_obj2)) \x3c 0) {\n      arr.push(obj);\n    } else {\n      insertAt(arr, obj, i);\n    }\n  }\n  function remove(arr, obj) {\n    const i \x3d indexOf(arr, obj);\n    let rv;\n    if (rv \x3d i \x3e\x3d 0) {\n      removeAt(arr, i);\n    }\n    return rv;\n  }\n  function removeLast(arr, obj) {\n    const i \x3d lastIndexOf(arr, obj);\n    if (i \x3e\x3d 0) {\n      removeAt(arr, i);\n      return true;\n    }\n    return false;\n  }\n  function removeAt(arr, i) {\n    asserts.assert(arr.length !\x3d null);\n    return Array.prototype.splice.call(arr, i, 1).length \x3d\x3d 1;\n  }\n  function removeIf(arr, f, opt_obj) {\n    const i \x3d findIndex(arr, f, opt_obj);\n    if (i \x3e\x3d 0) {\n      removeAt(arr, i);\n      return true;\n    }\n    return false;\n  }\n  function removeAllIf(arr, f, opt_obj) {\n    let removedCount \x3d 0;\n    forEachRight(arr, function(val, index) {\n      if (f.call(opt_obj, val, index, arr)) {\n        if (removeAt(arr, index)) {\n          removedCount++;\n        }\n      }\n    });\n    return removedCount;\n  }\n  function concat(var_args) {\n    return Array.prototype.concat.apply([], arguments);\n  }\n  function join(var_args) {\n    return Array.prototype.concat.apply([], arguments);\n  }\n  function toArray(object) {\n    const length \x3d object.length;\n    if (length \x3e 0) {\n      const rv \x3d new Array(length);\n      for (let i \x3d 0; i \x3c length; i++) {\n        rv[i] \x3d object[i];\n      }\n      return rv;\n    }\n    return [];\n  }\n  function extend(arr1, var_args) {\n    for (let i \x3d 1; i \x3c arguments.length; i++) {\n      const arr2 \x3d arguments[i];\n      if (goog.isArrayLike(arr2)) {\n        const len1 \x3d arr1.length || 0;\n        const len2 \x3d arr2.length || 0;\n        arr1.length \x3d len1 + len2;\n        for (let j \x3d 0; j \x3c len2; j++) {\n          arr1[len1 + j] \x3d arr2[j];\n        }\n      } else {\n        arr1.push(arr2);\n      }\n    }\n  }\n  function splice(arr, index, howMany, var_args) {\n    asserts.assert(arr.length !\x3d null);\n    return Array.prototype.splice.apply(arr, slice(arguments, 1));\n  }\n  function slice(arr, start, opt_end) {\n    asserts.assert(arr.length !\x3d null);\n    if (arguments.length \x3c\x3d 2) {\n      return Array.prototype.slice.call(arr, start);\n    } else {\n      return Array.prototype.slice.call(arr, start, opt_end);\n    }\n  }\n  function removeDuplicates(arr, opt_rv, opt_hashFn) {\n    const returnArray \x3d opt_rv || arr;\n    const defaultHashFn \x3d function(item) {\n      return goog.isObject(item) ? \x22o\x22 + goog.getUid(item) : (typeof item).charAt(0) + item;\n    };\n    const hashFn \x3d opt_hashFn || defaultHashFn;\n    let cursorInsert \x3d 0;\n    let cursorRead \x3d 0;\n    const seen \x3d {};\n    for (; cursorRead \x3c arr.length;) {\n      const current \x3d arr[cursorRead++];\n      const key \x3d hashFn(current);\n      if (!Object.prototype.hasOwnProperty.call(seen, key)) {\n        seen[key] \x3d true;\n        returnArray[cursorInsert++] \x3d current;\n      }\n    }\n    returnArray.length \x3d cursorInsert;\n  }\n  function binarySearch(arr, target, opt_compareFn) {\n    return binarySearch_(arr, opt_compareFn || defaultCompare, false, target);\n  }\n  function binarySelect(arr, evaluator, opt_obj) {\n    return binarySearch_(arr, evaluator, true, undefined, opt_obj);\n  }\n  function binarySearch_(arr, compareFn, isEvaluator, opt_target, opt_selfObj) {\n    let left \x3d 0;\n    let right \x3d arr.length;\n    let found;\n    for (; left \x3c right;) {\n      const middle \x3d left + (right - left \x3e\x3e\x3e 1);\n      let compareResult;\n      if (isEvaluator) {\n        compareResult \x3d compareFn.call(opt_selfObj, arr[middle], middle, arr);\n      } else {\n        compareResult \x3d compareFn(opt_target, arr[middle]);\n      }\n      if (compareResult \x3e 0) {\n        left \x3d middle + 1;\n      } else {\n        right \x3d middle;\n        found \x3d !compareResult;\n      }\n    }\n    return found ? left : -left - 1;\n  }\n  function sort(arr, opt_compareFn) {\n    arr.sort(opt_compareFn || defaultCompare);\n  }\n  function stableSort(arr, opt_compareFn) {\n    function stableCompareFn(obj1, obj2) {\n      return valueCompareFn(obj1.value, obj2.value) || obj1.index - obj2.index;\n    }\n    const compArr \x3d new Array(arr.length);\n    for (let i \x3d 0; i \x3c arr.length; i++) {\n      compArr[i] \x3d {index:i, value:arr[i]};\n    }\n    const valueCompareFn \x3d opt_compareFn || defaultCompare;\n    sort(compArr, stableCompareFn);\n    for (let i \x3d 0; i \x3c arr.length; i++) {\n      arr[i] \x3d compArr[i].value;\n    }\n  }\n  function sortByKey(arr, keyFn, opt_compareFn) {\n    const keyCompareFn \x3d opt_compareFn || defaultCompare;\n    sort(arr, function(a, b) {\n      return keyCompareFn(keyFn(a), keyFn(b));\n    });\n  }\n  function sortObjectsByKey(arr, key, opt_compareFn) {\n    sortByKey(arr, function(obj) {\n      return obj[key];\n    }, opt_compareFn);\n  }\n  function isSorted(arr, opt_compareFn, opt_strict) {\n    const compare \x3d opt_compareFn || defaultCompare;\n    for (let i \x3d 1; i \x3c arr.length; i++) {\n      const compareResult \x3d compare(arr[i - 1], arr[i]);\n      if (compareResult \x3e 0 || compareResult \x3d\x3d 0 \x26\x26 opt_strict) {\n        return false;\n      }\n    }\n    return true;\n  }\n  function equals(arr1, arr2, opt_equalsFn) {\n    if (!goog.isArrayLike(arr1) || !goog.isArrayLike(arr2) || arr1.length !\x3d arr2.length) {\n      return false;\n    }\n    const l \x3d arr1.length;\n    const equalsFn \x3d opt_equalsFn || defaultCompareEquality;\n    for (let i \x3d 0; i \x3c l; i++) {\n      if (!equalsFn(arr1[i], arr2[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  function compare3(arr1, arr2, opt_compareFn) {\n    const compare \x3d opt_compareFn || defaultCompare;\n    const l \x3d Math.min(arr1.length, arr2.length);\n    for (let i \x3d 0; i \x3c l; i++) {\n      const result \x3d compare(arr1[i], arr2[i]);\n      if (result !\x3d 0) {\n        return result;\n      }\n    }\n    return defaultCompare(arr1.length, arr2.length);\n  }\n  function defaultCompare(a, b) {\n    return a \x3e b ? 1 : a \x3c b ? -1 : 0;\n  }\n  function inverseDefaultCompare(a, b) {\n    return -defaultCompare(a, b);\n  }\n  function defaultCompareEquality(a, b) {\n    return a \x3d\x3d\x3d b;\n  }\n  function binaryInsert(array, value, opt_compareFn) {\n    const index \x3d binarySearch(array, value, opt_compareFn);\n    if (index \x3c 0) {\n      insertAt(array, value, -(index + 1));\n      return true;\n    }\n    return false;\n  }\n  function binaryRemove(array, value, opt_compareFn) {\n    const index \x3d binarySearch(array, value, opt_compareFn);\n    return index \x3e\x3d 0 ? removeAt(array, index) : false;\n  }\n  function bucket(array, sorter, opt_obj) {\n    const buckets \x3d {};\n    for (let i \x3d 0; i \x3c array.length; i++) {\n      const value \x3d array[i];\n      const key \x3d sorter.call(opt_obj, value, i, array);\n      if (key !\x3d\x3d undefined) {\n        const bucket \x3d buckets[key] || (buckets[key] \x3d []);\n        bucket.push(value);\n      }\n    }\n    return buckets;\n  }\n  function bucketToMap(array, sorter) {\n    const buckets \x3d new Map();\n    for (let i \x3d 0; i \x3c array.length; i++) {\n      const value \x3d array[i];\n      const key \x3d sorter(value, i, array);\n      if (key !\x3d\x3d undefined) {\n        let bucket \x3d buckets.get(key);\n        if (!bucket) {\n          bucket \x3d [];\n          buckets.set(key, bucket);\n        }\n        bucket.push(value);\n      }\n    }\n    return buckets;\n  }\n  function toObject(arr, keyFunc, opt_obj) {\n    const ret \x3d {};\n    forEach(arr, function(element, index) {\n      ret[keyFunc.call(opt_obj, element, index, arr)] \x3d element;\n    });\n    return ret;\n  }\n  function toMap(arr, keyFunc) {\n    const map \x3d new Map();\n    for (let i \x3d 0; i \x3c arr.length; i++) {\n      const element \x3d arr[i];\n      map.set(keyFunc(element, i, arr), element);\n    }\n    return map;\n  }\n  function range(startOrEnd, opt_end, opt_step) {\n    const array \x3d [];\n    let start \x3d 0;\n    let end \x3d startOrEnd;\n    const step \x3d opt_step || 1;\n    if (opt_end !\x3d\x3d undefined) {\n      start \x3d startOrEnd;\n      end \x3d opt_end;\n    }\n    if (step * (end - start) \x3c 0) {\n      return [];\n    }\n    if (step \x3e 0) {\n      for (let i \x3d start; i \x3c end; i \x3d i + step) {\n        array.push(i);\n      }\n    } else {\n      for (let i \x3d start; i \x3e end; i \x3d i + step) {\n        array.push(i);\n      }\n    }\n    return array;\n  }\n  function repeat(value, n) {\n    const array \x3d [];\n    for (let i \x3d 0; i \x3c n; i++) {\n      array[i] \x3d value;\n    }\n    return array;\n  }\n  function flatten(var_args) {\n    const CHUNK_SIZE \x3d 8192;\n    const result \x3d [];\n    for (let i \x3d 0; i \x3c arguments.length; i++) {\n      const element \x3d arguments[i];\n      if (Array.isArray(element)) {\n        for (let c \x3d 0; c \x3c element.length; c \x3d c + CHUNK_SIZE) {\n          const chunk \x3d slice(element, c, c + CHUNK_SIZE);\n          const recurseResult \x3d flatten.apply(null, chunk);\n          for (let r \x3d 0; r \x3c recurseResult.length; r++) {\n            result.push(recurseResult[r]);\n          }\n        }\n      } else {\n        result.push(element);\n      }\n    }\n    return result;\n  }\n  function rotate(array, n) {\n    asserts.assert(array.length !\x3d null);\n    if (array.length) {\n      n \x3d n % array.length;\n      if (n \x3e 0) {\n        Array.prototype.unshift.apply(array, array.splice(-n, n));\n      } else if (n \x3c 0) {\n        Array.prototype.push.apply(array, array.splice(0, -n));\n      }\n    }\n    return array;\n  }\n  function moveItem(arr, fromIndex, toIndex) {\n    asserts.assert(fromIndex \x3e\x3d 0 \x26\x26 fromIndex \x3c arr.length);\n    asserts.assert(toIndex \x3e\x3d 0 \x26\x26 toIndex \x3c arr.length);\n    const removedItems \x3d Array.prototype.splice.call(arr, fromIndex, 1);\n    Array.prototype.splice.call(arr, toIndex, 0, removedItems[0]);\n  }\n  function zip(var_args) {\n    if (!arguments.length) {\n      return [];\n    }\n    const result \x3d [];\n    let minLen \x3d arguments[0].length;\n    for (let i \x3d 1; i \x3c arguments.length; i++) {\n      if (arguments[i].length \x3c minLen) {\n        minLen \x3d arguments[i].length;\n      }\n    }\n    for (let i \x3d 0; i \x3c minLen; i++) {\n      const value \x3d [];\n      for (let j \x3d 0; j \x3c arguments.length; j++) {\n        value.push(arguments[j][i]);\n      }\n      result.push(value);\n    }\n    return result;\n  }\n  function shuffle(arr, opt_randFn) {\n    const randFn \x3d opt_randFn || Math.random;\n    for (let i \x3d arr.length - 1; i \x3e 0; i--) {\n      const j \x3d Math.floor(randFn() * (i + 1));\n      const tmp \x3d arr[i];\n      arr[i] \x3d arr[j];\n      arr[j] \x3d tmp;\n    }\n  }\n  function copyByIndex(arr, index_arr) {\n    const result \x3d [];\n    forEach(index_arr, function(index) {\n      result.push(arr[index]);\n    });\n    return result;\n  }\n  function concatMap(arr, f, opt_obj) {\n    return concat.apply([], map(arr, f, opt_obj));\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.array\x22);\n  goog.module.declareLegacyNamespace();\n  const asserts \x3d goog.require(\x22goog.asserts\x22);\n  goog.NATIVE_ARRAY_PROTOTYPES \x3d goog.define(\x22goog.NATIVE_ARRAY_PROTOTYPES\x22, goog.TRUSTED_SITE);\n  const ASSUME_NATIVE_FUNCTIONS \x3d goog.define(\x22goog.array.ASSUME_NATIVE_FUNCTIONS\x22, goog.FEATURESET_YEAR \x3e 2012);\n  exports.ASSUME_NATIVE_FUNCTIONS \x3d ASSUME_NATIVE_FUNCTIONS;\n  exports.peek \x3d peek;\n  exports.last \x3d peek;\n  const indexOf \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.indexOf) ? function(arr, obj, opt_fromIndex) {\n    asserts.assert(arr.length !\x3d null);\n    return Array.prototype.indexOf.call(arr, obj, opt_fromIndex);\n  } : function(arr, obj, opt_fromIndex) {\n    const fromIndex \x3d opt_fromIndex \x3d\x3d null ? 0 : opt_fromIndex \x3c 0 ? Math.max(0, arr.length + opt_fromIndex) : opt_fromIndex;\n    if (typeof arr \x3d\x3d\x3d \x22string\x22) {\n      if (typeof obj !\x3d\x3d \x22string\x22 || obj.length !\x3d 1) {\n        return -1;\n      }\n      return arr.indexOf(obj, fromIndex);\n    }\n    for (let i \x3d fromIndex; i \x3c arr.length; i++) {\n      if (i in arr \x26\x26 arr[i] \x3d\x3d\x3d obj) {\n        return i;\n      }\n    }\n    return -1;\n  };\n  exports.indexOf \x3d indexOf;\n  const lastIndexOf \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.lastIndexOf) ? function(arr, obj, opt_fromIndex) {\n    asserts.assert(arr.length !\x3d null);\n    const fromIndex \x3d opt_fromIndex \x3d\x3d null ? arr.length - 1 : opt_fromIndex;\n    return Array.prototype.lastIndexOf.call(arr, obj, fromIndex);\n  } : function(arr, obj, opt_fromIndex) {\n    let fromIndex \x3d opt_fromIndex \x3d\x3d null ? arr.length - 1 : opt_fromIndex;\n    if (fromIndex \x3c 0) {\n      fromIndex \x3d Math.max(0, arr.length + fromIndex);\n    }\n    if (typeof arr \x3d\x3d\x3d \x22string\x22) {\n      if (typeof obj !\x3d\x3d \x22string\x22 || obj.length !\x3d 1) {\n        return -1;\n      }\n      return arr.lastIndexOf(obj, fromIndex);\n    }\n    for (let i \x3d fromIndex; i \x3e\x3d 0; i--) {\n      if (i in arr \x26\x26 arr[i] \x3d\x3d\x3d obj) {\n        return i;\n      }\n    }\n    return -1;\n  };\n  exports.lastIndexOf \x3d lastIndexOf;\n  const forEach \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.forEach) ? function(arr, f, opt_obj) {\n    asserts.assert(arr.length !\x3d null);\n    Array.prototype.forEach.call(arr, f, opt_obj);\n  } : function(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d 0; i \x3c l; i++) {\n      if (i in arr2) {\n        f.call(opt_obj, arr2[i], i, arr);\n      }\n    }\n  };\n  exports.forEach \x3d forEach;\n  exports.forEachRight \x3d forEachRight;\n  const filter \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.filter) ? function(arr, f, opt_obj) {\n    asserts.assert(arr.length !\x3d null);\n    return Array.prototype.filter.call(arr, f, opt_obj);\n  } : function(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const res \x3d [];\n    let resLength \x3d 0;\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d 0; i \x3c l; i++) {\n      if (i in arr2) {\n        const val \x3d arr2[i];\n        if (f.call(opt_obj, val, i, arr)) {\n          res[resLength++] \x3d val;\n        }\n      }\n    }\n    return res;\n  };\n  exports.filter \x3d filter;\n  const map \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.map) ? function(arr, f, opt_obj) {\n    asserts.assert(arr.length !\x3d null);\n    return Array.prototype.map.call(arr, f, opt_obj);\n  } : function(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const res \x3d new Array(l);\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d 0; i \x3c l; i++) {\n      if (i in arr2) {\n        res[i] \x3d f.call(opt_obj, arr2[i], i, arr);\n      }\n    }\n    return res;\n  };\n  exports.map \x3d map;\n  const reduce \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduce) ? function(arr, f, val, opt_obj) {\n    asserts.assert(arr.length !\x3d null);\n    if (opt_obj) {\n      f \x3d goog.bind(f, opt_obj);\n    }\n    return Array.prototype.reduce.call(arr, f, val);\n  } : function(arr, f, val, opt_obj) {\n    let rval \x3d val;\n    forEach(arr, function(val, index) {\n      rval \x3d f.call(opt_obj, rval, val, index, arr);\n    });\n    return rval;\n  };\n  exports.reduce \x3d reduce;\n  const reduceRight \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduceRight) ? function(arr, f, val, opt_obj) {\n    asserts.assert(arr.length !\x3d null);\n    asserts.assert(f !\x3d null);\n    if (opt_obj) {\n      f \x3d goog.bind(f, opt_obj);\n    }\n    return Array.prototype.reduceRight.call(arr, f, val);\n  } : function(arr, f, val, opt_obj) {\n    let rval \x3d val;\n    forEachRight(arr, function(val, index) {\n      rval \x3d f.call(opt_obj, rval, val, index, arr);\n    });\n    return rval;\n  };\n  exports.reduceRight \x3d reduceRight;\n  const some \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.some) ? function(arr, f, opt_obj) {\n    asserts.assert(arr.length !\x3d null);\n    return Array.prototype.some.call(arr, f, opt_obj);\n  } : function(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d 0; i \x3c l; i++) {\n      if (i in arr2 \x26\x26 f.call(opt_obj, arr2[i], i, arr)) {\n        return true;\n      }\n    }\n    return false;\n  };\n  exports.some \x3d some;\n  const every \x3d goog.NATIVE_ARRAY_PROTOTYPES \x26\x26 (ASSUME_NATIVE_FUNCTIONS || Array.prototype.every) ? function(arr, f, opt_obj) {\n    asserts.assert(arr.length !\x3d null);\n    return Array.prototype.every.call(arr, f, opt_obj);\n  } : function(arr, f, opt_obj) {\n    const l \x3d arr.length;\n    const arr2 \x3d typeof arr \x3d\x3d\x3d \x22string\x22 ? arr.split(\x22\x22) : arr;\n    for (let i \x3d 0; i \x3c l; i++) {\n      if (i in arr2 \x26\x26 !f.call(opt_obj, arr2[i], i, arr)) {\n        return false;\n      }\n    }\n    return true;\n  };\n  exports.every \x3d every;\n  exports.count \x3d count;\n  exports.find \x3d find;\n  exports.findIndex \x3d findIndex;\n  exports.findRight \x3d findRight;\n  exports.findIndexRight \x3d findIndexRight;\n  exports.contains \x3d contains;\n  exports.isEmpty \x3d isEmpty;\n  exports.clear \x3d clear;\n  exports.insert \x3d insert;\n  exports.insertAt \x3d insertAt;\n  exports.insertArrayAt \x3d insertArrayAt;\n  exports.insertBefore \x3d insertBefore;\n  exports.remove \x3d remove;\n  exports.removeLast \x3d removeLast;\n  exports.removeAt \x3d removeAt;\n  exports.removeIf \x3d removeIf;\n  exports.removeAllIf \x3d removeAllIf;\n  exports.concat \x3d concat;\n  exports.join \x3d join;\n  exports.toArray \x3d toArray;\n  const clone \x3d toArray;\n  exports.clone \x3d clone;\n  exports.extend \x3d extend;\n  exports.splice \x3d splice;\n  exports.slice \x3d slice;\n  exports.removeDuplicates \x3d removeDuplicates;\n  exports.binarySearch \x3d binarySearch;\n  exports.binarySelect \x3d binarySelect;\n  exports.sort \x3d sort;\n  exports.stableSort \x3d stableSort;\n  exports.sortByKey \x3d sortByKey;\n  exports.sortObjectsByKey \x3d sortObjectsByKey;\n  exports.isSorted \x3d isSorted;\n  exports.equals \x3d equals;\n  exports.compare3 \x3d compare3;\n  exports.defaultCompare \x3d defaultCompare;\n  exports.inverseDefaultCompare \x3d inverseDefaultCompare;\n  exports.defaultCompareEquality \x3d defaultCompareEquality;\n  exports.binaryInsert \x3d binaryInsert;\n  exports.binaryRemove \x3d binaryRemove;\n  exports.bucket \x3d bucket;\n  exports.bucketToMap \x3d bucketToMap;\n  exports.toObject \x3d toObject;\n  exports.toMap \x3d toMap;\n  exports.range \x3d range;\n  exports.repeat \x3d repeat;\n  exports.flatten \x3d flatten;\n  exports.rotate \x3d rotate;\n  exports.moveItem \x3d moveItem;\n  exports.zip \x3d zip;\n  exports.shuffle \x3d shuffle;\n  exports.copyByIndex \x3d copyByIndex;\n  exports.concatMap \x3d concatMap;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.dom.tags.js", true, "goog.provide(\x22goog.dom.tags\x22);\ngoog.require(\x22goog.object\x22);\ngoog.dom.tags.VOID_TAGS_ \x3d goog.object.createSet(\x22area\x22, \x22base\x22, \x22br\x22, \x22col\x22, \x22command\x22, \x22embed\x22, \x22hr\x22, \x22img\x22, \x22input\x22, \x22keygen\x22, \x22link\x22, \x22meta\x22, \x22param\x22, \x22source\x22, \x22track\x22, \x22wbr\x22);\ngoog.dom.tags.isVoidTag \x3d function(tagName) {\n  return goog.dom.tags.VOID_TAGS_[tagName] \x3d\x3d\x3d true;\n};\n");
SHADOW_ENV.evalLoad("goog.html.safehtml.js", true, "goog.loadModule(function(exports) {\n  function getAttrNameAndValue(tagName, name, value) {\n    if (value instanceof Const) {\n      value \x3d Const.unwrap(value);\n    } else if (name.toLowerCase() \x3d\x3d \x22style\x22) {\n      if (SafeHtml.SUPPORT_STYLE_ATTRIBUTE) {\n        value \x3d getStyleValue(value);\n      } else {\n        throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? \x27Attribute \x22style\x22 not supported.\x27 : \x22\x22);\n      }\n    } else if (/^on/i.test(name)) {\n      throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? `Attribute \x22${name}` + \x27\x22 requires goog.string.Const value, \x22\x27 + value + \x27\x22 given.\x27 : \x22\x22);\n    } else if (name.toLowerCase() in URL_ATTRIBUTES) {\n      if (value instanceof TrustedResourceUrl) {\n        value \x3d TrustedResourceUrl.unwrap(value);\n      } else if (value instanceof SafeUrl) {\n        value \x3d SafeUrl.unwrap(value);\n      } else if (typeof value \x3d\x3d\x3d \x22string\x22) {\n        value \x3d SafeUrl.sanitize(value).getTypedStringValue();\n      } else {\n        throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? `Attribute \x22${name}\x22 on tag \x22${tagName}` + \x27\x22 requires goog.html.SafeUrl, goog.string.Const, or\x27 + \x27 string, value \x22\x27 + value + \x27\x22 given.\x27 : \x22\x22);\n      }\n    }\n    if (value.implementsGoogStringTypedString) {\n      value \x3d value.getTypedStringValue();\n    }\n    asserts.assert(typeof value \x3d\x3d\x3d \x22string\x22 || typeof value \x3d\x3d\x3d \x22number\x22, \x22String or number value expected, got \x22 + typeof value + \x22 with value: \x22 + value);\n    return `${name}\x3d\x22` + internal.htmlEscape(String(value)) + \x27\x22\x27;\n  }\n  function getStyleValue(value) {\n    if (!goog.isObject(value)) {\n      throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? \x27The \x22style\x22 attribute requires goog.html.SafeStyle or map \x27 + \x22of style properties, \x22 + typeof value + \x22 given: \x22 + value : \x22\x22);\n    }\n    if (!(value instanceof SafeStyle)) {\n      value \x3d SafeStyle.create(value);\n    }\n    return SafeStyle.unwrap(value);\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.html.SafeHtml\x22);\n  goog.module.declareLegacyNamespace();\n  const Const \x3d goog.require(\x22goog.string.Const\x22);\n  const SafeScript \x3d goog.require(\x22goog.html.SafeScript\x22);\n  const SafeStyle \x3d goog.require(\x22goog.html.SafeStyle\x22);\n  const SafeStyleSheet \x3d goog.require(\x22goog.html.SafeStyleSheet\x22);\n  const SafeUrl \x3d goog.require(\x22goog.html.SafeUrl\x22);\n  const TagName \x3d goog.require(\x22goog.dom.TagName\x22);\n  const TrustedResourceUrl \x3d goog.require(\x22goog.html.TrustedResourceUrl\x22);\n  const TypedString \x3d goog.require(\x22goog.string.TypedString\x22);\n  const asserts \x3d goog.require(\x22goog.asserts\x22);\n  const browser \x3d goog.require(\x22goog.labs.userAgent.browser\x22);\n  const googArray \x3d goog.require(\x22goog.array\x22);\n  const googObject \x3d goog.require(\x22goog.object\x22);\n  const internal \x3d goog.require(\x22goog.string.internal\x22);\n  const tags \x3d goog.require(\x22goog.dom.tags\x22);\n  const trustedtypes \x3d goog.require(\x22goog.html.trustedtypes\x22);\n  const CONSTRUCTOR_TOKEN_PRIVATE \x3d {};\n  class SafeHtml {\n    constructor(value, token) {\n      this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ \x3d token \x3d\x3d\x3d CONSTRUCTOR_TOKEN_PRIVATE ? value : \x22\x22;\n      this.implementsGoogStringTypedString \x3d true;\n    }\n    getTypedStringValue() {\n      return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString();\n    }\n    toString() {\n      return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString();\n    }\n    static unwrap(safeHtml) {\n      return SafeHtml.unwrapTrustedHTML(safeHtml).toString();\n    }\n    static unwrapTrustedHTML(safeHtml) {\n      if (safeHtml instanceof SafeHtml \x26\x26 safeHtml.constructor \x3d\x3d\x3d SafeHtml) {\n        return safeHtml.privateDoNotAccessOrElseSafeHtmlWrappedValue_;\n      } else {\n        asserts.fail(`expected object of type SafeHtml, got \x27${safeHtml}\x27 of type ` + goog.typeOf(safeHtml));\n        return \x22type_error:SafeHtml\x22;\n      }\n    }\n    static htmlEscape(textOrHtml) {\n      if (textOrHtml instanceof SafeHtml) {\n        return textOrHtml;\n      }\n      const textIsObject \x3d typeof textOrHtml \x3d\x3d \x22object\x22;\n      let textAsString;\n      if (textIsObject \x26\x26 textOrHtml.implementsGoogStringTypedString) {\n        textAsString \x3d textOrHtml.getTypedStringValue();\n      } else {\n        textAsString \x3d String(textOrHtml);\n      }\n      return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(internal.htmlEscape(textAsString));\n    }\n    static htmlEscapePreservingNewlines(textOrHtml) {\n      if (textOrHtml instanceof SafeHtml) {\n        return textOrHtml;\n      }\n      const html \x3d SafeHtml.htmlEscape(textOrHtml);\n      return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(internal.newLineToBr(SafeHtml.unwrap(html)));\n    }\n    static htmlEscapePreservingNewlinesAndSpaces(textOrHtml) {\n      if (textOrHtml instanceof SafeHtml) {\n        return textOrHtml;\n      }\n      const html \x3d SafeHtml.htmlEscape(textOrHtml);\n      return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(internal.whitespaceEscape(SafeHtml.unwrap(html)));\n    }\n    static comment(text) {\n      return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(\x22\\x3c!--\x22 + internal.htmlEscape(text) + \x22--\\x3e\x22);\n    }\n    static create(tagName, attributes \x3d undefined, content \x3d undefined) {\n      SafeHtml.verifyTagName(String(tagName));\n      return SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(String(tagName), attributes, content);\n    }\n    static verifyTagName(tagName) {\n      if (!VALID_NAMES_IN_TAG.test(tagName)) {\n        throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? `Invalid tag name \x3c${tagName}\x3e.` : \x22\x22);\n      }\n      if (tagName.toUpperCase() in NOT_ALLOWED_TAG_NAMES) {\n        throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? `Tag name \x3c${tagName}\x3e is not allowed for SafeHtml.` : \x22\x22);\n      }\n    }\n    static createIframe(src \x3d undefined, srcdoc \x3d undefined, attributes \x3d undefined, content \x3d undefined) {\n      if (src) {\n        TrustedResourceUrl.unwrap(src);\n      }\n      const fixedAttributes \x3d {};\n      fixedAttributes[\x22src\x22] \x3d src || null;\n      fixedAttributes[\x22srcdoc\x22] \x3d srcdoc \x26\x26 SafeHtml.unwrap(srcdoc);\n      const defaultAttributes \x3d {\x22sandbox\x22:\x22\x22};\n      const combinedAttrs \x3d SafeHtml.combineAttributes(fixedAttributes, defaultAttributes, attributes);\n      return SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(\x22iframe\x22, combinedAttrs, content);\n    }\n    static createSandboxIframe(src \x3d undefined, srcdoc \x3d undefined, attributes \x3d undefined, content \x3d undefined) {\n      if (!SafeHtml.canUseSandboxIframe()) {\n        throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? \x22The browser does not support sandboxed iframes.\x22 : \x22\x22);\n      }\n      const fixedAttributes \x3d {};\n      if (src) {\n        fixedAttributes[\x22src\x22] \x3d SafeUrl.unwrap(SafeUrl.sanitize(src));\n      } else {\n        fixedAttributes[\x22src\x22] \x3d null;\n      }\n      fixedAttributes[\x22srcdoc\x22] \x3d srcdoc || null;\n      fixedAttributes[\x22sandbox\x22] \x3d \x22\x22;\n      const combinedAttrs \x3d SafeHtml.combineAttributes(fixedAttributes, {}, attributes);\n      return SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(\x22iframe\x22, combinedAttrs, content);\n    }\n    static canUseSandboxIframe() {\n      return goog.global[\x22HTMLIFrameElement\x22] \x26\x26 \x22sandbox\x22 in goog.global[\x22HTMLIFrameElement\x22].prototype;\n    }\n    static createScriptSrc(src, attributes \x3d undefined) {\n      TrustedResourceUrl.unwrap(src);\n      const fixedAttributes \x3d {\x22src\x22:src};\n      const defaultAttributes \x3d {};\n      const combinedAttrs \x3d SafeHtml.combineAttributes(fixedAttributes, defaultAttributes, attributes);\n      return SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(\x22script\x22, combinedAttrs);\n    }\n    static createScript(script, attributes \x3d undefined) {\n      for (let attr in attributes) {\n        if (Object.prototype.hasOwnProperty.call(attributes, attr)) {\n          const attrLower \x3d attr.toLowerCase();\n          if (attrLower \x3d\x3d \x22language\x22 || attrLower \x3d\x3d \x22src\x22 || attrLower \x3d\x3d \x22text\x22) {\n            throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? `Cannot set \x22${attrLower}\x22 attribute` : \x22\x22);\n          }\n        }\n      }\n      let content \x3d \x22\x22;\n      script \x3d googArray.concat(script);\n      for (let i \x3d 0; i \x3c script.length; i++) {\n        content \x3d content + SafeScript.unwrap(script[i]);\n      }\n      const htmlContent \x3d SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(content);\n      return SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(\x22script\x22, attributes, htmlContent);\n    }\n    static createStyle(styleSheet, attributes \x3d undefined) {\n      const fixedAttributes \x3d {\x22type\x22:\x22text/css\x22};\n      const defaultAttributes \x3d {};\n      const combinedAttrs \x3d SafeHtml.combineAttributes(fixedAttributes, defaultAttributes, attributes);\n      let content \x3d \x22\x22;\n      styleSheet \x3d googArray.concat(styleSheet);\n      for (let i \x3d 0; i \x3c styleSheet.length; i++) {\n        content \x3d content + SafeStyleSheet.unwrap(styleSheet[i]);\n      }\n      const htmlContent \x3d SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(content);\n      return SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(\x22style\x22, combinedAttrs, htmlContent);\n    }\n    static createMetaRefresh(url, secs \x3d undefined) {\n      let unwrappedUrl \x3d SafeUrl.unwrap(SafeUrl.sanitize(url));\n      if (browser.isIE() || browser.isEdge()) {\n        if (internal.contains(unwrappedUrl, \x22;\x22)) {\n          unwrappedUrl \x3d \x22\x27\x22 + unwrappedUrl.replace(/\x27/g, \x22%27\x22) + \x22\x27\x22;\n        }\n      }\n      const attributes \x3d {\x22http-equiv\x22:\x22refresh\x22, \x22content\x22:(secs || 0) + \x22; url\\x3d\x22 + unwrappedUrl};\n      return SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(\x22meta\x22, attributes);\n    }\n    static join(separator, parts) {\n      const separatorHtml \x3d SafeHtml.htmlEscape(separator);\n      const content \x3d [];\n      const addArgument \x3d argument \x3d\x3e {\n        if (Array.isArray(argument)) {\n          argument.forEach(addArgument);\n        } else {\n          const html \x3d SafeHtml.htmlEscape(argument);\n          content.push(SafeHtml.unwrap(html));\n        }\n      };\n      parts.forEach(addArgument);\n      return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(content.join(SafeHtml.unwrap(separatorHtml)));\n    }\n    static concat(var_args) {\n      return SafeHtml.join(SafeHtml.EMPTY, Array.prototype.slice.call(arguments));\n    }\n    static createSafeHtmlSecurityPrivateDoNotAccessOrElse(html) {\n      const noinlineHtml \x3d html;\n      const policy \x3d trustedtypes.getPolicyPrivateDoNotAccessOrElse();\n      const trustedHtml \x3d policy ? policy.createHTML(noinlineHtml) : noinlineHtml;\n      return new SafeHtml(trustedHtml, CONSTRUCTOR_TOKEN_PRIVATE);\n    }\n    static createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(tagName, attributes \x3d undefined, content \x3d undefined) {\n      let result \x3d `\x3c${tagName}`;\n      result \x3d result + SafeHtml.stringifyAttributes(tagName, attributes);\n      if (content \x3d\x3d null) {\n        content \x3d [];\n      } else if (!Array.isArray(content)) {\n        content \x3d [content];\n      }\n      if (tags.isVoidTag(tagName.toLowerCase())) {\n        asserts.assert(!content.length, `Void tag \x3c${tagName}\x3e does not allow content.`);\n        result \x3d result + \x22\\x3e\x22;\n      } else {\n        const html \x3d SafeHtml.concat(content);\n        result \x3d result + (\x22\\x3e\x22 + SafeHtml.unwrap(html) + \x22\\x3c/\x22 + tagName + \x22\\x3e\x22);\n      }\n      return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(result);\n    }\n    static stringifyAttributes(tagName, attributes \x3d undefined) {\n      let result \x3d \x22\x22;\n      if (attributes) {\n        for (let name in attributes) {\n          if (Object.prototype.hasOwnProperty.call(attributes, name)) {\n            if (!VALID_NAMES_IN_TAG.test(name)) {\n              throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? `Invalid attribute name \x22${name}\x22.` : \x22\x22);\n            }\n            const value \x3d attributes[name];\n            if (value \x3d\x3d null) {\n              continue;\n            }\n            result \x3d result + (\x22 \x22 + getAttrNameAndValue(tagName, name, value));\n          }\n        }\n      }\n      return result;\n    }\n    static combineAttributes(fixedAttributes, defaultAttributes, attributes \x3d undefined) {\n      const combinedAttributes \x3d {};\n      for (const name in fixedAttributes) {\n        if (Object.prototype.hasOwnProperty.call(fixedAttributes, name)) {\n          asserts.assert(name.toLowerCase() \x3d\x3d name, \x22Must be lower case\x22);\n          combinedAttributes[name] \x3d fixedAttributes[name];\n        }\n      }\n      for (const name in defaultAttributes) {\n        if (Object.prototype.hasOwnProperty.call(defaultAttributes, name)) {\n          asserts.assert(name.toLowerCase() \x3d\x3d name, \x22Must be lower case\x22);\n          combinedAttributes[name] \x3d defaultAttributes[name];\n        }\n      }\n      if (attributes) {\n        for (const name in attributes) {\n          if (Object.prototype.hasOwnProperty.call(attributes, name)) {\n            const nameLower \x3d name.toLowerCase();\n            if (nameLower in fixedAttributes) {\n              throw new Error(SafeHtml.ENABLE_ERROR_MESSAGES ? `Cannot override \x22${nameLower}\x22 attribute, got \x22` + name + \x27\x22 with value \x22\x27 + attributes[name] + \x27\x22\x27 : \x22\x22);\n            }\n            if (nameLower in defaultAttributes) {\n              delete combinedAttributes[nameLower];\n            }\n            combinedAttributes[name] \x3d attributes[name];\n          }\n        }\n      }\n      return combinedAttributes;\n    }\n  }\n  SafeHtml.ENABLE_ERROR_MESSAGES \x3d goog.define(\x22goog.html.SafeHtml.ENABLE_ERROR_MESSAGES\x22, goog.DEBUG);\n  SafeHtml.SUPPORT_STYLE_ATTRIBUTE \x3d goog.define(\x22goog.html.SafeHtml.SUPPORT_STYLE_ATTRIBUTE\x22, true);\n  SafeHtml.TextOrHtml_;\n  SafeHtml.from \x3d SafeHtml.htmlEscape;\n  const VALID_NAMES_IN_TAG \x3d /^[a-zA-Z0-9-]+$/;\n  const URL_ATTRIBUTES \x3d googObject.createSet(\x22action\x22, \x22cite\x22, \x22data\x22, \x22formaction\x22, \x22href\x22, \x22manifest\x22, \x22poster\x22, \x22src\x22);\n  const NOT_ALLOWED_TAG_NAMES \x3d googObject.createSet(TagName.APPLET, TagName.BASE, TagName.EMBED, TagName.IFRAME, TagName.LINK, TagName.MATH, TagName.META, TagName.OBJECT, TagName.SCRIPT, TagName.STYLE, TagName.SVG, TagName.TEMPLATE);\n  SafeHtml.AttributeValue;\n  SafeHtml.DOCTYPE_HTML \x3d {valueOf:function() {\n    return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(\x22\\x3c!DOCTYPE html\\x3e\x22);\n  }}.valueOf();\n  SafeHtml.EMPTY \x3d new SafeHtml(goog.global.trustedTypes \x26\x26 goog.global.trustedTypes.emptyHTML || \x22\x22, CONSTRUCTOR_TOKEN_PRIVATE);\n  SafeHtml.BR \x3d {valueOf:function() {\n    return SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(\x22\\x3cbr\\x3e\x22);\n  }}.valueOf();\n  exports \x3d SafeHtml;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.html.uncheckedconversions.js", true, "goog.provide(\x22goog.html.uncheckedconversions\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.html.SafeHtml\x22);\ngoog.require(\x22goog.html.SafeScript\x22);\ngoog.require(\x22goog.html.SafeStyle\x22);\ngoog.require(\x22goog.html.SafeStyleSheet\x22);\ngoog.require(\x22goog.html.SafeUrl\x22);\ngoog.require(\x22goog.html.TrustedResourceUrl\x22);\ngoog.require(\x22goog.string.Const\x22);\ngoog.require(\x22goog.string.internal\x22);\ngoog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract \x3d function(justification, html) {\n  goog.asserts.assertString(goog.string.Const.unwrap(justification), \x22must provide justification\x22);\n  goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), \x22must provide non-empty justification\x22);\n  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(html);\n};\ngoog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract \x3d function(justification, script) {\n  goog.asserts.assertString(goog.string.Const.unwrap(justification), \x22must provide justification\x22);\n  goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), \x22must provide non-empty justification\x22);\n  return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(script);\n};\ngoog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract \x3d function(justification, style) {\n  goog.asserts.assertString(goog.string.Const.unwrap(justification), \x22must provide justification\x22);\n  goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), \x22must provide non-empty justification\x22);\n  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(style);\n};\ngoog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract \x3d function(justification, styleSheet) {\n  goog.asserts.assertString(goog.string.Const.unwrap(justification), \x22must provide justification\x22);\n  goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), \x22must provide non-empty justification\x22);\n  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheet);\n};\ngoog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract \x3d function(justification, url) {\n  goog.asserts.assertString(goog.string.Const.unwrap(justification), \x22must provide justification\x22);\n  goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), \x22must provide non-empty justification\x22);\n  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);\n};\ngoog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract \x3d function(justification, url) {\n  goog.asserts.assertString(goog.string.Const.unwrap(justification), \x22must provide justification\x22);\n  goog.asserts.assert(!goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), \x22must provide non-empty justification\x22);\n  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(url);\n};\n");
SHADOW_ENV.evalLoad("goog.dom.safe.js", true, "goog.provide(\x22goog.dom.safe\x22);\ngoog.provide(\x22goog.dom.safe.InsertAdjacentHtmlPosition\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.asserts.dom\x22);\ngoog.require(\x22goog.dom.asserts\x22);\ngoog.require(\x22goog.functions\x22);\ngoog.require(\x22goog.html.SafeHtml\x22);\ngoog.require(\x22goog.html.SafeScript\x22);\ngoog.require(\x22goog.html.SafeStyle\x22);\ngoog.require(\x22goog.html.SafeUrl\x22);\ngoog.require(\x22goog.html.TrustedResourceUrl\x22);\ngoog.require(\x22goog.html.uncheckedconversions\x22);\ngoog.require(\x22goog.string.Const\x22);\ngoog.require(\x22goog.string.internal\x22);\ngoog.dom.safe.InsertAdjacentHtmlPosition \x3d {AFTERBEGIN:\x22afterbegin\x22, AFTEREND:\x22afterend\x22, BEFOREBEGIN:\x22beforebegin\x22, BEFOREEND:\x22beforeend\x22};\ngoog.dom.safe.insertAdjacentHtml \x3d function(node, position, html) {\n  node.insertAdjacentHTML(position, goog.html.SafeHtml.unwrapTrustedHTML(html));\n};\ngoog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_ \x3d {\x22MATH\x22:true, \x22SCRIPT\x22:true, \x22STYLE\x22:true, \x22SVG\x22:true, \x22TEMPLATE\x22:true};\ngoog.dom.safe.isInnerHtmlCleanupRecursive_ \x3d goog.functions.cacheReturnValue(function() {\n  if (goog.DEBUG \x26\x26 typeof document \x3d\x3d\x3d \x22undefined\x22) {\n    return false;\n  }\n  var div \x3d document.createElement(\x22div\x22);\n  var childDiv \x3d document.createElement(\x22div\x22);\n  childDiv.appendChild(document.createElement(\x22div\x22));\n  div.appendChild(childDiv);\n  if (goog.DEBUG \x26\x26 !div.firstChild) {\n    return false;\n  }\n  var innerChild \x3d div.firstChild.firstChild;\n  div.innerHTML \x3d goog.html.SafeHtml.unwrapTrustedHTML(goog.html.SafeHtml.EMPTY);\n  return !innerChild.parentElement;\n});\ngoog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse \x3d function(elem, html) {\n  if (goog.dom.safe.isInnerHtmlCleanupRecursive_()) {\n    for (; elem.lastChild;) {\n      elem.removeChild(elem.lastChild);\n    }\n  }\n  elem.innerHTML \x3d goog.html.SafeHtml.unwrapTrustedHTML(html);\n};\ngoog.dom.safe.setInnerHtml \x3d function(elem, html) {\n  if (goog.asserts.ENABLE_ASSERTS \x26\x26 elem.tagName) {\n    var tagName \x3d elem.tagName.toUpperCase();\n    if (goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[tagName]) {\n      throw new Error(\x22goog.dom.safe.setInnerHtml cannot be used to set content of \x22 + elem.tagName + \x22.\x22);\n    }\n  }\n  goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse(elem, html);\n};\ngoog.dom.safe.setInnerHtmlFromConstant \x3d function(element, constHtml) {\n  goog.dom.safe.setInnerHtml(element, goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from(\x22Constant HTML to be immediatelly used.\x22), goog.string.Const.unwrap(constHtml)));\n};\ngoog.dom.safe.setOuterHtml \x3d function(elem, html) {\n  elem.outerHTML \x3d goog.html.SafeHtml.unwrapTrustedHTML(html);\n};\ngoog.dom.safe.setFormElementAction \x3d function(form, url) {\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  goog.asserts.dom.assertIsHtmlFormElement(form).action \x3d goog.html.SafeUrl.unwrap(safeUrl);\n};\ngoog.dom.safe.setButtonFormAction \x3d function(button, url) {\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  goog.asserts.dom.assertIsHtmlButtonElement(button).formAction \x3d goog.html.SafeUrl.unwrap(safeUrl);\n};\ngoog.dom.safe.setInputFormAction \x3d function(input, url) {\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  goog.asserts.dom.assertIsHtmlInputElement(input).formAction \x3d goog.html.SafeUrl.unwrap(safeUrl);\n};\ngoog.dom.safe.setStyle \x3d function(elem, style) {\n  elem.style.cssText \x3d goog.html.SafeStyle.unwrap(style);\n};\ngoog.dom.safe.documentWrite \x3d function(doc, html) {\n  doc.write(goog.html.SafeHtml.unwrapTrustedHTML(html));\n};\ngoog.dom.safe.setAnchorHref \x3d function(anchor, url) {\n  goog.asserts.dom.assertIsHtmlAnchorElement(anchor);\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  anchor.href \x3d goog.html.SafeUrl.unwrap(safeUrl);\n};\ngoog.dom.safe.setAudioSrc \x3d function(audioElement, url) {\n  goog.asserts.dom.assertIsHtmlAudioElement(audioElement);\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  audioElement.src \x3d goog.html.SafeUrl.unwrap(safeUrl);\n};\ngoog.dom.safe.setVideoSrc \x3d function(videoElement, url) {\n  goog.asserts.dom.assertIsHtmlVideoElement(videoElement);\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  videoElement.src \x3d goog.html.SafeUrl.unwrap(safeUrl);\n};\ngoog.dom.safe.setEmbedSrc \x3d function(embed, url) {\n  goog.asserts.dom.assertIsHtmlEmbedElement(embed);\n  embed.src \x3d goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(url);\n};\ngoog.dom.safe.setFrameSrc \x3d function(frame, url) {\n  goog.asserts.dom.assertIsHtmlFrameElement(frame);\n  frame.src \x3d goog.html.TrustedResourceUrl.unwrap(url);\n};\ngoog.dom.safe.setIframeSrc \x3d function(iframe, url) {\n  goog.asserts.dom.assertIsHtmlIFrameElement(iframe);\n  iframe.src \x3d goog.html.TrustedResourceUrl.unwrap(url);\n};\ngoog.dom.safe.setIframeSrcdoc \x3d function(iframe, html) {\n  goog.asserts.dom.assertIsHtmlIFrameElement(iframe);\n  iframe.srcdoc \x3d goog.html.SafeHtml.unwrapTrustedHTML(html);\n};\ngoog.dom.safe.setLinkHrefAndRel \x3d function(link, url, rel) {\n  goog.asserts.dom.assertIsHtmlLinkElement(link);\n  link.rel \x3d rel;\n  if (goog.string.internal.caseInsensitiveContains(rel, \x22stylesheet\x22)) {\n    goog.asserts.assert(url instanceof goog.html.TrustedResourceUrl, \x27URL must be TrustedResourceUrl because \x22rel\x22 contains \x22stylesheet\x22\x27);\n    link.href \x3d goog.html.TrustedResourceUrl.unwrap(url);\n    const win \x3d link.ownerDocument \x26\x26 link.ownerDocument.defaultView;\n    const nonce \x3d goog.dom.safe.getStyleNonce(win);\n    if (nonce) {\n      link.setAttribute(\x22nonce\x22, nonce);\n    }\n  } else if (url instanceof goog.html.TrustedResourceUrl) {\n    link.href \x3d goog.html.TrustedResourceUrl.unwrap(url);\n  } else if (url instanceof goog.html.SafeUrl) {\n    link.href \x3d goog.html.SafeUrl.unwrap(url);\n  } else {\n    link.href \x3d goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url));\n  }\n};\ngoog.dom.safe.setObjectData \x3d function(object, url) {\n  goog.asserts.dom.assertIsHtmlObjectElement(object);\n  object.data \x3d goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(url);\n};\ngoog.dom.safe.setScriptSrc \x3d function(script, url) {\n  goog.asserts.dom.assertIsHtmlScriptElement(script);\n  goog.dom.safe.setNonceForScriptElement_(script);\n  script.src \x3d goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(url);\n};\ngoog.dom.safe.setScriptContent \x3d function(script, content) {\n  goog.asserts.dom.assertIsHtmlScriptElement(script);\n  goog.dom.safe.setNonceForScriptElement_(script);\n  script.textContent \x3d goog.html.SafeScript.unwrapTrustedScript(content);\n};\ngoog.dom.safe.setNonceForScriptElement_ \x3d function(script) {\n  var win \x3d script.ownerDocument \x26\x26 script.ownerDocument.defaultView;\n  const nonce \x3d goog.dom.safe.getScriptNonce(win);\n  if (nonce) {\n    script.setAttribute(\x22nonce\x22, nonce);\n  }\n};\ngoog.dom.safe.setLocationHref \x3d function(loc, url) {\n  goog.dom.asserts.assertIsLocation(loc);\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  loc.href \x3d goog.html.SafeUrl.unwrap(safeUrl);\n};\ngoog.dom.safe.assignLocation \x3d function(loc, url) {\n  goog.dom.asserts.assertIsLocation(loc);\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  loc.assign(goog.html.SafeUrl.unwrap(safeUrl));\n};\ngoog.dom.safe.replaceLocation \x3d function(loc, url) {\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  loc.replace(goog.html.SafeUrl.unwrap(safeUrl));\n};\ngoog.dom.safe.openInWindow \x3d function(url, opt_openerWin, opt_name, opt_specs) {\n  var safeUrl;\n  if (url instanceof goog.html.SafeUrl) {\n    safeUrl \x3d url;\n  } else {\n    safeUrl \x3d goog.html.SafeUrl.sanitizeJavascriptUrlAssertUnchanged(url);\n  }\n  var win \x3d opt_openerWin || goog.global;\n  var name \x3d opt_name instanceof goog.string.Const ? goog.string.Const.unwrap(opt_name) : opt_name || \x22\x22;\n  if (opt_specs !\x3d\x3d undefined) {\n    return win.open(goog.html.SafeUrl.unwrap(safeUrl), name, opt_specs);\n  } else {\n    return win.open(goog.html.SafeUrl.unwrap(safeUrl), name);\n  }\n};\ngoog.dom.safe.parseFromStringHtml \x3d function(parser, html) {\n  return goog.dom.safe.parseFromString(parser, html, \x22text/html\x22);\n};\ngoog.dom.safe.parseFromString \x3d function(parser, content, type) {\n  return parser.parseFromString(goog.html.SafeHtml.unwrapTrustedHTML(content), type);\n};\ngoog.dom.safe.createImageFromBlob \x3d function(blob) {\n  if (!/^image\\/.*/g.test(blob.type)) {\n    throw new Error(\x22goog.dom.safe.createImageFromBlob only accepts MIME type image/.*.\x22);\n  }\n  var objectUrl \x3d goog.global.URL.createObjectURL(blob);\n  var image \x3d new goog.global.Image();\n  image.onload \x3d function() {\n    goog.global.URL.revokeObjectURL(objectUrl);\n  };\n  image.src \x3d objectUrl;\n  return image;\n};\ngoog.dom.safe.createContextualFragment \x3d function(range, html) {\n  return range.createContextualFragment(goog.html.SafeHtml.unwrapTrustedHTML(html));\n};\ngoog.dom.safe.getScriptNonce \x3d function(opt_window) {\n  return goog.dom.safe.getNonce_(\x22script[nonce]\x22, opt_window);\n};\ngoog.dom.safe.getStyleNonce \x3d function(opt_window) {\n  return goog.dom.safe.getNonce_(\x27style[nonce],link[rel\\x3d\x22stylesheet\x22][nonce]\x27, opt_window);\n};\ngoog.dom.safe.NONCE_PATTERN_ \x3d /^[\\w+/_-]+[\x3d]{0,2}$/;\ngoog.dom.safe.getNonce_ \x3d function(selector, win) {\n  const doc \x3d (win || goog.global).document;\n  if (!doc.querySelector) {\n    return \x22\x22;\n  }\n  let el \x3d doc.querySelector(selector);\n  if (el) {\n    const nonce \x3d el[\x22nonce\x22] || el.getAttribute(\x22nonce\x22);\n    if (nonce \x26\x26 goog.dom.safe.NONCE_PATTERN_.test(nonce)) {\n      return nonce;\n    }\n  }\n  return \x22\x22;\n};\n");
SHADOW_ENV.evalLoad("goog.string.string.js", true, "goog.provide(\x22goog.string\x22);\ngoog.provide(\x22goog.string.Unicode\x22);\ngoog.require(\x22goog.dom.safe\x22);\ngoog.require(\x22goog.html.uncheckedconversions\x22);\ngoog.require(\x22goog.string.Const\x22);\ngoog.require(\x22goog.string.internal\x22);\ngoog.string.DETECT_DOUBLE_ESCAPING \x3d goog.define(\x22goog.string.DETECT_DOUBLE_ESCAPING\x22, false);\ngoog.string.FORCE_NON_DOM_HTML_UNESCAPING \x3d goog.define(\x22goog.string.FORCE_NON_DOM_HTML_UNESCAPING\x22, false);\ngoog.string.Unicode \x3d {NBSP:\x22\xa0\x22, ZERO_WIDTH_SPACE:\x22\u200b\x22};\ngoog.string.startsWith \x3d goog.string.internal.startsWith;\ngoog.string.endsWith \x3d goog.string.internal.endsWith;\ngoog.string.caseInsensitiveStartsWith \x3d goog.string.internal.caseInsensitiveStartsWith;\ngoog.string.caseInsensitiveEndsWith \x3d goog.string.internal.caseInsensitiveEndsWith;\ngoog.string.caseInsensitiveEquals \x3d goog.string.internal.caseInsensitiveEquals;\ngoog.string.subs \x3d function(str, var_args) {\n  const splitParts \x3d str.split(\x22%s\x22);\n  let returnString \x3d \x22\x22;\n  const subsArguments \x3d Array.prototype.slice.call(arguments, 1);\n  for (; subsArguments.length \x26\x26 splitParts.length \x3e 1;) {\n    returnString \x3d returnString + (splitParts.shift() + subsArguments.shift());\n  }\n  return returnString + splitParts.join(\x22%s\x22);\n};\ngoog.string.collapseWhitespace \x3d function(str) {\n  return str.replace(/[\\s\\xa0]+/g, \x22 \x22).replace(/^\\s+|\\s+$/g, \x22\x22);\n};\ngoog.string.isEmptyOrWhitespace \x3d goog.string.internal.isEmptyOrWhitespace;\ngoog.string.isEmptyString \x3d function(str) {\n  return str.length \x3d\x3d 0;\n};\ngoog.string.isEmpty \x3d goog.string.isEmptyOrWhitespace;\ngoog.string.isEmptyOrWhitespaceSafe \x3d function(str) {\n  return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(str));\n};\ngoog.string.isEmptySafe \x3d goog.string.isEmptyOrWhitespaceSafe;\ngoog.string.isBreakingWhitespace \x3d function(str) {\n  return !/[^\\t\\n\\r ]/.test(str);\n};\ngoog.string.isAlpha \x3d function(str) {\n  return !/[^a-zA-Z]/.test(str);\n};\ngoog.string.isNumeric \x3d function(str) {\n  return !/[^0-9]/.test(str);\n};\ngoog.string.isAlphaNumeric \x3d function(str) {\n  return !/[^a-zA-Z0-9]/.test(str);\n};\ngoog.string.isSpace \x3d function(ch) {\n  return ch \x3d\x3d \x22 \x22;\n};\ngoog.string.isUnicodeChar \x3d function(ch) {\n  return ch.length \x3d\x3d 1 \x26\x26 ch \x3e\x3d \x22 \x22 \x26\x26 ch \x3c\x3d \x22~\x22 || ch \x3e\x3d \x22\x80\x22 \x26\x26 ch \x3c\x3d \x22\ufffd\x22;\n};\ngoog.string.stripNewlines \x3d function(str) {\n  return str.replace(/(\\r\\n|\\r|\\n)+/g, \x22 \x22);\n};\ngoog.string.canonicalizeNewlines \x3d function(str) {\n  return str.replace(/(\\r\\n|\\r|\\n)/g, \x22\\n\x22);\n};\ngoog.string.normalizeWhitespace \x3d function(str) {\n  return str.replace(/\\xa0|\\s/g, \x22 \x22);\n};\ngoog.string.normalizeSpaces \x3d function(str) {\n  return str.replace(/\\xa0|[ \\t]+/g, \x22 \x22);\n};\ngoog.string.collapseBreakingSpaces \x3d function(str) {\n  return str.replace(/[\\t\\r\\n ]+/g, \x22 \x22).replace(/^[\\t\\r\\n ]+|[\\t\\r\\n ]+$/g, \x22\x22);\n};\ngoog.string.trim \x3d goog.string.internal.trim;\ngoog.string.trimLeft \x3d function(str) {\n  return str.replace(/^[\\s\\xa0]+/, \x22\x22);\n};\ngoog.string.trimRight \x3d function(str) {\n  return str.replace(/[\\s\\xa0]+$/, \x22\x22);\n};\ngoog.string.caseInsensitiveCompare \x3d goog.string.internal.caseInsensitiveCompare;\ngoog.string.numberAwareCompare_ \x3d function(str1, str2, tokenizerRegExp) {\n  if (str1 \x3d\x3d str2) {\n    return 0;\n  }\n  if (!str1) {\n    return -1;\n  }\n  if (!str2) {\n    return 1;\n  }\n  const tokens1 \x3d str1.toLowerCase().match(tokenizerRegExp);\n  const tokens2 \x3d str2.toLowerCase().match(tokenizerRegExp);\n  const count \x3d Math.min(tokens1.length, tokens2.length);\n  for (let i \x3d 0; i \x3c count; i++) {\n    const a \x3d tokens1[i];\n    const b \x3d tokens2[i];\n    if (a !\x3d b) {\n      const num1 \x3d parseInt(a, 10);\n      if (!isNaN(num1)) {\n        const num2 \x3d parseInt(b, 10);\n        if (!isNaN(num2) \x26\x26 num1 - num2) {\n          return num1 - num2;\n        }\n      }\n      return a \x3c b ? -1 : 1;\n    }\n  }\n  if (tokens1.length !\x3d tokens2.length) {\n    return tokens1.length - tokens2.length;\n  }\n  return str1 \x3c str2 ? -1 : 1;\n};\ngoog.string.intAwareCompare \x3d function(str1, str2) {\n  return goog.string.numberAwareCompare_(str1, str2, /\\d+|\\D+/g);\n};\ngoog.string.floatAwareCompare \x3d function(str1, str2) {\n  return goog.string.numberAwareCompare_(str1, str2, /\\d+|\\.\\d+|\\D+/g);\n};\ngoog.string.numerateCompare \x3d goog.string.floatAwareCompare;\ngoog.string.urlEncode \x3d function(str) {\n  return encodeURIComponent(String(str));\n};\ngoog.string.urlDecode \x3d function(str) {\n  return decodeURIComponent(str.replace(/\\+/g, \x22 \x22));\n};\ngoog.string.newLineToBr \x3d goog.string.internal.newLineToBr;\ngoog.string.htmlEscape \x3d function(str, opt_isLikelyToContainHtmlChars) {\n  str \x3d goog.string.internal.htmlEscape(str, opt_isLikelyToContainHtmlChars);\n  if (goog.string.DETECT_DOUBLE_ESCAPING) {\n    str \x3d str.replace(goog.string.E_RE_, \x22\\x26#101;\x22);\n  }\n  return str;\n};\ngoog.string.E_RE_ \x3d /e/g;\ngoog.string.unescapeEntities \x3d function(str) {\n  if (goog.string.contains(str, \x22\\x26\x22)) {\n    if (!goog.string.FORCE_NON_DOM_HTML_UNESCAPING \x26\x26 \x22document\x22 in goog.global) {\n      return goog.string.unescapeEntitiesUsingDom_(str);\n    } else {\n      return goog.string.unescapePureXmlEntities_(str);\n    }\n  }\n  return str;\n};\ngoog.string.unescapeEntitiesWithDocument \x3d function(str, document) {\n  if (goog.string.contains(str, \x22\\x26\x22)) {\n    return goog.string.unescapeEntitiesUsingDom_(str, document);\n  }\n  return str;\n};\ngoog.string.unescapeEntitiesUsingDom_ \x3d function(str, opt_document) {\n  const seen \x3d {\x22\\x26amp;\x22:\x22\\x26\x22, \x22\\x26lt;\x22:\x22\\x3c\x22, \x22\\x26gt;\x22:\x22\\x3e\x22, \x22\\x26quot;\x22:\x27\x22\x27};\n  let div;\n  if (opt_document) {\n    div \x3d opt_document.createElement(\x22div\x22);\n  } else {\n    div \x3d goog.global.document.createElement(\x22div\x22);\n  }\n  return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {\n    let value \x3d seen[s];\n    if (value) {\n      return value;\n    }\n    if (entity.charAt(0) \x3d\x3d \x22#\x22) {\n      const n \x3d Number(\x220\x22 + entity.slice(1));\n      if (!isNaN(n)) {\n        value \x3d String.fromCharCode(n);\n      }\n    }\n    if (!value) {\n      goog.dom.safe.setInnerHtml(div, goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from(\x22Single HTML entity.\x22), s + \x22 \x22));\n      value \x3d div.firstChild.nodeValue.slice(0, -1);\n    }\n    return seen[s] \x3d value;\n  });\n};\ngoog.string.unescapePureXmlEntities_ \x3d function(str) {\n  return str.replace(/\x26([^;]+);/g, function(s, entity) {\n    switch(entity) {\n      case \x22amp\x22:\n        return \x22\\x26\x22;\n      case \x22lt\x22:\n        return \x22\\x3c\x22;\n      case \x22gt\x22:\n        return \x22\\x3e\x22;\n      case \x22quot\x22:\n        return \x27\x22\x27;\n      default:\n        if (entity.charAt(0) \x3d\x3d \x22#\x22) {\n          const n \x3d Number(\x220\x22 + entity.slice(1));\n          if (!isNaN(n)) {\n            return String.fromCharCode(n);\n          }\n        }\n        return s;\n    }\n  });\n};\ngoog.string.HTML_ENTITY_PATTERN_ \x3d /\x26([^;\\s\x3c\x26]+);?/g;\ngoog.string.whitespaceEscape \x3d function(str, opt_xml) {\n  return goog.string.newLineToBr(str.replace(/  /g, \x22 \\x26#160;\x22), opt_xml);\n};\ngoog.string.preserveSpaces \x3d function(str) {\n  return str.replace(/(^|[\\n ]) /g, \x22$1\x22 + goog.string.Unicode.NBSP);\n};\ngoog.string.stripQuotes \x3d function(str, quoteChars) {\n  const length \x3d quoteChars.length;\n  for (let i \x3d 0; i \x3c length; i++) {\n    const quoteChar \x3d length \x3d\x3d 1 ? quoteChars : quoteChars.charAt(i);\n    if (str.charAt(0) \x3d\x3d quoteChar \x26\x26 str.charAt(str.length - 1) \x3d\x3d quoteChar) {\n      return str.substring(1, str.length - 1);\n    }\n  }\n  return str;\n};\ngoog.string.truncate \x3d function(str, chars, opt_protectEscapedCharacters) {\n  if (opt_protectEscapedCharacters) {\n    str \x3d goog.string.unescapeEntities(str);\n  }\n  if (str.length \x3e chars) {\n    str \x3d str.substring(0, chars - 3) + \x22...\x22;\n  }\n  if (opt_protectEscapedCharacters) {\n    str \x3d goog.string.htmlEscape(str);\n  }\n  return str;\n};\ngoog.string.truncateMiddle \x3d function(str, chars, opt_protectEscapedCharacters, opt_trailingChars) {\n  if (opt_protectEscapedCharacters) {\n    str \x3d goog.string.unescapeEntities(str);\n  }\n  if (opt_trailingChars \x26\x26 str.length \x3e chars) {\n    if (opt_trailingChars \x3e chars) {\n      opt_trailingChars \x3d chars;\n    }\n    const endPoint \x3d str.length - opt_trailingChars;\n    const startPoint \x3d chars - opt_trailingChars;\n    str \x3d str.substring(0, startPoint) + \x22...\x22 + str.substring(endPoint);\n  } else if (str.length \x3e chars) {\n    let half \x3d Math.floor(chars / 2);\n    const endPos \x3d str.length - half;\n    half \x3d half + chars % 2;\n    str \x3d str.substring(0, half) + \x22...\x22 + str.substring(endPos);\n  }\n  if (opt_protectEscapedCharacters) {\n    str \x3d goog.string.htmlEscape(str);\n  }\n  return str;\n};\ngoog.string.specialEscapeChars_ \x3d {\x22\\x00\x22:\x22\\\\0\x22, \x22\\b\x22:\x22\\\\b\x22, \x22\\f\x22:\x22\\\\f\x22, \x22\\n\x22:\x22\\\\n\x22, \x22\\r\x22:\x22\\\\r\x22, \x22\\t\x22:\x22\\\\t\x22, \x22\\v\x22:\x22\\\\x0B\x22, \x27\x22\x27:\x27\\\\\x22\x27, \x22\\\\\x22:\x22\\\\\\\\\x22, \x22\\x3c\x22:\x22\\\\u003C\x22};\ngoog.string.jsEscapeCache_ \x3d {\x22\x27\x22:\x22\\\\\x27\x22};\ngoog.string.quote \x3d function(s) {\n  s \x3d String(s);\n  const sb \x3d [\x27\x22\x27];\n  for (let i \x3d 0; i \x3c s.length; i++) {\n    const ch \x3d s.charAt(i);\n    const cc \x3d ch.charCodeAt(0);\n    sb[i + 1] \x3d goog.string.specialEscapeChars_[ch] || (cc \x3e 31 \x26\x26 cc \x3c 127 ? ch : goog.string.escapeChar(ch));\n  }\n  sb.push(\x27\x22\x27);\n  return sb.join(\x22\x22);\n};\ngoog.string.escapeString \x3d function(str) {\n  const sb \x3d [];\n  for (let i \x3d 0; i \x3c str.length; i++) {\n    sb[i] \x3d goog.string.escapeChar(str.charAt(i));\n  }\n  return sb.join(\x22\x22);\n};\ngoog.string.escapeChar \x3d function(c) {\n  if (c in goog.string.jsEscapeCache_) {\n    return goog.string.jsEscapeCache_[c];\n  }\n  if (c in goog.string.specialEscapeChars_) {\n    return goog.string.jsEscapeCache_[c] \x3d goog.string.specialEscapeChars_[c];\n  }\n  let rv \x3d c;\n  const cc \x3d c.charCodeAt(0);\n  if (cc \x3e 31 \x26\x26 cc \x3c 127) {\n    rv \x3d c;\n  } else {\n    if (cc \x3c 256) {\n      rv \x3d \x22\\\\x\x22;\n      if (cc \x3c 16 || cc \x3e 256) {\n        rv \x3d rv + \x220\x22;\n      }\n    } else {\n      rv \x3d \x22\\\\u\x22;\n      if (cc \x3c 4096) {\n        rv \x3d rv + \x220\x22;\n      }\n    }\n    rv \x3d rv + cc.toString(16).toUpperCase();\n  }\n  return goog.string.jsEscapeCache_[c] \x3d rv;\n};\ngoog.string.contains \x3d goog.string.internal.contains;\ngoog.string.caseInsensitiveContains \x3d goog.string.internal.caseInsensitiveContains;\ngoog.string.countOf \x3d function(s, ss) {\n  return s \x26\x26 ss ? s.split(ss).length - 1 : 0;\n};\ngoog.string.removeAt \x3d function(s, index, stringLength) {\n  let resultStr \x3d s;\n  if (index \x3e\x3d 0 \x26\x26 index \x3c s.length \x26\x26 stringLength \x3e 0) {\n    resultStr \x3d s.slice(0, index) + s.slice(index + stringLength);\n  }\n  return resultStr;\n};\ngoog.string.remove \x3d function(str, substr) {\n  return str.replace(substr, \x22\x22);\n};\ngoog.string.removeAll \x3d function(s, ss) {\n  const re \x3d new RegExp(goog.string.regExpEscape(ss), \x22g\x22);\n  return s.replace(re, \x22\x22);\n};\ngoog.string.replaceAll \x3d function(s, ss, replacement) {\n  const re \x3d new RegExp(goog.string.regExpEscape(ss), \x22g\x22);\n  return s.replace(re, replacement.replace(/\\$/g, \x22$$$$\x22));\n};\ngoog.string.regExpEscape \x3d function(s) {\n  return String(s).replace(/([-()\\[\\]{}+?*.$\\^|,:#\x3c!\\\\])/g, \x22\\\\$1\x22).replace(/\\x08/g, \x22\\\\x08\x22);\n};\ngoog.string.repeat \x3d String.prototype.repeat ? function(string, length) {\n  return string.repeat(length);\n} : function(string, length) {\n  return (new Array(length + 1)).join(string);\n};\ngoog.string.padNumber \x3d function(num, length, opt_precision) {\n  if (!Number.isFinite(num)) {\n    return String(num);\n  }\n  let s \x3d opt_precision !\x3d\x3d undefined ? num.toFixed(opt_precision) : String(num);\n  let index \x3d s.indexOf(\x22.\x22);\n  if (index \x3d\x3d\x3d -1) {\n    index \x3d s.length;\n  }\n  const sign \x3d s[0] \x3d\x3d\x3d \x22-\x22 ? \x22-\x22 : \x22\x22;\n  if (sign) {\n    s \x3d s.substring(1);\n  }\n  return sign + goog.string.repeat(\x220\x22, Math.max(0, length - index)) + s;\n};\ngoog.string.makeSafe \x3d function(obj) {\n  return obj \x3d\x3d null ? \x22\x22 : String(obj);\n};\ngoog.string.getRandomString \x3d function() {\n  const x \x3d 2147483648;\n  return Math.floor(Math.random() * x).toString(36) + Math.abs(Math.floor(Math.random() * x) ^ goog.now()).toString(36);\n};\ngoog.string.compareVersions \x3d goog.string.internal.compareVersions;\ngoog.string.hashCode \x3d function(str) {\n  let result \x3d 0;\n  for (let i \x3d 0; i \x3c str.length; ++i) {\n    result \x3d 31 * result + str.charCodeAt(i) \x3e\x3e\x3e 0;\n  }\n  return result;\n};\ngoog.string.uniqueStringCounter_ \x3d Math.random() * 2147483648 | 0;\ngoog.string.createUniqueString \x3d function() {\n  return \x22goog_\x22 + goog.string.uniqueStringCounter_++;\n};\ngoog.string.toNumber \x3d function(str) {\n  const num \x3d Number(str);\n  if (num \x3d\x3d 0 \x26\x26 goog.string.isEmptyOrWhitespace(str)) {\n    return NaN;\n  }\n  return num;\n};\ngoog.string.isLowerCamelCase \x3d function(str) {\n  return /^[a-z]+([A-Z][a-z]*)*$/.test(str);\n};\ngoog.string.isUpperCamelCase \x3d function(str) {\n  return /^([A-Z][a-z]*)+$/.test(str);\n};\ngoog.string.toCamelCase \x3d function(str) {\n  return String(str).replace(/\\-([a-z])/g, function(all, match) {\n    return match.toUpperCase();\n  });\n};\ngoog.string.toSelectorCase \x3d function(str) {\n  return String(str).replace(/([A-Z])/g, \x22-$1\x22).toLowerCase();\n};\ngoog.string.toTitleCase \x3d function(str, opt_delimiters) {\n  let delimiters \x3d typeof opt_delimiters \x3d\x3d\x3d \x22string\x22 ? goog.string.regExpEscape(opt_delimiters) : \x22\\\\s\x22;\n  delimiters \x3d delimiters ? \x22|[\x22 + delimiters + \x22]+\x22 : \x22\x22;\n  const regexp \x3d new RegExp(\x22(^\x22 + delimiters + \x22)([a-z])\x22, \x22g\x22);\n  return str.replace(regexp, function(all, p1, p2) {\n    return p1 + p2.toUpperCase();\n  });\n};\ngoog.string.capitalize \x3d function(str) {\n  return String(str.charAt(0)).toUpperCase() + String(str.slice(1)).toLowerCase();\n};\ngoog.string.parseInt \x3d function(value) {\n  if (isFinite(value)) {\n    value \x3d String(value);\n  }\n  if (typeof value \x3d\x3d\x3d \x22string\x22) {\n    return /^\\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10);\n  }\n  return NaN;\n};\ngoog.string.splitLimit \x3d function(str, separator, limit) {\n  const parts \x3d str.split(separator);\n  const returnVal \x3d [];\n  for (; limit \x3e 0 \x26\x26 parts.length;) {\n    returnVal.push(parts.shift());\n    limit--;\n  }\n  if (parts.length) {\n    returnVal.push(parts.join(separator));\n  }\n  return returnVal;\n};\ngoog.string.lastComponent \x3d function(str, separators) {\n  if (!separators) {\n    return str;\n  } else if (typeof separators \x3d\x3d \x22string\x22) {\n    separators \x3d [separators];\n  }\n  let lastSeparatorIndex \x3d -1;\n  for (let i \x3d 0; i \x3c separators.length; i++) {\n    if (separators[i] \x3d\x3d \x22\x22) {\n      continue;\n    }\n    const currentSeparatorIndex \x3d str.lastIndexOf(separators[i]);\n    if (currentSeparatorIndex \x3e lastSeparatorIndex) {\n      lastSeparatorIndex \x3d currentSeparatorIndex;\n    }\n  }\n  if (lastSeparatorIndex \x3d\x3d -1) {\n    return str;\n  }\n  return str.slice(lastSeparatorIndex + 1);\n};\ngoog.string.editDistance \x3d function(a, b) {\n  const v0 \x3d [];\n  const v1 \x3d [];\n  if (a \x3d\x3d b) {\n    return 0;\n  }\n  if (!a.length || !b.length) {\n    return Math.max(a.length, b.length);\n  }\n  for (let i \x3d 0; i \x3c b.length + 1; i++) {\n    v0[i] \x3d i;\n  }\n  for (let i \x3d 0; i \x3c a.length; i++) {\n    v1[0] \x3d i + 1;\n    for (let j \x3d 0; j \x3c b.length; j++) {\n      const cost \x3d Number(a[i] !\x3d b[j]);\n      v1[j + 1] \x3d Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);\n    }\n    for (let j \x3d 0; j \x3c v0.length; j++) {\n      v0[j] \x3d v1[j];\n    }\n  }\n  return v1[b.length];\n};\n");
SHADOW_ENV.evalLoad("goog.collections.maps.js", true, "goog.loadModule(function(exports) {\n  function setAll(map, entries) {\n    if (!entries) {\n      return;\n    }\n    for (const [k, v] of entries) {\n      map.set(k, v);\n    }\n  }\n  function hasValue(map, val, valueEqualityFn \x3d defaultEqualityFn) {\n    for (const v of map.values()) {\n      if (valueEqualityFn(v, val)) {\n        return true;\n      }\n    }\n    return false;\n  }\n  function equals(map, otherMap, valueEqualityFn \x3d defaultEqualityFn) {\n    if (map \x3d\x3d\x3d otherMap) {\n      return true;\n    }\n    if (map.size !\x3d\x3d otherMap.size) {\n      return false;\n    }\n    for (const key of map.keys()) {\n      if (!otherMap.has(key)) {\n        return false;\n      }\n      if (!valueEqualityFn(map.get(key), otherMap.get(key))) {\n        return false;\n      }\n    }\n    return true;\n  }\n  function transpose(map) {\n    const transposed \x3d new Map();\n    for (const key of map.keys()) {\n      const val \x3d map.get(key);\n      transposed.set(val, key);\n    }\n    return transposed;\n  }\n  function toObject(map) {\n    const obj \x3d {};\n    for (const key of map.keys()) {\n      obj[key] \x3d map.get(key);\n    }\n    return obj;\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.collections.maps\x22);\n  goog.module.declareLegacyNamespace();\n  class MapLike {\n    constructor() {\n      this.size;\n    }\n    set(key, val) {\n    }\n    get(key) {\n    }\n    keys() {\n    }\n    values() {\n    }\n    has(key) {\n    }\n  }\n  exports.MapLike \x3d MapLike;\n  exports.setAll \x3d setAll;\n  exports.hasValue \x3d hasValue;\n  const defaultEqualityFn \x3d (a, b) \x3d\x3e {\n    return a \x3d\x3d\x3d b;\n  };\n  exports.equals \x3d equals;\n  exports.transpose \x3d transpose;\n  exports.toObject \x3d toObject;\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.structs.structs.js", true, "goog.provide(\x22goog.structs\x22);\ngoog.require(\x22goog.array\x22);\ngoog.require(\x22goog.object\x22);\ngoog.structs.getCount \x3d function(col) {\n  if (col.getCount \x26\x26 typeof col.getCount \x3d\x3d \x22function\x22) {\n    return col.getCount();\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    return col.length;\n  }\n  return goog.object.getCount(col);\n};\ngoog.structs.getValues \x3d function(col) {\n  if (col.getValues \x26\x26 typeof col.getValues \x3d\x3d \x22function\x22) {\n    return col.getValues();\n  }\n  if (typeof Map !\x3d\x3d \x22undefined\x22 \x26\x26 col instanceof Map || typeof Set !\x3d\x3d \x22undefined\x22 \x26\x26 col instanceof Set) {\n    return Array.from(col.values());\n  }\n  if (typeof col \x3d\x3d\x3d \x22string\x22) {\n    return col.split(\x22\x22);\n  }\n  if (goog.isArrayLike(col)) {\n    var rv \x3d [];\n    var l \x3d col.length;\n    var i \x3d 0;\n    for (; i \x3c l; i++) {\n      rv.push(col[i]);\n    }\n    return rv;\n  }\n  return goog.object.getValues(col);\n};\ngoog.structs.getKeys \x3d function(col) {\n  if (col.getKeys \x26\x26 typeof col.getKeys \x3d\x3d \x22function\x22) {\n    return col.getKeys();\n  }\n  if (col.getValues \x26\x26 typeof col.getValues \x3d\x3d \x22function\x22) {\n    return undefined;\n  }\n  if (typeof Map !\x3d\x3d \x22undefined\x22 \x26\x26 col instanceof Map) {\n    return Array.from(col.keys());\n  }\n  if (typeof Set !\x3d\x3d \x22undefined\x22 \x26\x26 col instanceof Set) {\n    return undefined;\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    var rv \x3d [];\n    var l \x3d col.length;\n    var i \x3d 0;\n    for (; i \x3c l; i++) {\n      rv.push(i);\n    }\n    return rv;\n  }\n  return goog.object.getKeys(col);\n};\ngoog.structs.contains \x3d function(col, val) {\n  if (col.contains \x26\x26 typeof col.contains \x3d\x3d \x22function\x22) {\n    return col.contains(val);\n  }\n  if (col.containsValue \x26\x26 typeof col.containsValue \x3d\x3d \x22function\x22) {\n    return col.containsValue(val);\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    return goog.array.contains(col, val);\n  }\n  return goog.object.containsValue(col, val);\n};\ngoog.structs.isEmpty \x3d function(col) {\n  if (col.isEmpty \x26\x26 typeof col.isEmpty \x3d\x3d \x22function\x22) {\n    return col.isEmpty();\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    return col.length \x3d\x3d\x3d 0;\n  }\n  return goog.object.isEmpty(col);\n};\ngoog.structs.clear \x3d function(col) {\n  if (col.clear \x26\x26 typeof col.clear \x3d\x3d \x22function\x22) {\n    col.clear();\n  } else if (goog.isArrayLike(col)) {\n    goog.array.clear(col);\n  } else {\n    goog.object.clear(col);\n  }\n};\ngoog.structs.forEach \x3d function(col, f, opt_obj) {\n  if (col.forEach \x26\x26 typeof col.forEach \x3d\x3d \x22function\x22) {\n    col.forEach(f, opt_obj);\n  } else if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    Array.prototype.forEach.call(col, f, opt_obj);\n  } else {\n    var keys \x3d goog.structs.getKeys(col);\n    var values \x3d goog.structs.getValues(col);\n    var l \x3d values.length;\n    var i \x3d 0;\n    for (; i \x3c l; i++) {\n      f.call(opt_obj, values[i], keys \x26\x26 keys[i], col);\n    }\n  }\n};\ngoog.structs.filter \x3d function(col, f, opt_obj) {\n  if (typeof col.filter \x3d\x3d \x22function\x22) {\n    return col.filter(f, opt_obj);\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    return Array.prototype.filter.call(col, f, opt_obj);\n  }\n  var rv;\n  var keys \x3d goog.structs.getKeys(col);\n  var values \x3d goog.structs.getValues(col);\n  var l \x3d values.length;\n  if (keys) {\n    rv \x3d {};\n    var i \x3d 0;\n    for (; i \x3c l; i++) {\n      if (f.call(opt_obj, values[i], keys[i], col)) {\n        rv[keys[i]] \x3d values[i];\n      }\n    }\n  } else {\n    rv \x3d [];\n    i \x3d 0;\n    for (; i \x3c l; i++) {\n      if (f.call(opt_obj, values[i], undefined, col)) {\n        rv.push(values[i]);\n      }\n    }\n  }\n  return rv;\n};\ngoog.structs.map \x3d function(col, f, opt_obj) {\n  if (typeof col.map \x3d\x3d \x22function\x22) {\n    return col.map(f, opt_obj);\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    return Array.prototype.map.call(col, f, opt_obj);\n  }\n  var rv;\n  var keys \x3d goog.structs.getKeys(col);\n  var values \x3d goog.structs.getValues(col);\n  var l \x3d values.length;\n  if (keys) {\n    rv \x3d {};\n    var i \x3d 0;\n    for (; i \x3c l; i++) {\n      rv[keys[i]] \x3d f.call(opt_obj, values[i], keys[i], col);\n    }\n  } else {\n    rv \x3d [];\n    i \x3d 0;\n    for (; i \x3c l; i++) {\n      rv[i] \x3d f.call(opt_obj, values[i], undefined, col);\n    }\n  }\n  return rv;\n};\ngoog.structs.some \x3d function(col, f, opt_obj) {\n  if (typeof col.some \x3d\x3d \x22function\x22) {\n    return col.some(f, opt_obj);\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    return Array.prototype.some.call(col, f, opt_obj);\n  }\n  var keys \x3d goog.structs.getKeys(col);\n  var values \x3d goog.structs.getValues(col);\n  var l \x3d values.length;\n  var i \x3d 0;\n  for (; i \x3c l; i++) {\n    if (f.call(opt_obj, values[i], keys \x26\x26 keys[i], col)) {\n      return true;\n    }\n  }\n  return false;\n};\ngoog.structs.every \x3d function(col, f, opt_obj) {\n  if (typeof col.every \x3d\x3d \x22function\x22) {\n    return col.every(f, opt_obj);\n  }\n  if (goog.isArrayLike(col) || typeof col \x3d\x3d\x3d \x22string\x22) {\n    return Array.prototype.every.call(col, f, opt_obj);\n  }\n  var keys \x3d goog.structs.getKeys(col);\n  var values \x3d goog.structs.getValues(col);\n  var l \x3d values.length;\n  var i \x3d 0;\n  for (; i \x3c l; i++) {\n    if (!f.call(opt_obj, values[i], keys \x26\x26 keys[i], col)) {\n      return false;\n    }\n  }\n  return true;\n};\n");
SHADOW_ENV.evalLoad("goog.uri.utils.js", true, "goog.provide(\x22goog.uri.utils\x22);\ngoog.provide(\x22goog.uri.utils.ComponentIndex\x22);\ngoog.provide(\x22goog.uri.utils.QueryArray\x22);\ngoog.provide(\x22goog.uri.utils.QueryValue\x22);\ngoog.provide(\x22goog.uri.utils.StandardQueryParam\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.string\x22);\ngoog.uri.utils.CharCode_ \x3d {AMPERSAND:38, EQUAL:61, HASH:35, QUESTION:63};\ngoog.uri.utils.buildFromEncodedParts \x3d function(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {\n  var out \x3d \x22\x22;\n  if (opt_scheme) {\n    out \x3d out + (opt_scheme + \x22:\x22);\n  }\n  if (opt_domain) {\n    out \x3d out + \x22//\x22;\n    if (opt_userInfo) {\n      out \x3d out + (opt_userInfo + \x22@\x22);\n    }\n    out \x3d out + opt_domain;\n    if (opt_port) {\n      out \x3d out + (\x22:\x22 + opt_port);\n    }\n  }\n  if (opt_path) {\n    out \x3d out + opt_path;\n  }\n  if (opt_queryData) {\n    out \x3d out + (\x22?\x22 + opt_queryData);\n  }\n  if (opt_fragment) {\n    out \x3d out + (\x22#\x22 + opt_fragment);\n  }\n  return out;\n};\ngoog.uri.utils.splitRe_ \x3d new RegExp(\x22^\x22 + \x22(?:\x22 + \x22([^:/?#.]+)\x22 + \x22:)?\x22 + \x22(?://\x22 + \x22(?:([^\\\\\\\\/?#]*)@)?\x22 + \x22([^\\\\\\\\/?#]*?)\x22 + \x22(?::([0-9]+))?\x22 + \x22(?\\x3d[\\\\\\\\/?#]|$)\x22 + \x22)?\x22 + \x22([^?#]+)?\x22 + \x22(?:\\\\?([^#]*))?\x22 + \x22(?:#([\\\\s\\\\S]*))?\x22 + \x22$\x22);\ngoog.uri.utils.ComponentIndex \x3d {SCHEME:1, USER_INFO:2, DOMAIN:3, PORT:4, PATH:5, QUERY_DATA:6, FRAGMENT:7};\ngoog.uri.utils.urlPackageSupportLoggingHandler_ \x3d null;\ngoog.uri.utils.setUrlPackageSupportLoggingHandler \x3d function(handler) {\n  goog.uri.utils.urlPackageSupportLoggingHandler_ \x3d handler;\n};\ngoog.uri.utils.split \x3d function(uri) {\n  var result \x3d uri.match(goog.uri.utils.splitRe_);\n  if (goog.uri.utils.urlPackageSupportLoggingHandler_ \x26\x26 [\x22http\x22, \x22https\x22, \x22ws\x22, \x22wss\x22, \x22ftp\x22].indexOf(result[goog.uri.utils.ComponentIndex.SCHEME]) \x3e\x3d 0) {\n    goog.uri.utils.urlPackageSupportLoggingHandler_(uri);\n  }\n  return result;\n};\ngoog.uri.utils.decodeIfPossible_ \x3d function(uri, opt_preserveReserved) {\n  if (!uri) {\n    return uri;\n  }\n  return opt_preserveReserved ? decodeURI(uri) : decodeURIComponent(uri);\n};\ngoog.uri.utils.getComponentByIndex_ \x3d function(componentIndex, uri) {\n  return goog.uri.utils.split(uri)[componentIndex] || null;\n};\ngoog.uri.utils.getScheme \x3d function(uri) {\n  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.SCHEME, uri);\n};\ngoog.uri.utils.getEffectiveScheme \x3d function(uri) {\n  var scheme \x3d goog.uri.utils.getScheme(uri);\n  if (!scheme \x26\x26 goog.global.self \x26\x26 goog.global.self.location) {\n    var protocol \x3d goog.global.self.location.protocol;\n    scheme \x3d protocol.slice(0, -1);\n  }\n  return scheme ? scheme.toLowerCase() : \x22\x22;\n};\ngoog.uri.utils.getUserInfoEncoded \x3d function(uri) {\n  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.USER_INFO, uri);\n};\ngoog.uri.utils.getUserInfo \x3d function(uri) {\n  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getUserInfoEncoded(uri));\n};\ngoog.uri.utils.getDomainEncoded \x3d function(uri) {\n  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.DOMAIN, uri);\n};\ngoog.uri.utils.getDomain \x3d function(uri) {\n  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getDomainEncoded(uri), true);\n};\ngoog.uri.utils.getPort \x3d function(uri) {\n  return Number(goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PORT, uri)) || null;\n};\ngoog.uri.utils.getPathEncoded \x3d function(uri) {\n  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PATH, uri);\n};\ngoog.uri.utils.getPath \x3d function(uri) {\n  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getPathEncoded(uri), true);\n};\ngoog.uri.utils.getQueryData \x3d function(uri) {\n  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.QUERY_DATA, uri);\n};\ngoog.uri.utils.getFragmentEncoded \x3d function(uri) {\n  var hashIndex \x3d uri.indexOf(\x22#\x22);\n  return hashIndex \x3c 0 ? null : uri.slice(hashIndex + 1);\n};\ngoog.uri.utils.setFragmentEncoded \x3d function(uri, fragment) {\n  return goog.uri.utils.removeFragment(uri) + (fragment ? \x22#\x22 + fragment : \x22\x22);\n};\ngoog.uri.utils.getFragment \x3d function(uri) {\n  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getFragmentEncoded(uri));\n};\ngoog.uri.utils.getHost \x3d function(uri) {\n  var pieces \x3d goog.uri.utils.split(uri);\n  return goog.uri.utils.buildFromEncodedParts(pieces[goog.uri.utils.ComponentIndex.SCHEME], pieces[goog.uri.utils.ComponentIndex.USER_INFO], pieces[goog.uri.utils.ComponentIndex.DOMAIN], pieces[goog.uri.utils.ComponentIndex.PORT]);\n};\ngoog.uri.utils.getOrigin \x3d function(uri) {\n  var pieces \x3d goog.uri.utils.split(uri);\n  return goog.uri.utils.buildFromEncodedParts(pieces[goog.uri.utils.ComponentIndex.SCHEME], null, pieces[goog.uri.utils.ComponentIndex.DOMAIN], pieces[goog.uri.utils.ComponentIndex.PORT]);\n};\ngoog.uri.utils.getPathAndAfter \x3d function(uri) {\n  var pieces \x3d goog.uri.utils.split(uri);\n  return goog.uri.utils.buildFromEncodedParts(null, null, null, null, pieces[goog.uri.utils.ComponentIndex.PATH], pieces[goog.uri.utils.ComponentIndex.QUERY_DATA], pieces[goog.uri.utils.ComponentIndex.FRAGMENT]);\n};\ngoog.uri.utils.removeFragment \x3d function(uri) {\n  var hashIndex \x3d uri.indexOf(\x22#\x22);\n  return hashIndex \x3c 0 ? uri : uri.slice(0, hashIndex);\n};\ngoog.uri.utils.haveSameDomain \x3d function(uri1, uri2) {\n  var pieces1 \x3d goog.uri.utils.split(uri1);\n  var pieces2 \x3d goog.uri.utils.split(uri2);\n  return pieces1[goog.uri.utils.ComponentIndex.DOMAIN] \x3d\x3d pieces2[goog.uri.utils.ComponentIndex.DOMAIN] \x26\x26 pieces1[goog.uri.utils.ComponentIndex.SCHEME] \x3d\x3d pieces2[goog.uri.utils.ComponentIndex.SCHEME] \x26\x26 pieces1[goog.uri.utils.ComponentIndex.PORT] \x3d\x3d pieces2[goog.uri.utils.ComponentIndex.PORT];\n};\ngoog.uri.utils.assertNoFragmentsOrQueries_ \x3d function(uri) {\n  goog.asserts.assert(uri.indexOf(\x22#\x22) \x3c 0 \x26\x26 uri.indexOf(\x22?\x22) \x3c 0, \x22goog.uri.utils: Fragment or query identifiers are not supported: [%s]\x22, uri);\n};\ngoog.uri.utils.QueryValue;\ngoog.uri.utils.QueryArray;\ngoog.uri.utils.parseQueryData \x3d function(encodedQuery, callback) {\n  if (!encodedQuery) {\n    return;\n  }\n  var pairs \x3d encodedQuery.split(\x22\\x26\x22);\n  var i \x3d 0;\n  for (; i \x3c pairs.length; i++) {\n    var indexOfEquals \x3d pairs[i].indexOf(\x22\\x3d\x22);\n    var name \x3d null;\n    var value \x3d null;\n    if (indexOfEquals \x3e\x3d 0) {\n      name \x3d pairs[i].substring(0, indexOfEquals);\n      value \x3d pairs[i].substring(indexOfEquals + 1);\n    } else {\n      name \x3d pairs[i];\n    }\n    callback(name, value ? goog.string.urlDecode(value) : \x22\x22);\n  }\n};\ngoog.uri.utils.splitQueryData_ \x3d function(uri) {\n  var hashIndex \x3d uri.indexOf(\x22#\x22);\n  if (hashIndex \x3c 0) {\n    hashIndex \x3d uri.length;\n  }\n  var questionIndex \x3d uri.indexOf(\x22?\x22);\n  var queryData;\n  if (questionIndex \x3c 0 || questionIndex \x3e hashIndex) {\n    questionIndex \x3d hashIndex;\n    queryData \x3d \x22\x22;\n  } else {\n    queryData \x3d uri.substring(questionIndex + 1, hashIndex);\n  }\n  return [uri.slice(0, questionIndex), queryData, uri.slice(hashIndex)];\n};\ngoog.uri.utils.joinQueryData_ \x3d function(parts) {\n  return parts[0] + (parts[1] ? \x22?\x22 + parts[1] : \x22\x22) + parts[2];\n};\ngoog.uri.utils.appendQueryData_ \x3d function(queryData, newData) {\n  if (!newData) {\n    return queryData;\n  }\n  return queryData ? queryData + \x22\\x26\x22 + newData : newData;\n};\ngoog.uri.utils.appendQueryDataToUri_ \x3d function(uri, queryData) {\n  if (!queryData) {\n    return uri;\n  }\n  var parts \x3d goog.uri.utils.splitQueryData_(uri);\n  parts[1] \x3d goog.uri.utils.appendQueryData_(parts[1], queryData);\n  return goog.uri.utils.joinQueryData_(parts);\n};\ngoog.uri.utils.appendKeyValuePairs_ \x3d function(key, value, pairs) {\n  goog.asserts.assertString(key);\n  if (Array.isArray(value)) {\n    goog.asserts.assertArray(value);\n    var j \x3d 0;\n    for (; j \x3c value.length; j++) {\n      goog.uri.utils.appendKeyValuePairs_(key, String(value[j]), pairs);\n    }\n  } else if (value !\x3d null) {\n    pairs.push(key + (value \x3d\x3d\x3d \x22\x22 ? \x22\x22 : \x22\\x3d\x22 + goog.string.urlEncode(value)));\n  }\n};\ngoog.uri.utils.buildQueryData \x3d function(keysAndValues, opt_startIndex) {\n  goog.asserts.assert(Math.max(keysAndValues.length - (opt_startIndex || 0), 0) % 2 \x3d\x3d 0, \x22goog.uri.utils: Key/value lists must be even in length.\x22);\n  var params \x3d [];\n  var i \x3d opt_startIndex || 0;\n  for (; i \x3c keysAndValues.length; i \x3d i + 2) {\n    var key \x3d keysAndValues[i];\n    goog.uri.utils.appendKeyValuePairs_(key, keysAndValues[i + 1], params);\n  }\n  return params.join(\x22\\x26\x22);\n};\ngoog.uri.utils.buildQueryDataFromMap \x3d function(map) {\n  var params \x3d [];\n  var key;\n  for (key in map) {\n    goog.uri.utils.appendKeyValuePairs_(key, map[key], params);\n  }\n  return params.join(\x22\\x26\x22);\n};\ngoog.uri.utils.appendParams \x3d function(uri, var_args) {\n  var queryData \x3d arguments.length \x3d\x3d 2 ? goog.uri.utils.buildQueryData(arguments[1], 0) : goog.uri.utils.buildQueryData(arguments, 1);\n  return goog.uri.utils.appendQueryDataToUri_(uri, queryData);\n};\ngoog.uri.utils.appendParamsFromMap \x3d function(uri, map) {\n  var queryData \x3d goog.uri.utils.buildQueryDataFromMap(map);\n  return goog.uri.utils.appendQueryDataToUri_(uri, queryData);\n};\ngoog.uri.utils.appendParam \x3d function(uri, key, opt_value) {\n  var value \x3d opt_value !\x3d null ? \x22\\x3d\x22 + goog.string.urlEncode(opt_value) : \x22\x22;\n  return goog.uri.utils.appendQueryDataToUri_(uri, key + value);\n};\ngoog.uri.utils.findParam_ \x3d function(uri, startIndex, keyEncoded, hashOrEndIndex) {\n  var index \x3d startIndex;\n  var keyLength \x3d keyEncoded.length;\n  for (; (index \x3d uri.indexOf(keyEncoded, index)) \x3e\x3d 0 \x26\x26 index \x3c hashOrEndIndex;) {\n    var precedingChar \x3d uri.charCodeAt(index - 1);\n    if (precedingChar \x3d\x3d goog.uri.utils.CharCode_.AMPERSAND || precedingChar \x3d\x3d goog.uri.utils.CharCode_.QUESTION) {\n      var followingChar \x3d uri.charCodeAt(index + keyLength);\n      if (!followingChar || followingChar \x3d\x3d goog.uri.utils.CharCode_.EQUAL || followingChar \x3d\x3d goog.uri.utils.CharCode_.AMPERSAND || followingChar \x3d\x3d goog.uri.utils.CharCode_.HASH) {\n        return index;\n      }\n    }\n    index \x3d index + (keyLength + 1);\n  }\n  return -1;\n};\ngoog.uri.utils.hashOrEndRe_ \x3d /#|$/;\ngoog.uri.utils.hasParam \x3d function(uri, keyEncoded) {\n  return goog.uri.utils.findParam_(uri, 0, keyEncoded, uri.search(goog.uri.utils.hashOrEndRe_)) \x3e\x3d 0;\n};\ngoog.uri.utils.getParamValue \x3d function(uri, keyEncoded) {\n  var hashOrEndIndex \x3d uri.search(goog.uri.utils.hashOrEndRe_);\n  var foundIndex \x3d goog.uri.utils.findParam_(uri, 0, keyEncoded, hashOrEndIndex);\n  if (foundIndex \x3c 0) {\n    return null;\n  } else {\n    var endPosition \x3d uri.indexOf(\x22\\x26\x22, foundIndex);\n    if (endPosition \x3c 0 || endPosition \x3e hashOrEndIndex) {\n      endPosition \x3d hashOrEndIndex;\n    }\n    foundIndex \x3d foundIndex + (keyEncoded.length + 1);\n    return goog.string.urlDecode(uri.slice(foundIndex, endPosition !\x3d\x3d -1 ? endPosition : 0));\n  }\n};\ngoog.uri.utils.getParamValues \x3d function(uri, keyEncoded) {\n  var hashOrEndIndex \x3d uri.search(goog.uri.utils.hashOrEndRe_);\n  var position \x3d 0;\n  var foundIndex;\n  var result \x3d [];\n  for (; (foundIndex \x3d goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex)) \x3e\x3d 0;) {\n    position \x3d uri.indexOf(\x22\\x26\x22, foundIndex);\n    if (position \x3c 0 || position \x3e hashOrEndIndex) {\n      position \x3d hashOrEndIndex;\n    }\n    foundIndex \x3d foundIndex + (keyEncoded.length + 1);\n    result.push(goog.string.urlDecode(uri.slice(foundIndex, Math.max(position, 0))));\n  }\n  return result;\n};\ngoog.uri.utils.trailingQueryPunctuationRe_ \x3d /[?\x26]($|#)/;\ngoog.uri.utils.removeParam \x3d function(uri, keyEncoded) {\n  var hashOrEndIndex \x3d uri.search(goog.uri.utils.hashOrEndRe_);\n  var position \x3d 0;\n  var foundIndex;\n  var buffer \x3d [];\n  for (; (foundIndex \x3d goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex)) \x3e\x3d 0;) {\n    buffer.push(uri.substring(position, foundIndex));\n    position \x3d Math.min(uri.indexOf(\x22\\x26\x22, foundIndex) + 1 || hashOrEndIndex, hashOrEndIndex);\n  }\n  buffer.push(uri.slice(position));\n  return buffer.join(\x22\x22).replace(goog.uri.utils.trailingQueryPunctuationRe_, \x22$1\x22);\n};\ngoog.uri.utils.setParam \x3d function(uri, keyEncoded, value) {\n  return goog.uri.utils.appendParam(goog.uri.utils.removeParam(uri, keyEncoded), keyEncoded, value);\n};\ngoog.uri.utils.setParamsFromMap \x3d function(uri, params) {\n  var parts \x3d goog.uri.utils.splitQueryData_(uri);\n  var queryData \x3d parts[1];\n  var buffer \x3d [];\n  if (queryData) {\n    queryData.split(\x22\\x26\x22).forEach(function(pair) {\n      var indexOfEquals \x3d pair.indexOf(\x22\\x3d\x22);\n      var name \x3d indexOfEquals \x3e\x3d 0 ? pair.slice(0, indexOfEquals) : pair;\n      if (!params.hasOwnProperty(name)) {\n        buffer.push(pair);\n      }\n    });\n  }\n  parts[1] \x3d goog.uri.utils.appendQueryData_(buffer.join(\x22\\x26\x22), goog.uri.utils.buildQueryDataFromMap(params));\n  return goog.uri.utils.joinQueryData_(parts);\n};\ngoog.uri.utils.appendPath \x3d function(baseUri, path) {\n  goog.uri.utils.assertNoFragmentsOrQueries_(baseUri);\n  if (goog.string.endsWith(baseUri, \x22/\x22)) {\n    baseUri \x3d baseUri.slice(0, -1);\n  }\n  if (goog.string.startsWith(path, \x22/\x22)) {\n    path \x3d path.slice(1);\n  }\n  return \x22\x22 + baseUri + \x22/\x22 + path;\n};\ngoog.uri.utils.setPath \x3d function(uri, path) {\n  if (!goog.string.startsWith(path, \x22/\x22)) {\n    path \x3d \x22/\x22 + path;\n  }\n  var parts \x3d goog.uri.utils.split(uri);\n  return goog.uri.utils.buildFromEncodedParts(parts[goog.uri.utils.ComponentIndex.SCHEME], parts[goog.uri.utils.ComponentIndex.USER_INFO], parts[goog.uri.utils.ComponentIndex.DOMAIN], parts[goog.uri.utils.ComponentIndex.PORT], path, parts[goog.uri.utils.ComponentIndex.QUERY_DATA], parts[goog.uri.utils.ComponentIndex.FRAGMENT]);\n};\ngoog.uri.utils.StandardQueryParam \x3d {RANDOM:\x22zx\x22};\ngoog.uri.utils.makeUnique \x3d function(uri) {\n  return goog.uri.utils.setParam(uri, goog.uri.utils.StandardQueryParam.RANDOM, goog.string.getRandomString());\n};\n");
SHADOW_ENV.evalLoad("goog.uri.uri.js", true, "goog.provide(\x22goog.Uri\x22);\ngoog.provide(\x22goog.Uri.QueryData\x22);\ngoog.require(\x22goog.array\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.collections.maps\x22);\ngoog.require(\x22goog.string\x22);\ngoog.require(\x22goog.structs\x22);\ngoog.require(\x22goog.uri.utils\x22);\ngoog.require(\x22goog.uri.utils.ComponentIndex\x22);\ngoog.require(\x22goog.uri.utils.StandardQueryParam\x22);\ngoog.Uri \x3d function(opt_uri, opt_ignoreCase) {\n  this.scheme_ \x3d \x22\x22;\n  this.userInfo_ \x3d \x22\x22;\n  this.domain_ \x3d \x22\x22;\n  this.port_ \x3d null;\n  this.path_ \x3d \x22\x22;\n  this.fragment_ \x3d \x22\x22;\n  this.isReadOnly_ \x3d false;\n  this.ignoreCase_ \x3d false;\n  this.queryData_;\n  var m;\n  if (opt_uri instanceof goog.Uri) {\n    this.ignoreCase_ \x3d opt_ignoreCase !\x3d\x3d undefined ? opt_ignoreCase : opt_uri.getIgnoreCase();\n    this.setScheme(opt_uri.getScheme());\n    this.setUserInfo(opt_uri.getUserInfo());\n    this.setDomain(opt_uri.getDomain());\n    this.setPort(opt_uri.getPort());\n    this.setPath(opt_uri.getPath());\n    this.setQueryData(opt_uri.getQueryData().clone());\n    this.setFragment(opt_uri.getFragment());\n  } else if (opt_uri \x26\x26 (m \x3d goog.uri.utils.split(String(opt_uri)))) {\n    this.ignoreCase_ \x3d !!opt_ignoreCase;\n    this.setScheme(m[goog.uri.utils.ComponentIndex.SCHEME] || \x22\x22, true);\n    this.setUserInfo(m[goog.uri.utils.ComponentIndex.USER_INFO] || \x22\x22, true);\n    this.setDomain(m[goog.uri.utils.ComponentIndex.DOMAIN] || \x22\x22, true);\n    this.setPort(m[goog.uri.utils.ComponentIndex.PORT]);\n    this.setPath(m[goog.uri.utils.ComponentIndex.PATH] || \x22\x22, true);\n    this.setQueryData(m[goog.uri.utils.ComponentIndex.QUERY_DATA] || \x22\x22, true);\n    this.setFragment(m[goog.uri.utils.ComponentIndex.FRAGMENT] || \x22\x22, true);\n  } else {\n    this.ignoreCase_ \x3d !!opt_ignoreCase;\n    this.queryData_ \x3d new goog.Uri.QueryData(null, this.ignoreCase_);\n  }\n};\ngoog.Uri.RANDOM_PARAM \x3d goog.uri.utils.StandardQueryParam.RANDOM;\ngoog.Uri.prototype.toString \x3d function() {\n  var out \x3d [];\n  var scheme \x3d this.getScheme();\n  if (scheme) {\n    out.push(goog.Uri.encodeSpecialChars_(scheme, goog.Uri.reDisallowedInSchemeOrUserInfo_, true), \x22:\x22);\n  }\n  var domain \x3d this.getDomain();\n  if (domain || scheme \x3d\x3d \x22file\x22) {\n    out.push(\x22//\x22);\n    var userInfo \x3d this.getUserInfo();\n    if (userInfo) {\n      out.push(goog.Uri.encodeSpecialChars_(userInfo, goog.Uri.reDisallowedInSchemeOrUserInfo_, true), \x22@\x22);\n    }\n    out.push(goog.Uri.removeDoubleEncoding_(goog.string.urlEncode(domain)));\n    var port \x3d this.getPort();\n    if (port !\x3d null) {\n      out.push(\x22:\x22, String(port));\n    }\n  }\n  var path \x3d this.getPath();\n  if (path) {\n    if (this.hasDomain() \x26\x26 path.charAt(0) !\x3d \x22/\x22) {\n      out.push(\x22/\x22);\n    }\n    out.push(goog.Uri.encodeSpecialChars_(path, path.charAt(0) \x3d\x3d \x22/\x22 ? goog.Uri.reDisallowedInAbsolutePath_ : goog.Uri.reDisallowedInRelativePath_, true));\n  }\n  var query \x3d this.getEncodedQuery();\n  if (query) {\n    out.push(\x22?\x22, query);\n  }\n  var fragment \x3d this.getFragment();\n  if (fragment) {\n    out.push(\x22#\x22, goog.Uri.encodeSpecialChars_(fragment, goog.Uri.reDisallowedInFragment_));\n  }\n  return out.join(\x22\x22);\n};\ngoog.Uri.prototype.resolve \x3d function(relativeUri) {\n  var absoluteUri \x3d this.clone();\n  var overridden \x3d relativeUri.hasScheme();\n  if (overridden) {\n    absoluteUri.setScheme(relativeUri.getScheme());\n  } else {\n    overridden \x3d relativeUri.hasUserInfo();\n  }\n  if (overridden) {\n    absoluteUri.setUserInfo(relativeUri.getUserInfo());\n  } else {\n    overridden \x3d relativeUri.hasDomain();\n  }\n  if (overridden) {\n    absoluteUri.setDomain(relativeUri.getDomain());\n  } else {\n    overridden \x3d relativeUri.hasPort();\n  }\n  var path \x3d relativeUri.getPath();\n  if (overridden) {\n    absoluteUri.setPort(relativeUri.getPort());\n  } else {\n    overridden \x3d relativeUri.hasPath();\n    if (overridden) {\n      if (path.charAt(0) !\x3d \x22/\x22) {\n        if (this.hasDomain() \x26\x26 !this.hasPath()) {\n          path \x3d \x22/\x22 + path;\n        } else {\n          var lastSlashIndex \x3d absoluteUri.getPath().lastIndexOf(\x22/\x22);\n          if (lastSlashIndex !\x3d -1) {\n            path \x3d absoluteUri.getPath().slice(0, lastSlashIndex + 1) + path;\n          }\n        }\n      }\n      path \x3d goog.Uri.removeDotSegments(path);\n    }\n  }\n  if (overridden) {\n    absoluteUri.setPath(path);\n  } else {\n    overridden \x3d relativeUri.hasQuery();\n  }\n  if (overridden) {\n    absoluteUri.setQueryData(relativeUri.getQueryData().clone());\n  } else {\n    overridden \x3d relativeUri.hasFragment();\n  }\n  if (overridden) {\n    absoluteUri.setFragment(relativeUri.getFragment());\n  }\n  return absoluteUri;\n};\ngoog.Uri.prototype.clone \x3d function() {\n  return new goog.Uri(this);\n};\ngoog.Uri.prototype.getScheme \x3d function() {\n  return this.scheme_;\n};\ngoog.Uri.prototype.setScheme \x3d function(newScheme, opt_decode) {\n  this.enforceReadOnly();\n  this.scheme_ \x3d opt_decode ? goog.Uri.decodeOrEmpty_(newScheme, true) : newScheme;\n  if (this.scheme_) {\n    this.scheme_ \x3d this.scheme_.replace(/:$/, \x22\x22);\n  }\n  return this;\n};\ngoog.Uri.prototype.hasScheme \x3d function() {\n  return !!this.scheme_;\n};\ngoog.Uri.prototype.getUserInfo \x3d function() {\n  return this.userInfo_;\n};\ngoog.Uri.prototype.setUserInfo \x3d function(newUserInfo, opt_decode) {\n  this.enforceReadOnly();\n  this.userInfo_ \x3d opt_decode ? goog.Uri.decodeOrEmpty_(newUserInfo) : newUserInfo;\n  return this;\n};\ngoog.Uri.prototype.hasUserInfo \x3d function() {\n  return !!this.userInfo_;\n};\ngoog.Uri.prototype.getDomain \x3d function() {\n  return this.domain_;\n};\ngoog.Uri.prototype.setDomain \x3d function(newDomain, opt_decode) {\n  this.enforceReadOnly();\n  this.domain_ \x3d opt_decode ? goog.Uri.decodeOrEmpty_(newDomain, true) : newDomain;\n  return this;\n};\ngoog.Uri.prototype.hasDomain \x3d function() {\n  return !!this.domain_;\n};\ngoog.Uri.prototype.getPort \x3d function() {\n  return this.port_;\n};\ngoog.Uri.prototype.setPort \x3d function(newPort) {\n  this.enforceReadOnly();\n  if (newPort) {\n    newPort \x3d Number(newPort);\n    if (isNaN(newPort) || newPort \x3c 0) {\n      throw new Error(\x22Bad port number \x22 + newPort);\n    }\n    this.port_ \x3d newPort;\n  } else {\n    this.port_ \x3d null;\n  }\n  return this;\n};\ngoog.Uri.prototype.hasPort \x3d function() {\n  return this.port_ !\x3d null;\n};\ngoog.Uri.prototype.getPath \x3d function() {\n  return this.path_;\n};\ngoog.Uri.prototype.setPath \x3d function(newPath, opt_decode) {\n  this.enforceReadOnly();\n  this.path_ \x3d opt_decode ? goog.Uri.decodeOrEmpty_(newPath, true) : newPath;\n  return this;\n};\ngoog.Uri.prototype.hasPath \x3d function() {\n  return !!this.path_;\n};\ngoog.Uri.prototype.hasQuery \x3d function() {\n  return this.queryData_.toString() !\x3d\x3d \x22\x22;\n};\ngoog.Uri.prototype.setQueryData \x3d function(queryData, opt_decode) {\n  this.enforceReadOnly();\n  if (queryData instanceof goog.Uri.QueryData) {\n    this.queryData_ \x3d queryData;\n    this.queryData_.setIgnoreCase(this.ignoreCase_);\n  } else {\n    if (!opt_decode) {\n      queryData \x3d goog.Uri.encodeSpecialChars_(queryData, goog.Uri.reDisallowedInQuery_);\n    }\n    this.queryData_ \x3d new goog.Uri.QueryData(queryData, this.ignoreCase_);\n  }\n  return this;\n};\ngoog.Uri.prototype.setQuery \x3d function(newQuery, opt_decode) {\n  return this.setQueryData(newQuery, opt_decode);\n};\ngoog.Uri.prototype.getEncodedQuery \x3d function() {\n  return this.queryData_.toString();\n};\ngoog.Uri.prototype.getDecodedQuery \x3d function() {\n  return this.queryData_.toDecodedString();\n};\ngoog.Uri.prototype.getQueryData \x3d function() {\n  return this.queryData_;\n};\ngoog.Uri.prototype.getQuery \x3d function() {\n  return this.getEncodedQuery();\n};\ngoog.Uri.prototype.setParameterValue \x3d function(key, value) {\n  this.enforceReadOnly();\n  this.queryData_.set(key, value);\n  return this;\n};\ngoog.Uri.prototype.setParameterValues \x3d function(key, values) {\n  this.enforceReadOnly();\n  if (!Array.isArray(values)) {\n    values \x3d [String(values)];\n  }\n  this.queryData_.setValues(key, values);\n  return this;\n};\ngoog.Uri.prototype.getParameterValues \x3d function(name) {\n  return this.queryData_.getValues(name);\n};\ngoog.Uri.prototype.getParameterValue \x3d function(paramName) {\n  return this.queryData_.get(paramName);\n};\ngoog.Uri.prototype.getFragment \x3d function() {\n  return this.fragment_;\n};\ngoog.Uri.prototype.setFragment \x3d function(newFragment, opt_decode) {\n  this.enforceReadOnly();\n  this.fragment_ \x3d opt_decode ? goog.Uri.decodeOrEmpty_(newFragment) : newFragment;\n  return this;\n};\ngoog.Uri.prototype.hasFragment \x3d function() {\n  return !!this.fragment_;\n};\ngoog.Uri.prototype.hasSameDomainAs \x3d function(uri2) {\n  return (!this.hasDomain() \x26\x26 !uri2.hasDomain() || this.getDomain() \x3d\x3d uri2.getDomain()) \x26\x26 (!this.hasPort() \x26\x26 !uri2.hasPort() || this.getPort() \x3d\x3d uri2.getPort());\n};\ngoog.Uri.prototype.makeUnique \x3d function() {\n  this.enforceReadOnly();\n  this.setParameterValue(goog.Uri.RANDOM_PARAM, goog.string.getRandomString());\n  return this;\n};\ngoog.Uri.prototype.removeParameter \x3d function(key) {\n  this.enforceReadOnly();\n  this.queryData_.remove(key);\n  return this;\n};\ngoog.Uri.prototype.setReadOnly \x3d function(isReadOnly) {\n  this.isReadOnly_ \x3d isReadOnly;\n  return this;\n};\ngoog.Uri.prototype.isReadOnly \x3d function() {\n  return this.isReadOnly_;\n};\ngoog.Uri.prototype.enforceReadOnly \x3d function() {\n  if (this.isReadOnly_) {\n    throw new Error(\x22Tried to modify a read-only Uri\x22);\n  }\n};\ngoog.Uri.prototype.setIgnoreCase \x3d function(ignoreCase) {\n  this.ignoreCase_ \x3d ignoreCase;\n  if (this.queryData_) {\n    this.queryData_.setIgnoreCase(ignoreCase);\n  }\n  return this;\n};\ngoog.Uri.prototype.getIgnoreCase \x3d function() {\n  return this.ignoreCase_;\n};\ngoog.Uri.parse \x3d function(uri, opt_ignoreCase) {\n  return uri instanceof goog.Uri ? uri.clone() : new goog.Uri(uri, opt_ignoreCase);\n};\ngoog.Uri.create \x3d function(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_query, opt_fragment, opt_ignoreCase) {\n  var uri \x3d new goog.Uri(null, opt_ignoreCase);\n  opt_scheme \x26\x26 uri.setScheme(opt_scheme);\n  opt_userInfo \x26\x26 uri.setUserInfo(opt_userInfo);\n  opt_domain \x26\x26 uri.setDomain(opt_domain);\n  opt_port \x26\x26 uri.setPort(opt_port);\n  opt_path \x26\x26 uri.setPath(opt_path);\n  opt_query \x26\x26 uri.setQueryData(opt_query);\n  opt_fragment \x26\x26 uri.setFragment(opt_fragment);\n  return uri;\n};\ngoog.Uri.resolve \x3d function(base, rel) {\n  if (!(base instanceof goog.Uri)) {\n    base \x3d goog.Uri.parse(base);\n  }\n  if (!(rel instanceof goog.Uri)) {\n    rel \x3d goog.Uri.parse(rel);\n  }\n  return base.resolve(rel);\n};\ngoog.Uri.removeDotSegments \x3d function(path) {\n  if (path \x3d\x3d \x22..\x22 || path \x3d\x3d \x22.\x22) {\n    return \x22\x22;\n  } else if (!goog.string.contains(path, \x22./\x22) \x26\x26 !goog.string.contains(path, \x22/.\x22)) {\n    return path;\n  } else {\n    var leadingSlash \x3d goog.string.startsWith(path, \x22/\x22);\n    var segments \x3d path.split(\x22/\x22);\n    var out \x3d [];\n    var pos \x3d 0;\n    for (; pos \x3c segments.length;) {\n      var segment \x3d segments[pos++];\n      if (segment \x3d\x3d \x22.\x22) {\n        if (leadingSlash \x26\x26 pos \x3d\x3d segments.length) {\n          out.push(\x22\x22);\n        }\n      } else if (segment \x3d\x3d \x22..\x22) {\n        if (out.length \x3e 1 || out.length \x3d\x3d 1 \x26\x26 out[0] !\x3d \x22\x22) {\n          out.pop();\n        }\n        if (leadingSlash \x26\x26 pos \x3d\x3d segments.length) {\n          out.push(\x22\x22);\n        }\n      } else {\n        out.push(segment);\n        leadingSlash \x3d true;\n      }\n    }\n    return out.join(\x22/\x22);\n  }\n};\ngoog.Uri.decodeOrEmpty_ \x3d function(val, opt_preserveReserved) {\n  if (!val) {\n    return \x22\x22;\n  }\n  return opt_preserveReserved ? decodeURI(val.replace(/%25/g, \x22%2525\x22)) : decodeURIComponent(val);\n};\ngoog.Uri.encodeSpecialChars_ \x3d function(unescapedPart, extra, opt_removeDoubleEncoding) {\n  if (typeof unescapedPart \x3d\x3d\x3d \x22string\x22) {\n    var encoded \x3d encodeURI(unescapedPart).replace(extra, goog.Uri.encodeChar_);\n    if (opt_removeDoubleEncoding) {\n      encoded \x3d goog.Uri.removeDoubleEncoding_(encoded);\n    }\n    return encoded;\n  }\n  return null;\n};\ngoog.Uri.encodeChar_ \x3d function(ch) {\n  var n \x3d ch.charCodeAt(0);\n  return \x22%\x22 + (n \x3e\x3e 4 \x26 15).toString(16) + (n \x26 15).toString(16);\n};\ngoog.Uri.removeDoubleEncoding_ \x3d function(doubleEncodedString) {\n  return doubleEncodedString.replace(/%25([0-9a-fA-F]{2})/g, \x22%$1\x22);\n};\ngoog.Uri.reDisallowedInSchemeOrUserInfo_ \x3d /[#\\/\\?@]/g;\ngoog.Uri.reDisallowedInRelativePath_ \x3d /[#\\?:]/g;\ngoog.Uri.reDisallowedInAbsolutePath_ \x3d /[#\\?]/g;\ngoog.Uri.reDisallowedInQuery_ \x3d /[#\\?@]/g;\ngoog.Uri.reDisallowedInFragment_ \x3d /#/g;\ngoog.Uri.haveSameDomain \x3d function(uri1String, uri2String) {\n  var pieces1 \x3d goog.uri.utils.split(uri1String);\n  var pieces2 \x3d goog.uri.utils.split(uri2String);\n  return pieces1[goog.uri.utils.ComponentIndex.DOMAIN] \x3d\x3d pieces2[goog.uri.utils.ComponentIndex.DOMAIN] \x26\x26 pieces1[goog.uri.utils.ComponentIndex.PORT] \x3d\x3d pieces2[goog.uri.utils.ComponentIndex.PORT];\n};\ngoog.Uri.QueryData \x3d function(opt_query, opt_ignoreCase) {\n  this.keyMap_ \x3d null;\n  this.count_ \x3d null;\n  this.encodedQuery_ \x3d opt_query || null;\n  this.ignoreCase_ \x3d !!opt_ignoreCase;\n};\ngoog.Uri.QueryData.prototype.ensureKeyMapInitialized_ \x3d function() {\n  if (!this.keyMap_) {\n    this.keyMap_ \x3d new Map();\n    this.count_ \x3d 0;\n    if (this.encodedQuery_) {\n      var self \x3d this;\n      goog.uri.utils.parseQueryData(this.encodedQuery_, function(name, value) {\n        self.add(goog.string.urlDecode(name), value);\n      });\n    }\n  }\n};\ngoog.Uri.QueryData.createFromMap \x3d function(map, opt_ignoreCase) {\n  var keys \x3d goog.structs.getKeys(map);\n  if (typeof keys \x3d\x3d \x22undefined\x22) {\n    throw new Error(\x22Keys are undefined\x22);\n  }\n  var queryData \x3d new goog.Uri.QueryData(null, opt_ignoreCase);\n  var values \x3d goog.structs.getValues(map);\n  var i \x3d 0;\n  for (; i \x3c keys.length; i++) {\n    var key \x3d keys[i];\n    var value \x3d values[i];\n    if (!Array.isArray(value)) {\n      queryData.add(key, value);\n    } else {\n      queryData.setValues(key, value);\n    }\n  }\n  return queryData;\n};\ngoog.Uri.QueryData.createFromKeysValues \x3d function(keys, values, opt_ignoreCase) {\n  if (keys.length !\x3d values.length) {\n    throw new Error(\x22Mismatched lengths for keys/values\x22);\n  }\n  var queryData \x3d new goog.Uri.QueryData(null, opt_ignoreCase);\n  var i \x3d 0;\n  for (; i \x3c keys.length; i++) {\n    queryData.add(keys[i], values[i]);\n  }\n  return queryData;\n};\ngoog.Uri.QueryData.prototype.getCount \x3d function() {\n  this.ensureKeyMapInitialized_();\n  return this.count_;\n};\ngoog.Uri.QueryData.prototype.add \x3d function(key, value) {\n  this.ensureKeyMapInitialized_();\n  this.invalidateCache_();\n  key \x3d this.getKeyName_(key);\n  var values \x3d this.keyMap_.get(key);\n  if (!values) {\n    this.keyMap_.set(key, values \x3d []);\n  }\n  values.push(value);\n  this.count_ \x3d goog.asserts.assertNumber(this.count_) + 1;\n  return this;\n};\ngoog.Uri.QueryData.prototype.remove \x3d function(key) {\n  this.ensureKeyMapInitialized_();\n  key \x3d this.getKeyName_(key);\n  if (this.keyMap_.has(key)) {\n    this.invalidateCache_();\n    this.count_ \x3d goog.asserts.assertNumber(this.count_) - this.keyMap_.get(key).length;\n    return this.keyMap_.delete(key);\n  }\n  return false;\n};\ngoog.Uri.QueryData.prototype.clear \x3d function() {\n  this.invalidateCache_();\n  this.keyMap_ \x3d null;\n  this.count_ \x3d 0;\n};\ngoog.Uri.QueryData.prototype.isEmpty \x3d function() {\n  this.ensureKeyMapInitialized_();\n  return this.count_ \x3d\x3d 0;\n};\ngoog.Uri.QueryData.prototype.containsKey \x3d function(key) {\n  this.ensureKeyMapInitialized_();\n  key \x3d this.getKeyName_(key);\n  return this.keyMap_.has(key);\n};\ngoog.Uri.QueryData.prototype.containsValue \x3d function(value) {\n  var vals \x3d this.getValues();\n  return goog.array.contains(vals, value);\n};\ngoog.Uri.QueryData.prototype.forEach \x3d function(f, opt_scope) {\n  this.ensureKeyMapInitialized_();\n  this.keyMap_.forEach(function(values, key) {\n    values.forEach(function(value) {\n      f.call(opt_scope, value, key, this);\n    }, this);\n  }, this);\n};\ngoog.Uri.QueryData.prototype.getKeys \x3d function() {\n  this.ensureKeyMapInitialized_();\n  const vals \x3d Array.from(this.keyMap_.values());\n  const keys \x3d Array.from(this.keyMap_.keys());\n  const rv \x3d [];\n  for (let i \x3d 0; i \x3c keys.length; i++) {\n    const val \x3d vals[i];\n    for (let j \x3d 0; j \x3c val.length; j++) {\n      rv.push(keys[i]);\n    }\n  }\n  return rv;\n};\ngoog.Uri.QueryData.prototype.getValues \x3d function(opt_key) {\n  this.ensureKeyMapInitialized_();\n  let rv \x3d [];\n  if (typeof opt_key \x3d\x3d\x3d \x22string\x22) {\n    if (this.containsKey(opt_key)) {\n      rv \x3d rv.concat(this.keyMap_.get(this.getKeyName_(opt_key)));\n    }\n  } else {\n    const values \x3d Array.from(this.keyMap_.values());\n    for (let i \x3d 0; i \x3c values.length; i++) {\n      rv \x3d rv.concat(values[i]);\n    }\n  }\n  return rv;\n};\ngoog.Uri.QueryData.prototype.set \x3d function(key, value) {\n  this.ensureKeyMapInitialized_();\n  this.invalidateCache_();\n  key \x3d this.getKeyName_(key);\n  if (this.containsKey(key)) {\n    this.count_ \x3d goog.asserts.assertNumber(this.count_) - this.keyMap_.get(key).length;\n  }\n  this.keyMap_.set(key, [value]);\n  this.count_ \x3d goog.asserts.assertNumber(this.count_) + 1;\n  return this;\n};\ngoog.Uri.QueryData.prototype.get \x3d function(key, opt_default) {\n  if (!key) {\n    return opt_default;\n  }\n  var values \x3d this.getValues(key);\n  return values.length \x3e 0 ? String(values[0]) : opt_default;\n};\ngoog.Uri.QueryData.prototype.setValues \x3d function(key, values) {\n  this.remove(key);\n  if (values.length \x3e 0) {\n    this.invalidateCache_();\n    this.keyMap_.set(this.getKeyName_(key), goog.array.clone(values));\n    this.count_ \x3d goog.asserts.assertNumber(this.count_) + values.length;\n  }\n};\ngoog.Uri.QueryData.prototype.toString \x3d function() {\n  if (this.encodedQuery_) {\n    return this.encodedQuery_;\n  }\n  if (!this.keyMap_) {\n    return \x22\x22;\n  }\n  const sb \x3d [];\n  const keys \x3d Array.from(this.keyMap_.keys());\n  var i \x3d 0;\n  for (; i \x3c keys.length; i++) {\n    const key \x3d keys[i];\n    const encodedKey \x3d goog.string.urlEncode(key);\n    const val \x3d this.getValues(key);\n    var j \x3d 0;\n    for (; j \x3c val.length; j++) {\n      var param \x3d encodedKey;\n      if (val[j] !\x3d\x3d \x22\x22) {\n        param \x3d param + (\x22\\x3d\x22 + goog.string.urlEncode(val[j]));\n      }\n      sb.push(param);\n    }\n  }\n  return this.encodedQuery_ \x3d sb.join(\x22\\x26\x22);\n};\ngoog.Uri.QueryData.prototype.toDecodedString \x3d function() {\n  return goog.Uri.decodeOrEmpty_(this.toString());\n};\ngoog.Uri.QueryData.prototype.invalidateCache_ \x3d function() {\n  this.encodedQuery_ \x3d null;\n};\ngoog.Uri.QueryData.prototype.filterKeys \x3d function(keys) {\n  this.ensureKeyMapInitialized_();\n  this.keyMap_.forEach(function(value, key) {\n    if (!goog.array.contains(keys, key)) {\n      this.remove(key);\n    }\n  }, this);\n  return this;\n};\ngoog.Uri.QueryData.prototype.clone \x3d function() {\n  var rv \x3d new goog.Uri.QueryData();\n  rv.encodedQuery_ \x3d this.encodedQuery_;\n  if (this.keyMap_) {\n    rv.keyMap_ \x3d new Map(this.keyMap_);\n    rv.count_ \x3d this.count_;\n  }\n  return rv;\n};\ngoog.Uri.QueryData.prototype.getKeyName_ \x3d function(arg) {\n  var keyName \x3d String(arg);\n  if (this.ignoreCase_) {\n    keyName \x3d keyName.toLowerCase();\n  }\n  return keyName;\n};\ngoog.Uri.QueryData.prototype.setIgnoreCase \x3d function(ignoreCase) {\n  var resetKeys \x3d ignoreCase \x26\x26 !this.ignoreCase_;\n  if (resetKeys) {\n    this.ensureKeyMapInitialized_();\n    this.invalidateCache_();\n    this.keyMap_.forEach(function(value, key) {\n      var lowerCase \x3d key.toLowerCase();\n      if (key !\x3d lowerCase) {\n        this.remove(key);\n        this.setValues(lowerCase, value);\n      }\n    }, this);\n  }\n  this.ignoreCase_ \x3d ignoreCase;\n};\ngoog.Uri.QueryData.prototype.extend \x3d function(var_args) {\n  var i \x3d 0;\n  for (; i \x3c arguments.length; i++) {\n    var data \x3d arguments[i];\n    goog.structs.forEach(data, function(value, key) {\n      this.add(key, value);\n    }, this);\n  }\n};\n");
SHADOW_ENV.evalLoad("goog.string.stringbuffer.js", true, "goog.provide(\x22goog.string.StringBuffer\x22);\ngoog.string.StringBuffer \x3d function(opt_a1, var_args) {\n  if (opt_a1 !\x3d null) {\n    this.append.apply(this, arguments);\n  }\n};\ngoog.string.StringBuffer.prototype.buffer_ \x3d \x22\x22;\ngoog.string.StringBuffer.prototype.set \x3d function(s) {\n  this.buffer_ \x3d \x22\x22 + s;\n};\ngoog.string.StringBuffer.prototype.append \x3d function(a1, opt_a2, var_args) {\n  this.buffer_ +\x3d String(a1);\n  if (opt_a2 !\x3d null) {\n    for (let i \x3d 1; i \x3c arguments.length; i++) {\n      this.buffer_ +\x3d arguments[i];\n    }\n  }\n  return this;\n};\ngoog.string.StringBuffer.prototype.clear \x3d function() {\n  this.buffer_ \x3d \x22\x22;\n};\ngoog.string.StringBuffer.prototype.getLength \x3d function() {\n  return this.buffer_.length;\n};\ngoog.string.StringBuffer.prototype.toString \x3d function() {\n  return this.buffer_;\n};\n");
SHADOW_ENV.evalLoad("cljs.core.js", true, "goog.provide(\x27cljs.core\x27);\ngoog.scope(function(){\n  cljs.core.goog$module$goog$math$Long \x3d goog.module.get(\x27goog.math.Long\x27);\n  cljs.core.goog$module$goog$object \x3d goog.module.get(\x27goog.object\x27);\n  cljs.core.goog$module$goog$array \x3d goog.module.get(\x27goog.array\x27);\n});\ncljs.core._STAR_clojurescript_version_STAR_ \x3d \x221.11.132\x22;\ncljs.core._STAR_unchecked_if_STAR_ \x3d false;\ncljs.core._STAR_unchecked_arrays_STAR_ \x3d false;\ncljs.core._STAR_warn_on_infer_STAR_ \x3d false;\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.PROTOCOL_SENTINEL !\x3d\x3d \x27undefined\x27)){\n} else {\ncljs.core.PROTOCOL_SENTINEL \x3d ({});\n}\ncljs.core.MODULE_URIS \x3d null;\ncljs.core.MODULE_INFOS \x3d null;\n/**\n * Var bound to the name value of the compiler build :target option.\n *   For example, if the compiler build :target is :nodejs, *target* will be bound\n *   to \x22nodejs\x22. *target* is a Google Closure define and can be set by compiler\n *   :closure-defines option.\n * @define {string}\n */\ncljs.core._STAR_target_STAR_ \x3d goog.define(\x22cljs.core._STAR_target_STAR_\x22,\x22default\x22);\n/**\n * Manually set the JavaScript global context. Only \x22window\x22, \x22self\x22\n *   , and \x22global\x22 supported. \n * @define {string}\n */\ncljs.core._STAR_global_STAR_ \x3d goog.define(\x22cljs.core._STAR_global_STAR_\x22,\x22default\x22);\n/**\n * Var bound to the current namespace. Only used for bootstrapping.\n * @type {*}\n */\ncljs.core._STAR_ns_STAR_ \x3d null;\n/**\n * @type {*}\n */\ncljs.core._STAR_out_STAR_ \x3d null;\ncljs.core._STAR_assert_STAR_ \x3d true;\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core._STAR_print_fn_STAR_ !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * Each runtime environment provides a different way to print output.\n *   Whatever function *print-fn* is bound to will be passed any\n *   Strings which should be printed.\n */\ncljs.core._STAR_print_fn_STAR_ \x3d null;\n}\n/**\n * Arranges to have tap functions executed via the supplied f, a\n *   function of no arguments. Returns true if successful, false otherwise.\n */\ncljs.core._STAR_exec_tap_fn_STAR_ \x3d (function cljs$core$_STAR_exec_tap_fn_STAR_(f){\nvar and__5000__auto__ \x3d (typeof setTimeout !\x3d\x3d \x27undefined\x27);\nif(and__5000__auto__){\nvar G__17381 \x3d setTimeout(f,(0));\nreturn (cljs.core.boolean$.cljs$core$IFn$_invoke$arity$1 ? cljs.core.boolean$.cljs$core$IFn$_invoke$arity$1(G__17381) : cljs.core.boolean$.call(null, G__17381));\n} else {\nreturn and__5000__auto__;\n}\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core._STAR_print_err_fn_STAR_ !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * Each runtime environment provides a different way to print error output.\n *   Whatever function *print-err-fn* is bound to will be passed any\n *   Strings which should be printed.\n */\ncljs.core._STAR_print_err_fn_STAR_ \x3d null;\n}\n/**\n * Set *print-fn* to f.\n */\ncljs.core.set_print_fn_BANG_ \x3d (function cljs$core$set_print_fn_BANG_(f){\nreturn (cljs.core._STAR_print_fn_STAR_ \x3d f);\n});\n/**\n * Set *print-err-fn* to f.\n */\ncljs.core.set_print_err_fn_BANG_ \x3d (function cljs$core$set_print_err_fn_BANG_(f){\nreturn (cljs.core._STAR_print_err_fn_STAR_ \x3d f);\n});\n/**\n * When set to true, output will be flushed whenever a newline is printed.\n * \n *   Defaults to true.\n */\ncljs.core._STAR_flush_on_newline_STAR_ \x3d true;\n/**\n * When set to logical false will drop newlines from printing calls.\n *   This is to work around the implicit newlines emitted by standard JavaScript\n *   console objects.\n */\ncljs.core._STAR_print_newline_STAR_ \x3d true;\n/**\n * When set to logical false, strings and characters will be printed with\n *   non-alphanumeric characters converted to the appropriate escape sequences.\n * \n *   Defaults to true\n */\ncljs.core._STAR_print_readably_STAR_ \x3d true;\n/**\n * If set to logical true, when printing an object, its metadata will also\n *   be printed in a form that can be read back by the reader.\n * \n *   Defaults to false.\n */\ncljs.core._STAR_print_meta_STAR_ \x3d false;\n/**\n * When set to logical true, objects will be printed in a way that preserves\n *   their type when read in later.\n * \n *   Defaults to false.\n */\ncljs.core._STAR_print_dup_STAR_ \x3d false;\n/**\n * *print-namespace-maps* controls whether the printer will print\n *   namespace map literal syntax.\n * \n *   Defaults to false, but the REPL binds it to true.\n */\ncljs.core._STAR_print_namespace_maps_STAR_ \x3d false;\n/**\n * *print-length* controls how many items of each collection the\n *   printer will print. If it is bound to logical false, there is no\n *   limit. Otherwise, it must be bound to an integer indicating the maximum\n *   number of items of each collection to print. If a collection contains\n *   more items, the printer will print items up to the limit followed by\n *   \x27...\x27 to represent the remaining items. The root binding is nil\n *   indicating no limit.\n * @type {null|number}\n */\ncljs.core._STAR_print_length_STAR_ \x3d null;\n/**\n * *print-level* controls how many levels deep the printer will\n *   print nested objects. If it is bound to logical false, there is no\n *   limit. Otherwise, it must be bound to an integer indicating the maximum\n *   level to print. Each argument to print is at level 0; if an argument is a\n *   collection, its items are at level 1; and so on. If an object is a\n *   collection and is at a level greater than or equal to the value bound to\n *   *print-level*, the printer prints \x27#\x27 to represent it. The root binding\n *   is nil indicating no limit.\n * @type {null|number}\n */\ncljs.core._STAR_print_level_STAR_ \x3d null;\n/**\n * *print-fns-bodies* controls whether functions print their source or\n *  only their names.\n */\ncljs.core._STAR_print_fn_bodies_STAR_ \x3d false;\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core._STAR_loaded_libs_STAR_ !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * @type {*}\n */\ncljs.core._STAR_loaded_libs_STAR_ \x3d null;\n}\ncljs.core.pr_opts \x3d (function cljs$core$pr_opts(){\nreturn new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22flush-on-newline\x22,\x22flush-on-newline\x22,-151457939),cljs.core._STAR_flush_on_newline_STAR_,new cljs.core.Keyword(null,\x22readably\x22,\x22readably\x22,1129599760),cljs.core._STAR_print_readably_STAR_,new cljs.core.Keyword(null,\x22meta\x22,\x22meta\x22,1499536964),cljs.core._STAR_print_meta_STAR_,new cljs.core.Keyword(null,\x22dup\x22,\x22dup\x22,556298533),cljs.core._STAR_print_dup_STAR_,new cljs.core.Keyword(null,\x22print-length\x22,\x22print-length\x22,1931866356),cljs.core._STAR_print_length_STAR_], null);\n});\n/**\n * Set *print-fn* to console.log\n */\ncljs.core.enable_console_print_BANG_ \x3d (function cljs$core$enable_console_print_BANG_(){\n(cljs.core._STAR_print_newline_STAR_ \x3d false);\n\ncljs.core.set_print_fn_BANG_((function (){\nvar xs \x3d arguments;\nreturn console.log.apply(console,cljs.core.goog$module$goog$array.clone(xs));\n}));\n\ncljs.core.set_print_err_fn_BANG_((function (){\nvar xs \x3d arguments;\nreturn console.error.apply(console,cljs.core.goog$module$goog$array.clone(xs));\n}));\n\nreturn null;\n});\n/**\n * Internal - do not use!\n */\ncljs.core.truth_ \x3d (function cljs$core$truth_(x){\nreturn (x !\x3d null \x26\x26 x !\x3d\x3d false);\n});\ncljs.core.not_native \x3d null;\n\n/**\n * Tests if 2 arguments are the same object\n */\ncljs.core.identical_QMARK_ \x3d (function cljs$core$identical_QMARK_(x,y){\nreturn (x \x3d\x3d\x3d y);\n});\n/**\n * Returns true if x is nil, false otherwise.\n */\ncljs.core.nil_QMARK_ \x3d (function cljs$core$nil_QMARK_(x){\nreturn (x \x3d\x3d null);\n});\n/**\n * Returns true if x is a JavaScript array.\n */\ncljs.core.array_QMARK_ \x3d (function cljs$core$array_QMARK_(x){\nif((cljs.core._STAR_target_STAR_ \x3d\x3d\x3d \x22nodejs\x22)){\nreturn Array.isArray(x);\n} else {\nreturn (x instanceof Array);\n}\n});\n/**\n * Returns true if x is a JavaScript number.\n */\ncljs.core.number_QMARK_ \x3d (function cljs$core$number_QMARK_(x){\nreturn typeof x \x3d\x3d\x3d \x27number\x27;\n});\n/**\n * Returns true if x is logical false, false otherwise.\n */\ncljs.core.not \x3d (function cljs$core$not(x){\nif((x \x3d\x3d null)){\nreturn true;\n} else {\nif(x \x3d\x3d\x3d false){\nreturn true;\n} else {\nreturn false;\n\n}\n}\n});\n/**\n * Returns true if x is not nil, false otherwise.\n */\ncljs.core.some_QMARK_ \x3d (function cljs$core$some_QMARK_(x){\nreturn (!((x \x3d\x3d null)));\n});\n/**\n * Returns true if x\x27s constructor is Object\n */\ncljs.core.object_QMARK_ \x3d (function cljs$core$object_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nreturn (x.constructor \x3d\x3d\x3d Object);\n} else {\nreturn false;\n}\n});\n/**\n * Returns true if x is a JavaScript string.\n */\ncljs.core.string_QMARK_ \x3d (function cljs$core$string_QMARK_(x){\nreturn (\x22string\x22 \x3d\x3d\x3d goog.typeOf(x));\n});\n/**\n * Returns true if x is a JavaScript string of length one.\n */\ncljs.core.char_QMARK_ \x3d (function cljs$core$char_QMARK_(x){\nreturn ((typeof x \x3d\x3d\x3d \x27string\x27) \x26\x26 (((1) \x3d\x3d\x3d x.length)));\n});\n/**\n * Returns true if given any argument.\n */\ncljs.core.any_QMARK_ \x3d (function cljs$core$any_QMARK_(x){\nreturn true;\n});\n/**\n * Internal - do not use!\n */\ncljs.core.native_satisfies_QMARK_ \x3d (function cljs$core$native_satisfies_QMARK_(p,x){\nvar x__$1 \x3d (((x \x3d\x3d null))?null:x);\nif((p[goog.typeOf(x__$1)])){\nreturn true;\n} else {\nif((p[\x22_\x22])){\nreturn true;\n} else {\nreturn false;\n\n}\n}\n});\ncljs.core.is_proto_ \x3d (function cljs$core$is_proto_(x){\nreturn (x.constructor.prototype \x3d\x3d\x3d x);\n});\n/**\n * When compiled for a command-line target, whatever function\n *   *main-cli-fn* is set to will be called with the command-line\n *   argv as arguments\n */\ncljs.core._STAR_main_cli_fn_STAR_ \x3d null;\n/**\n * A sequence of the supplied command line arguments, or nil if\n *   none were supplied\n */\ncljs.core._STAR_command_line_args_STAR_ \x3d null;\n/**\n * Return x\x27s constructor.\n */\ncljs.core.type \x3d (function cljs$core$type(x){\nif((x \x3d\x3d null)){\nreturn null;\n} else {\nreturn x.constructor;\n}\n});\ncljs.core.missing_protocol \x3d (function cljs$core$missing_protocol(proto,obj){\nvar ty \x3d cljs.core.type(obj);\nvar ty__$1 \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d ty;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn ty.cljs$lang$type;\n} else {\nreturn and__5000__auto__;\n}\n})())?ty.cljs$lang$ctorStr:goog.typeOf(obj));\nreturn (new Error([\x22No protocol method \x22,proto,\x22 defined for type \x22,ty__$1,\x22: \x22,obj].join(\x22\x22)));\n});\ncljs.core.type__GT_str \x3d (function cljs$core$type__GT_str(ty){\nvar temp__5802__auto__ \x3d ty.cljs$lang$ctorStr;\nif(cljs.core.truth_(temp__5802__auto__)){\nvar s \x3d temp__5802__auto__;\nreturn s;\n} else {\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(ty);\n}\n});\ncljs.core.load_file \x3d (function cljs$core$load_file(file){\nif(cljs.core.truth_(COMPILED)){\nreturn null;\n} else {\nreturn goog.nodeGlobalRequire(file);\n}\n});\nif((((typeof Symbol !\x3d\x3d \x27undefined\x27)) \x26\x26 ((goog.typeOf(Symbol) \x3d\x3d\x3d \x22function\x22)))){\ncljs.core.ITER_SYMBOL \x3d Symbol.iterator;\n} else {\ncljs.core.ITER_SYMBOL \x3d \x22@@iterator\x22;\n}\n/**\n * @enum {string}\n */\ncljs.core.CHAR_MAP \x3d ({\x22]\x22: \x22_RBRACK_\x22, \x22\x27\x22: \x22_SINGLEQUOTE_\x22, \x22\x3d\x22: \x22_EQ_\x22, \x22\\\x22\x22: \x22_DOUBLEQUOTE_\x22, \x22!\x22: \x22_BANG_\x22, \x22*\x22: \x22_STAR_\x22, \x22%\x22: \x22_PERCENT_\x22, \x22|\x22: \x22_BAR_\x22, \x22~\x22: \x22_TILDE_\x22, \x22/\x22: \x22_SLASH_\x22, \x22\\\\\x22: \x22_BSLASH_\x22, \x22-\x22: \x22_\x22, \x22?\x22: \x22_QMARK_\x22, \x22\x26\x22: \x22_AMPERSAND_\x22, \x22:\x22: \x22_COLON_\x22, \x22\x3c\x22: \x22_LT_\x22, \x22{\x22: \x22_LBRACE_\x22, \x22}\x22: \x22_RBRACE_\x22, \x22[\x22: \x22_LBRACK_\x22, \x22#\x22: \x22_SHARP_\x22, \x22^\x22: \x22_CARET_\x22, \x22+\x22: \x22_PLUS_\x22, \x22@\x22: \x22_CIRCA_\x22, \x22\x3e\x22: \x22_GT_\x22});\n/**\n * @enum {string}\n */\ncljs.core.DEMUNGE_MAP \x3d ({\x22_RBRACE_\x22: \x22}\x22, \x22_COLON_\x22: \x22:\x22, \x22_BANG_\x22: \x22!\x22, \x22_QMARK_\x22: \x22?\x22, \x22_BSLASH_\x22: \x22\\\\\\\\\x22, \x22_SLASH_\x22: \x22/\x22, \x22_PERCENT_\x22: \x22%\x22, \x22_PLUS_\x22: \x22+\x22, \x22_SHARP_\x22: \x22#\x22, \x22_LBRACE_\x22: \x22{\x22, \x22_BAR_\x22: \x22|\x22, \x22_LBRACK_\x22: \x22[\x22, \x22_EQ_\x22: \x22\x3d\x22, \x22_\x22: \x22-\x22, \x22_TILDE_\x22: \x22~\x22, \x22_RBRACK_\x22: \x22]\x22, \x22_GT_\x22: \x22\x3e\x22, \x22_SINGLEQUOTE_\x22: \x22\x27\x22, \x22_CIRCA_\x22: \x22@\x22, \x22_AMPERSAND_\x22: \x22\x26\x22, \x22_DOUBLEQUOTE_\x22: \x22\\\\\\\x22\x22, \x22_CARET_\x22: \x22^\x22, \x22_LT_\x22: \x22\x3c\x22, \x22_STAR_\x22: \x22*\x22});\ncljs.core.DEMUNGE_PATTERN \x3d null;\n/**\n * Returns highest resolution time offered by host in milliseconds.\n */\ncljs.core.system_time \x3d (function cljs$core$system_time(){\nif((((typeof performance !\x3d\x3d \x27undefined\x27)) \x26\x26 ((!((performance.now \x3d\x3d null)))))){\nreturn performance.now();\n} else {\nif((((typeof process !\x3d\x3d \x27undefined\x27)) \x26\x26 ((!((process.hrtime \x3d\x3d null)))))){\nvar t \x3d process.hrtime();\nreturn ((((t[(0)]) * 1.0E9) + (t[(1)])) / 1000000.0);\n} else {\nreturn (new Date()).getTime();\n\n}\n}\n});\n/**\n * Construct a JavaScript array of the specified dimensions. Accepts ignored\n *   type argument for compatibility with Clojure. Note that there is no efficient\n *   way to allocate multi-dimensional arrays in JavaScript; as such, this function\n *   will run in polynomial time when called with 3 or more arguments.\n */\ncljs.core.make_array \x3d (function cljs$core$make_array(var_args){\nvar G__17386 \x3d arguments.length;\nswitch (G__17386) {\ncase 1:\nreturn cljs.core.make_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.make_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20091 \x3d arguments.length;\nvar i__5727__auto___20093 \x3d (0);\nwhile(true){\nif((i__5727__auto___20093 \x3c len__5726__auto___20091)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20093]));\n\nvar G__20097 \x3d (i__5727__auto___20093 + (1));\ni__5727__auto___20093 \x3d G__20097;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.make_array.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.make_array.cljs$core$IFn$_invoke$arity$1 \x3d (function (size){\nreturn (new Array(size));\n}));\n\n(cljs.core.make_array.cljs$core$IFn$_invoke$arity$2 \x3d (function (type,size){\nreturn (new Array(size));\n}));\n\n(cljs.core.make_array.cljs$core$IFn$_invoke$arity$variadic \x3d (function (type,size,more_sizes){\nvar dims \x3d more_sizes;\nvar dimarray \x3d (new Array(size));\nvar n__5593__auto___20100 \x3d dimarray.length;\nvar i_20101 \x3d (0);\nwhile(true){\nif((i_20101 \x3c n__5593__auto___20100)){\n(dimarray[i_20101] \x3d (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)));\n\nvar G__20105 \x3d (i_20101 + (1));\ni_20101 \x3d G__20105;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn dimarray;\n}));\n\n/** @this {Function} */\n(cljs.core.make_array.cljs$lang$applyTo \x3d (function (seq17383){\nvar G__17384 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17383) : cljs.core.first.call(null, seq17383));\nvar seq17383__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17383) : cljs.core.next.call(null, seq17383));\nvar G__17385 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17383__$1) : cljs.core.first.call(null, seq17383__$1));\nvar seq17383__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17383__$1) : cljs.core.next.call(null, seq17383__$1));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17384,G__17385,seq17383__$2);\n}));\n\n(cljs.core.make_array.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns a javascript array, cloned from the passed in array\n */\ncljs.core.aclone \x3d (function cljs$core$aclone(arr){\nvar len \x3d arr.length;\nvar new_arr \x3d (new Array(len));\nvar n__5593__auto___20111 \x3d len;\nvar i_20113 \x3d (0);\nwhile(true){\nif((i_20113 \x3c n__5593__auto___20111)){\n(new_arr[i_20113] \x3d (arr[i_20113]));\n\nvar G__20115 \x3d (i_20113 + (1));\ni_20113 \x3d G__20115;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn new_arr;\n});\n/**\n * Creates a new javascript array.\n * @param {...*} var_args\n */\ncljs.core.array \x3d (function cljs$core$array(var_args){\nvar a \x3d (new Array(arguments.length));\nvar i \x3d (0);\nwhile(true){\nif((i \x3c a.length)){\n(a[i] \x3d (arguments[i]));\n\nvar G__20121 \x3d (i + (1));\ni \x3d G__20121;\ncontinue;\n} else {\nreturn a;\n}\nbreak;\n}\n});\ncljs.core.maybe_warn \x3d (function cljs$core$maybe_warn(e){\nif(cljs.core.truth_(cljs.core._STAR_print_err_fn_STAR_)){\nreturn cljs.core._STAR_print_err_fn_STAR_.call(null, e);\n} else {\nreturn null;\n}\n});\ncljs.core.checked_aget \x3d (function cljs$core$checked_aget(var_args){\nvar G__17391 \x3d arguments.length;\nswitch (G__17391) {\ncase 2:\nreturn cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20128 \x3d arguments.length;\nvar i__5727__auto___20130 \x3d (0);\nwhile(true){\nif((i__5727__auto___20130 \x3c len__5726__auto___20128)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20130]));\n\nvar G__20131 \x3d (i__5727__auto___20130 + (1));\ni__5727__auto___20130 \x3d G__20131;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2 \x3d (function (array,idx){\ntry{if(cljs.core.truth_((function (){var or__5002__auto__ \x3d cljs.core.array_QMARK_(array);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn goog.isArrayLike(array);\n}\n})())){\n} else {\nthrow (new Error(\x22Assert failed: (or (array? array) (goog/isArrayLike array))\x22));\n}\n\nif(typeof idx \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? idx)\x22));\n}\n\nif((!((idx \x3c (0))))){\n} else {\nthrow (new Error(\x22Assert failed: (not (neg? idx))\x22));\n}\n\nif((idx \x3c array.length)){\n} else {\nthrow (new Error(\x22Assert failed: (\x3c idx (alength array))\x22));\n}\n}catch (e17392){var e_20146 \x3d e17392;\ncljs.core.maybe_warn(e_20146);\n}\nreturn (array[idx]);\n}));\n\n(cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$variadic \x3d (function (array,idx,idxs){\nvar G__17393 \x3d cljs.core.checked_aget;\nvar G__17394 \x3d cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2(array,idx);\nvar G__17395 \x3d idxs;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$3 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$3(G__17393,G__17394,G__17395) : cljs.core.apply.call(null, G__17393,G__17394,G__17395));\n}));\n\n/** @this {Function} */\n(cljs.core.checked_aget.cljs$lang$applyTo \x3d (function (seq17388){\nvar G__17389 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17388) : cljs.core.first.call(null, seq17388));\nvar seq17388__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17388) : cljs.core.next.call(null, seq17388));\nvar G__17390 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17388__$1) : cljs.core.first.call(null, seq17388__$1));\nvar seq17388__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17388__$1) : cljs.core.next.call(null, seq17388__$1));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17389,G__17390,seq17388__$2);\n}));\n\n(cljs.core.checked_aget.cljs$lang$maxFixedArity \x3d (2));\n\ncljs.core.checked_aset \x3d (function cljs$core$checked_aset(var_args){\nvar G__17401 \x3d arguments.length;\nswitch (G__17401) {\ncase 3:\nreturn cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20153 \x3d arguments.length;\nvar i__5727__auto___20154 \x3d (0);\nwhile(true){\nif((i__5727__auto___20154 \x3c len__5726__auto___20153)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20154]));\n\nvar G__20157 \x3d (i__5727__auto___20154 + (1));\ni__5727__auto___20154 \x3d G__20157;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$3 \x3d (function (array,idx,val){\ntry{if(cljs.core.truth_((function (){var or__5002__auto__ \x3d cljs.core.array_QMARK_(array);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn goog.isArrayLike(array);\n}\n})())){\n} else {\nthrow (new Error(\x22Assert failed: (or (array? array) (goog/isArrayLike array))\x22));\n}\n\nif(typeof idx \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? idx)\x22));\n}\n\nif((!((idx \x3c (0))))){\n} else {\nthrow (new Error(\x22Assert failed: (not (neg? idx))\x22));\n}\n\nif((idx \x3c array.length)){\n} else {\nthrow (new Error(\x22Assert failed: (\x3c idx (alength array))\x22));\n}\n}catch (e17402){var e_20166 \x3d e17402;\ncljs.core.maybe_warn(e_20166);\n}\nreturn (array[idx] \x3d val);\n}));\n\n(cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$variadic \x3d (function (array,idx,idx2,idxv){\nvar G__17403 \x3d cljs.core.checked_aset;\nvar G__17404 \x3d cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2(array,idx);\nvar G__17405 \x3d idx2;\nvar G__17406 \x3d idxv;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$4 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$4(G__17403,G__17404,G__17405,G__17406) : cljs.core.apply.call(null, G__17403,G__17404,G__17405,G__17406));\n}));\n\n/** @this {Function} */\n(cljs.core.checked_aset.cljs$lang$applyTo \x3d (function (seq17397){\nvar G__17398 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17397) : cljs.core.first.call(null, seq17397));\nvar seq17397__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17397) : cljs.core.next.call(null, seq17397));\nvar G__17399 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17397__$1) : cljs.core.first.call(null, seq17397__$1));\nvar seq17397__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17397__$1) : cljs.core.next.call(null, seq17397__$1));\nvar G__17400 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17397__$2) : cljs.core.first.call(null, seq17397__$2));\nvar seq17397__$3 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17397__$2) : cljs.core.next.call(null, seq17397__$2));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17398,G__17399,G__17400,seq17397__$3);\n}));\n\n(cljs.core.checked_aset.cljs$lang$maxFixedArity \x3d (3));\n\ncljs.core.checked_aget_SINGLEQUOTE_ \x3d (function cljs$core$checked_aget_SINGLEQUOTE_(var_args){\nvar G__17411 \x3d arguments.length;\nswitch (G__17411) {\ncase 2:\nreturn cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20181 \x3d arguments.length;\nvar i__5727__auto___20183 \x3d (0);\nwhile(true){\nif((i__5727__auto___20183 \x3c len__5726__auto___20181)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20183]));\n\nvar G__20187 \x3d (i__5727__auto___20183 + (1));\ni__5727__auto___20183 \x3d G__20187;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2 \x3d (function (array,idx){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d cljs.core.array_QMARK_(array);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn goog.isArrayLike(array);\n}\n})())){\n} else {\nthrow (new Error(\x22Assert failed: (or (array? array) (goog/isArrayLike array))\x22));\n}\n\nif(typeof idx \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? idx)\x22));\n}\n\nif((!((idx \x3c (0))))){\n} else {\nthrow (new Error(\x22Assert failed: (not (neg? idx))\x22));\n}\n\nif((idx \x3c array.length)){\n} else {\nthrow (new Error(\x22Assert failed: (\x3c idx (alength array))\x22));\n}\n\nreturn (array[idx]);\n}));\n\n(cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (array,idx,idxs){\nvar G__17412 \x3d cljs.core.checked_aget_SINGLEQUOTE_;\nvar G__17413 \x3d cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2(array,idx);\nvar G__17414 \x3d idxs;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$3 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$3(G__17412,G__17413,G__17414) : cljs.core.apply.call(null, G__17412,G__17413,G__17414));\n}));\n\n/** @this {Function} */\n(cljs.core.checked_aget_SINGLEQUOTE_.cljs$lang$applyTo \x3d (function (seq17408){\nvar G__17409 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17408) : cljs.core.first.call(null, seq17408));\nvar seq17408__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17408) : cljs.core.next.call(null, seq17408));\nvar G__17410 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17408__$1) : cljs.core.first.call(null, seq17408__$1));\nvar seq17408__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17408__$1) : cljs.core.next.call(null, seq17408__$1));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17409,G__17410,seq17408__$2);\n}));\n\n(cljs.core.checked_aget_SINGLEQUOTE_.cljs$lang$maxFixedArity \x3d (2));\n\ncljs.core.checked_aset_SINGLEQUOTE_ \x3d (function cljs$core$checked_aset_SINGLEQUOTE_(var_args){\nvar G__17420 \x3d arguments.length;\nswitch (G__17420) {\ncase 3:\nreturn cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20208 \x3d arguments.length;\nvar i__5727__auto___20209 \x3d (0);\nwhile(true){\nif((i__5727__auto___20209 \x3c len__5726__auto___20208)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20209]));\n\nvar G__20212 \x3d (i__5727__auto___20209 + (1));\ni__5727__auto___20209 \x3d G__20212;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$3 \x3d (function (array,idx,val){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d cljs.core.array_QMARK_(array);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn goog.isArrayLike(array);\n}\n})())){\n} else {\nthrow (new Error(\x22Assert failed: (or (array? array) (goog/isArrayLike array))\x22));\n}\n\nif(typeof idx \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? idx)\x22));\n}\n\nif((!((idx \x3c (0))))){\n} else {\nthrow (new Error(\x22Assert failed: (not (neg? idx))\x22));\n}\n\nif((idx \x3c array.length)){\n} else {\nthrow (new Error(\x22Assert failed: (\x3c idx (alength array))\x22));\n}\n\nreturn (array[idx] \x3d val);\n}));\n\n(cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (array,idx,idx2,idxv){\nvar G__17421 \x3d cljs.core.checked_aset_SINGLEQUOTE_;\nvar G__17422 \x3d cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2(array,idx);\nvar G__17423 \x3d idx2;\nvar G__17424 \x3d idxv;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$4 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$4(G__17421,G__17422,G__17423,G__17424) : cljs.core.apply.call(null, G__17421,G__17422,G__17423,G__17424));\n}));\n\n/** @this {Function} */\n(cljs.core.checked_aset_SINGLEQUOTE_.cljs$lang$applyTo \x3d (function (seq17416){\nvar G__17417 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17416) : cljs.core.first.call(null, seq17416));\nvar seq17416__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17416) : cljs.core.next.call(null, seq17416));\nvar G__17418 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17416__$1) : cljs.core.first.call(null, seq17416__$1));\nvar seq17416__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17416__$1) : cljs.core.next.call(null, seq17416__$1));\nvar G__17419 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17416__$2) : cljs.core.first.call(null, seq17416__$2));\nvar seq17416__$3 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17416__$2) : cljs.core.next.call(null, seq17416__$2));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17417,G__17418,G__17419,seq17416__$3);\n}));\n\n(cljs.core.checked_aset_SINGLEQUOTE_.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * Returns the value at the index/indices. Works on JavaScript arrays.\n */\ncljs.core.aget \x3d (function cljs$core$aget(var_args){\nvar G__17429 \x3d arguments.length;\nswitch (G__17429) {\ncase 2:\nreturn cljs.core.aget.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20262 \x3d arguments.length;\nvar i__5727__auto___20263 \x3d (0);\nwhile(true){\nif((i__5727__auto___20263 \x3c len__5726__auto___20262)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20263]));\n\nvar G__20264 \x3d (i__5727__auto___20263 + (1));\ni__5727__auto___20263 \x3d G__20264;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.aget.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.aget.cljs$core$IFn$_invoke$arity$2 \x3d (function (array,idx){\nreturn (array[idx]);\n}));\n\n(cljs.core.aget.cljs$core$IFn$_invoke$arity$variadic \x3d (function (array,idx,idxs){\nvar G__17430 \x3d cljs.core.aget;\nvar G__17431 \x3d (array[idx]);\nvar G__17432 \x3d idxs;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$3 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$3(G__17430,G__17431,G__17432) : cljs.core.apply.call(null, G__17430,G__17431,G__17432));\n}));\n\n/** @this {Function} */\n(cljs.core.aget.cljs$lang$applyTo \x3d (function (seq17426){\nvar G__17427 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17426) : cljs.core.first.call(null, seq17426));\nvar seq17426__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17426) : cljs.core.next.call(null, seq17426));\nvar G__17428 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17426__$1) : cljs.core.first.call(null, seq17426__$1));\nvar seq17426__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17426__$1) : cljs.core.next.call(null, seq17426__$1));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17427,G__17428,seq17426__$2);\n}));\n\n(cljs.core.aget.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Sets the value at the index/indices. Works on JavaScript arrays.\n *   Returns val.\n */\ncljs.core.aset \x3d (function cljs$core$aset(var_args){\nvar G__17438 \x3d arguments.length;\nswitch (G__17438) {\ncase 3:\nreturn cljs.core.aset.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20272 \x3d arguments.length;\nvar i__5727__auto___20273 \x3d (0);\nwhile(true){\nif((i__5727__auto___20273 \x3c len__5726__auto___20272)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20273]));\n\nvar G__20274 \x3d (i__5727__auto___20273 + (1));\ni__5727__auto___20273 \x3d G__20274;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.aset.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.aset.cljs$core$IFn$_invoke$arity$3 \x3d (function (array,idx,val){\nreturn (array[idx] \x3d val);\n}));\n\n(cljs.core.aset.cljs$core$IFn$_invoke$arity$variadic \x3d (function (array,idx,idx2,idxv){\nvar G__17439 \x3d cljs.core.aset;\nvar G__17440 \x3d (array[idx]);\nvar G__17441 \x3d idx2;\nvar G__17442 \x3d idxv;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$4 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$4(G__17439,G__17440,G__17441,G__17442) : cljs.core.apply.call(null, G__17439,G__17440,G__17441,G__17442));\n}));\n\n/** @this {Function} */\n(cljs.core.aset.cljs$lang$applyTo \x3d (function (seq17434){\nvar G__17435 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17434) : cljs.core.first.call(null, seq17434));\nvar seq17434__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17434) : cljs.core.next.call(null, seq17434));\nvar G__17436 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17434__$1) : cljs.core.first.call(null, seq17434__$1));\nvar seq17434__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17434__$1) : cljs.core.next.call(null, seq17434__$1));\nvar G__17437 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17434__$2) : cljs.core.first.call(null, seq17434__$2));\nvar seq17434__$3 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17434__$2) : cljs.core.next.call(null, seq17434__$2));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17435,G__17436,G__17437,seq17434__$3);\n}));\n\n(cljs.core.aset.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * Returns the length of the array. Works on arrays of all types.\n */\ncljs.core.alength \x3d (function cljs$core$alength(array){\nreturn array.length;\n});\n/**\n * Returns an array with components set to the values in aseq. Optional type\n *   argument accepted for compatibility with Clojure.\n */\ncljs.core.into_array \x3d (function cljs$core$into_array(var_args){\nvar G__17444 \x3d arguments.length;\nswitch (G__17444) {\ncase 1:\nreturn cljs.core.into_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.into_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.into_array.cljs$core$IFn$_invoke$arity$1 \x3d (function (aseq){\nreturn cljs.core.into_array.cljs$core$IFn$_invoke$arity$2(null,aseq);\n}));\n\n(cljs.core.into_array.cljs$core$IFn$_invoke$arity$2 \x3d (function (type,aseq){\nvar G__17445 \x3d (function (a,x){\na.push(x);\n\nreturn a;\n});\nvar G__17446 \x3d [];\nvar G__17447 \x3d aseq;\nreturn (cljs.core.reduce.cljs$core$IFn$_invoke$arity$3 ? cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(G__17445,G__17446,G__17447) : cljs.core.reduce.call(null, G__17445,G__17446,G__17447));\n}));\n\n(cljs.core.into_array.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Invoke JavaScript object method via string. Needed when the\n *   string is not a valid unquoted property name.\n */\ncljs.core.js_invoke \x3d (function cljs$core$js_invoke(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___20292 \x3d arguments.length;\nvar i__5727__auto___20293 \x3d (0);\nwhile(true){\nif((i__5727__auto___20293 \x3c len__5726__auto___20292)){\nargs__5732__auto__.push((arguments[i__5727__auto___20293]));\n\nvar G__20294 \x3d (i__5727__auto___20293 + (1));\ni__5727__auto___20293 \x3d G__20294;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.js_invoke.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(cljs.core.js_invoke.cljs$core$IFn$_invoke$arity$variadic \x3d (function (obj,s,args){\nreturn (obj[s]).apply(obj,cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(args));\n}));\n\n(cljs.core.js_invoke.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(cljs.core.js_invoke.cljs$lang$applyTo \x3d (function (seq17448){\nvar G__17449 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17448) : cljs.core.first.call(null, seq17448));\nvar seq17448__$1 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17448) : cljs.core.next.call(null, seq17448));\nvar G__17450 \x3d (cljs.core.first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.first.cljs$core$IFn$_invoke$arity$1(seq17448__$1) : cljs.core.first.call(null, seq17448__$1));\nvar seq17448__$2 \x3d (cljs.core.next.cljs$core$IFn$_invoke$arity$1 ? cljs.core.next.cljs$core$IFn$_invoke$arity$1(seq17448__$1) : cljs.core.next.call(null, seq17448__$1));\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17449,G__17450,seq17448__$2);\n}));\n\n/**\n * Returns true if x is an instance of Symbol\n */\ncljs.core.js_symbol_QMARK_ \x3d (function cljs$core$js_symbol_QMARK_(x){\nreturn (((goog.typeOf(x) \x3d\x3d\x3d \x22symbol\x22)) || ((((typeof Symbol !\x3d\x3d \x27undefined\x27)) \x26\x26 ((x instanceof Symbol)))));\n});\n\n/**\n * Marker protocol\n * @interface\n */\ncljs.core.Fn \x3d function(){};\n\n\n/**\n * Protocol for adding the ability to invoke an object as a function.\n *   For example, a vector can also be used to look up a value:\n *   ([1 2 3 4] 1) \x3d\x3e 2\n * @interface\n */\ncljs.core.IFn \x3d function(){};\n\nvar cljs$core$IFn$_invoke$dyn_20297 \x3d (function() {\nvar G__20299 \x3d null;\nvar G__20299__1 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__2 \x3d (function (this$,a){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(this$,a) : m__5351__auto__.call(null, this$,a));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(this$,a) : m__5349__auto__.call(null, this$,a));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__3 \x3d (function (this$,a,b){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(this$,a,b) : m__5351__auto__.call(null, this$,a,b));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(this$,a,b) : m__5349__auto__.call(null, this$,a,b));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__4 \x3d (function (this$,a,b,c){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$4(this$,a,b,c) : m__5351__auto__.call(null, this$,a,b,c));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$4(this$,a,b,c) : m__5349__auto__.call(null, this$,a,b,c));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__5 \x3d (function (this$,a,b,c,d){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$5 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d) : m__5351__auto__.call(null, this$,a,b,c,d));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$5 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d) : m__5349__auto__.call(null, this$,a,b,c,d));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__6 \x3d (function (this$,a,b,c,d,e){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$6 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e) : m__5351__auto__.call(null, this$,a,b,c,d,e));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$6 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e) : m__5349__auto__.call(null, this$,a,b,c,d,e));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__7 \x3d (function (this$,a,b,c,d,e,f){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$7 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f) : m__5351__auto__.call(null, this$,a,b,c,d,e,f));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$7 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f) : m__5349__auto__.call(null, this$,a,b,c,d,e,f));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__8 \x3d (function (this$,a,b,c,d,e,f,g){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$8 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$8 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__9 \x3d (function (this$,a,b,c,d,e,f,g,h){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$9 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$9 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__10 \x3d (function (this$,a,b,c,d,e,f,g,h,i){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$10 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$10 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__11 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$11 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$11 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__12 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$12 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$12 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__13 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$13 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$13(this$,a,b,c,d,e,f,g,h,i,j,k,l) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$13 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$13(this$,a,b,c,d,e,f,g,h,i,j,k,l) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__14 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$14 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$14(this$,a,b,c,d,e,f,g,h,i,j,k,l,m) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$14 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$14(this$,a,b,c,d,e,f,g,h,i,j,k,l,m) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__15 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$15 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$15(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$15 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$15(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__16 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$16 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$16(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$16 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$16(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__17 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$17 ? m__5351__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__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$17 ? m__5349__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__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__18 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$18 ? m__5351__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__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$18 ? m__5349__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__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__19 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$19 ? m__5351__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__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$19 ? m__5349__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__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__20 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$20 ? m__5351__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__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$20 ? m__5349__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__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__21 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$21 ? m__5351__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, new cljs.core.IndexedSeq([t],0,null)) : m__5351__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$21 ? m__5349__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, new cljs.core.IndexedSeq([t],0,null)) : m__5349__auto__.call(null, this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nvar G__20299__22 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$21 ? m__5351__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, new cljs.core.IndexedSeq([t,rest],0,null)) : m__5351__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));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$21 ? m__5349__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, new cljs.core.IndexedSeq([t,rest],0,null)) : m__5349__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));\n} else {\nthrow cljs.core.missing_protocol(\x22IFn.-invoke\x22,this$);\n}\n}\n});\nG__20299 \x3d function(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){\nswitch(arguments.length){\ncase 1:\nreturn G__20299__1.call(this,this$);\ncase 2:\nreturn G__20299__2.call(this,this$,a);\ncase 3:\nreturn G__20299__3.call(this,this$,a,b);\ncase 4:\nreturn G__20299__4.call(this,this$,a,b,c);\ncase 5:\nreturn G__20299__5.call(this,this$,a,b,c,d);\ncase 6:\nreturn G__20299__6.call(this,this$,a,b,c,d,e);\ncase 7:\nreturn G__20299__7.call(this,this$,a,b,c,d,e,f);\ncase 8:\nreturn G__20299__8.call(this,this$,a,b,c,d,e,f,g);\ncase 9:\nreturn G__20299__9.call(this,this$,a,b,c,d,e,f,g,h);\ncase 10:\nreturn G__20299__10.call(this,this$,a,b,c,d,e,f,g,h,i);\ncase 11:\nreturn G__20299__11.call(this,this$,a,b,c,d,e,f,g,h,i,j);\ncase 12:\nreturn G__20299__12.call(this,this$,a,b,c,d,e,f,g,h,i,j,k);\ncase 13:\nreturn G__20299__13.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l);\ncase 14:\nreturn G__20299__14.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m);\ncase 15:\nreturn G__20299__15.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n);\ncase 16:\nreturn G__20299__16.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);\ncase 17:\nreturn G__20299__17.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);\ncase 18:\nreturn G__20299__18.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q);\ncase 19:\nreturn G__20299__19.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r);\ncase 20:\nreturn G__20299__20.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s);\ncase 21:\nreturn G__20299__21.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t);\ncase 22:\nreturn G__20299__22.call(this,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__20299.cljs$core$IFn$_invoke$arity$1 \x3d G__20299__1;\nG__20299.cljs$core$IFn$_invoke$arity$2 \x3d G__20299__2;\nG__20299.cljs$core$IFn$_invoke$arity$3 \x3d G__20299__3;\nG__20299.cljs$core$IFn$_invoke$arity$4 \x3d G__20299__4;\nG__20299.cljs$core$IFn$_invoke$arity$5 \x3d G__20299__5;\nG__20299.cljs$core$IFn$_invoke$arity$6 \x3d G__20299__6;\nG__20299.cljs$core$IFn$_invoke$arity$7 \x3d G__20299__7;\nG__20299.cljs$core$IFn$_invoke$arity$8 \x3d G__20299__8;\nG__20299.cljs$core$IFn$_invoke$arity$9 \x3d G__20299__9;\nG__20299.cljs$core$IFn$_invoke$arity$10 \x3d G__20299__10;\nG__20299.cljs$core$IFn$_invoke$arity$11 \x3d G__20299__11;\nG__20299.cljs$core$IFn$_invoke$arity$12 \x3d G__20299__12;\nG__20299.cljs$core$IFn$_invoke$arity$13 \x3d G__20299__13;\nG__20299.cljs$core$IFn$_invoke$arity$14 \x3d G__20299__14;\nG__20299.cljs$core$IFn$_invoke$arity$15 \x3d G__20299__15;\nG__20299.cljs$core$IFn$_invoke$arity$16 \x3d G__20299__16;\nG__20299.cljs$core$IFn$_invoke$arity$17 \x3d G__20299__17;\nG__20299.cljs$core$IFn$_invoke$arity$18 \x3d G__20299__18;\nG__20299.cljs$core$IFn$_invoke$arity$19 \x3d G__20299__19;\nG__20299.cljs$core$IFn$_invoke$arity$20 \x3d G__20299__20;\nG__20299.cljs$core$IFn$_invoke$arity$21 \x3d G__20299__21;\nG__20299.cljs$core$IFn$_invoke$arity$22 \x3d G__20299__22;\nreturn G__20299;\n})()\n;\ncljs.core._invoke \x3d (function cljs$core$_invoke(var_args){\nvar G__17452 \x3d arguments.length;\nswitch (G__17452) {\ncase 1:\nreturn cljs.core._invoke.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._invoke.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core._invoke.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core._invoke.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core._invoke.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn cljs.core._invoke.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ncase 7:\nreturn cljs.core._invoke.cljs$core$IFn$_invoke$arity$7((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]));\n\nbreak;\ncase 8:\nreturn 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)]));\n\nbreak;\ncase 9:\nreturn 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)]));\n\nbreak;\ncase 10:\nreturn 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)]));\n\nbreak;\ncase 11:\nreturn 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)]));\n\nbreak;\ncase 12:\nreturn 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)]));\n\nbreak;\ncase 13:\nreturn 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)]));\n\nbreak;\ncase 14:\nreturn 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)]));\n\nbreak;\ncase 15:\nreturn 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)]));\n\nbreak;\ncase 16:\nreturn 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)]));\n\nbreak;\ncase 17:\nreturn 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)]));\n\nbreak;\ncase 18:\nreturn 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)]));\n\nbreak;\ncase 19:\nreturn 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)]));\n\nbreak;\ncase 20:\nreturn 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)]));\n\nbreak;\ncase 21:\nreturn 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)]));\n\nbreak;\ncase 22:\nreturn 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)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$1 \x3d (function (this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$1 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$1(this$);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$2 \x3d (function (this$,a){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$2 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$2(this$,a);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$3 \x3d (function (this$,a,b){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$3 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$3(this$,a,b);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$4 \x3d (function (this$,a,b,c){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$4 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$4(this$,a,b,c);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$5 \x3d (function (this$,a,b,c,d){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$5 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$6 \x3d (function (this$,a,b,c,d,e){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$6 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$7 \x3d (function (this$,a,b,c,d,e,f){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$7 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$8 \x3d (function (this$,a,b,c,d,e,f,g){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$8 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$9 \x3d (function (this$,a,b,c,d,e,f,g,h){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$9 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$10 \x3d (function (this$,a,b,c,d,e,f,g,h,i){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$10 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$11 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$11 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$12 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$12 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$13 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$13 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$13(this$,a,b,c,d,e,f,g,h,i,j,k,l);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$14 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$14 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$14(this$,a,b,c,d,e,f,g,h,i,j,k,l,m);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$15 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$15 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$15(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$16 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$16 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$16(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$17 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$17 \x3d\x3d null)))))){\nreturn this$.cljs$core$IFn$_invoke$arity$17(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$18 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$18 \x3d\x3d null)))))){\nreturn 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);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$19 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$19 \x3d\x3d null)))))){\nreturn 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);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$20 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$20 \x3d\x3d null)))))){\nreturn 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);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$21 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$21 \x3d\x3d null)))))){\nreturn 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);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t);\n}\n}));\n\n(cljs.core._invoke.cljs$core$IFn$_invoke$arity$22 \x3d (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IFn$_invoke$arity$22 \x3d\x3d null)))))){\nreturn 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);\n} else {\nreturn cljs$core$IFn$_invoke$dyn_20297(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest);\n}\n}));\n\n(cljs.core._invoke.cljs$lang$maxFixedArity \x3d 22);\n\n\n\n/**\n * Protocol for cloning a value.\n * @interface\n */\ncljs.core.ICloneable \x3d function(){};\n\nvar cljs$core$ICloneable$_clone$dyn_20490 \x3d (function (value){\nvar x__5350__auto__ \x3d (((value \x3d\x3d null))?null:value);\nvar m__5351__auto__ \x3d (cljs.core._clone[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(value) : m__5351__auto__.call(null, value));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._clone[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(value) : m__5349__auto__.call(null, value));\n} else {\nthrow cljs.core.missing_protocol(\x22ICloneable.-clone\x22,value);\n}\n}\n});\n/**\n * Creates a clone of value.\n */\ncljs.core._clone \x3d (function cljs$core$_clone(value){\nif((((!((value \x3d\x3d null)))) \x26\x26 ((!((value.cljs$core$ICloneable$_clone$arity$1 \x3d\x3d null)))))){\nreturn value.cljs$core$ICloneable$_clone$arity$1(value);\n} else {\nreturn cljs$core$ICloneable$_clone$dyn_20490(value);\n}\n});\n\n\n/**\n * Protocol for adding the ability to count a collection in constant time.\n * @interface\n */\ncljs.core.ICounted \x3d function(){};\n\nvar cljs$core$ICounted$_count$dyn_20494 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._count[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._count[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22ICounted.-count\x22,coll);\n}\n}\n});\n/**\n * Calculates the count of coll in constant time. Used by cljs.core/count.\n */\ncljs.core._count \x3d (function cljs$core$_count(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ICounted$_count$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$ICounted$_count$arity$1(coll);\n} else {\nreturn cljs$core$ICounted$_count$dyn_20494(coll);\n}\n});\n\n\n/**\n * Protocol for creating an empty collection.\n * @interface\n */\ncljs.core.IEmptyableCollection \x3d function(){};\n\nvar cljs$core$IEmptyableCollection$_empty$dyn_20497 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._empty[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._empty[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IEmptyableCollection.-empty\x22,coll);\n}\n}\n});\n/**\n * Returns an empty collection of the same category as coll. Used\n *   by cljs.core/empty.\n */\ncljs.core._empty \x3d (function cljs$core$_empty(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll);\n} else {\nreturn cljs$core$IEmptyableCollection$_empty$dyn_20497(coll);\n}\n});\n\n\n/**\n * Protocol for adding to a collection.\n * @interface\n */\ncljs.core.ICollection \x3d function(){};\n\nvar cljs$core$ICollection$_conj$dyn_20503 \x3d (function (coll,o){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._conj[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,o) : m__5351__auto__.call(null, coll,o));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._conj[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,o) : m__5349__auto__.call(null, coll,o));\n} else {\nthrow cljs.core.missing_protocol(\x22ICollection.-conj\x22,coll);\n}\n}\n});\n/**\n * Returns a new collection of coll with o added to it. The new item\n *   should be added to the most efficient place, e.g.\n *   (conj [1 2 3 4] 5) \x3d\x3e [1 2 3 4 5]\n *   (conj \x27(2 3 4 5) 1) \x3d\x3e \x27(1 2 3 4 5)\n */\ncljs.core._conj \x3d (function cljs$core$_conj(coll,o){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ICollection$_conj$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$ICollection$_conj$arity$2(coll,o);\n} else {\nreturn cljs$core$ICollection$_conj$dyn_20503(coll,o);\n}\n});\n\n\n/**\n * Protocol for collections to provide indexed-based access to their items.\n * @interface\n */\ncljs.core.IIndexed \x3d function(){};\n\nvar cljs$core$IIndexed$_nth$dyn_20514 \x3d (function() {\nvar G__20515 \x3d null;\nvar G__20515__2 \x3d (function (coll,n){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._nth[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,n) : m__5351__auto__.call(null, coll,n));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._nth[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,n) : m__5349__auto__.call(null, coll,n));\n} else {\nthrow cljs.core.missing_protocol(\x22IIndexed.-nth\x22,coll);\n}\n}\n});\nvar G__20515__3 \x3d (function (coll,n,not_found){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._nth[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(coll,n,not_found) : m__5351__auto__.call(null, coll,n,not_found));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._nth[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(coll,n,not_found) : m__5349__auto__.call(null, coll,n,not_found));\n} else {\nthrow cljs.core.missing_protocol(\x22IIndexed.-nth\x22,coll);\n}\n}\n});\nG__20515 \x3d function(coll,n,not_found){\nswitch(arguments.length){\ncase 2:\nreturn G__20515__2.call(this,coll,n);\ncase 3:\nreturn G__20515__3.call(this,coll,n,not_found);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__20515.cljs$core$IFn$_invoke$arity$2 \x3d G__20515__2;\nG__20515.cljs$core$IFn$_invoke$arity$3 \x3d G__20515__3;\nreturn G__20515;\n})()\n;\n/**\n * Returns the value at the index n in the collection coll.\n *   Returns not-found if index n is out of bounds and not-found is supplied.\n */\ncljs.core._nth \x3d (function cljs$core$_nth(var_args){\nvar G__17454 \x3d arguments.length;\nswitch (G__17454) {\ncase 2:\nreturn cljs.core._nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core._nth.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core._nth.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,n){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IIndexed$_nth$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$IIndexed$_nth$arity$2(coll,n);\n} else {\nreturn cljs$core$IIndexed$_nth$dyn_20514(coll,n);\n}\n}));\n\n(cljs.core._nth.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,n,not_found){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IIndexed$_nth$arity$3 \x3d\x3d null)))))){\nreturn coll.cljs$core$IIndexed$_nth$arity$3(coll,n,not_found);\n} else {\nreturn cljs$core$IIndexed$_nth$dyn_20514(coll,n,not_found);\n}\n}));\n\n(cljs.core._nth.cljs$lang$maxFixedArity \x3d 3);\n\n\n\n/**\n * Marker protocol indicating an array sequence.\n * @interface\n */\ncljs.core.ASeq \x3d function(){};\n\n\n/**\n * Protocol for collections to provide access to their items as sequences.\n * @interface\n */\ncljs.core.ISeq \x3d function(){};\n\nvar cljs$core$ISeq$_first$dyn_20530 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._first[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._first[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22ISeq.-first\x22,coll);\n}\n}\n});\n/**\n * Returns the first item in the collection coll. Used by cljs.core/first.\n */\ncljs.core._first \x3d (function cljs$core$_first(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ISeq$_first$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$ISeq$_first$arity$1(coll);\n} else {\nreturn cljs$core$ISeq$_first$dyn_20530(coll);\n}\n});\n\nvar cljs$core$ISeq$_rest$dyn_20540 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._rest[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._rest[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22ISeq.-rest\x22,coll);\n}\n}\n});\n/**\n * Returns a new collection of coll without the first item. It should\n *   always return a seq, e.g.\n *   (rest []) \x3d\x3e ()\n *   (rest nil) \x3d\x3e ()\n */\ncljs.core._rest \x3d (function cljs$core$_rest(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ISeq$_rest$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$ISeq$_rest$arity$1(coll);\n} else {\nreturn cljs$core$ISeq$_rest$dyn_20540(coll);\n}\n});\n\n\n/**\n * Protocol for accessing the next items of a collection.\n * @interface\n */\ncljs.core.INext \x3d function(){};\n\nvar cljs$core$INext$_next$dyn_20543 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._next[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._next[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22INext.-next\x22,coll);\n}\n}\n});\n/**\n * Returns a new collection of coll without the first item. In contrast to\n *   rest, it should return nil if there are no more items, e.g.\n *   (next []) \x3d\x3e nil\n *   (next nil) \x3d\x3e nil\n */\ncljs.core._next \x3d (function cljs$core$_next(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$INext$_next$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$INext$_next$arity$1(coll);\n} else {\nreturn cljs$core$INext$_next$dyn_20543(coll);\n}\n});\n\n\n/**\n * Protocol for looking up a value in a data structure.\n * @interface\n */\ncljs.core.ILookup \x3d function(){};\n\nvar cljs$core$ILookup$_lookup$dyn_20548 \x3d (function() {\nvar G__20549 \x3d null;\nvar G__20549__2 \x3d (function (o,k){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._lookup[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(o,k) : m__5351__auto__.call(null, o,k));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._lookup[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(o,k) : m__5349__auto__.call(null, o,k));\n} else {\nthrow cljs.core.missing_protocol(\x22ILookup.-lookup\x22,o);\n}\n}\n});\nvar G__20549__3 \x3d (function (o,k,not_found){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._lookup[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(o,k,not_found) : m__5351__auto__.call(null, o,k,not_found));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._lookup[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(o,k,not_found) : m__5349__auto__.call(null, o,k,not_found));\n} else {\nthrow cljs.core.missing_protocol(\x22ILookup.-lookup\x22,o);\n}\n}\n});\nG__20549 \x3d function(o,k,not_found){\nswitch(arguments.length){\ncase 2:\nreturn G__20549__2.call(this,o,k);\ncase 3:\nreturn G__20549__3.call(this,o,k,not_found);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__20549.cljs$core$IFn$_invoke$arity$2 \x3d G__20549__2;\nG__20549.cljs$core$IFn$_invoke$arity$3 \x3d G__20549__3;\nreturn G__20549;\n})()\n;\n/**\n * Use k to look up a value in o. If not-found is supplied and k is not\n *   a valid value that can be used for look up, not-found is returned.\n */\ncljs.core._lookup \x3d (function cljs$core$_lookup(var_args){\nvar G__17456 \x3d arguments.length;\nswitch (G__17456) {\ncase 2:\nreturn cljs.core._lookup.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core._lookup.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core._lookup.cljs$core$IFn$_invoke$arity$2 \x3d (function (o,k){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$ILookup$_lookup$arity$2 \x3d\x3d null)))))){\nreturn o.cljs$core$ILookup$_lookup$arity$2(o,k);\n} else {\nreturn cljs$core$ILookup$_lookup$dyn_20548(o,k);\n}\n}));\n\n(cljs.core._lookup.cljs$core$IFn$_invoke$arity$3 \x3d (function (o,k,not_found){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$ILookup$_lookup$arity$3 \x3d\x3d null)))))){\nreturn o.cljs$core$ILookup$_lookup$arity$3(o,k,not_found);\n} else {\nreturn cljs$core$ILookup$_lookup$dyn_20548(o,k,not_found);\n}\n}));\n\n(cljs.core._lookup.cljs$lang$maxFixedArity \x3d 3);\n\n\n\n/**\n * Protocol for adding associativity to collections.\n * @interface\n */\ncljs.core.IAssociative \x3d function(){};\n\nvar cljs$core$IAssociative$_contains_key_QMARK_$dyn_20562 \x3d (function (coll,k){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._contains_key_QMARK_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__5351__auto__.call(null, coll,k));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._contains_key_QMARK_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__5349__auto__.call(null, coll,k));\n} else {\nthrow cljs.core.missing_protocol(\x22IAssociative.-contains-key?\x22,coll);\n}\n}\n});\n/**\n * Returns true if k is a key in coll.\n */\ncljs.core._contains_key_QMARK_ \x3d (function cljs$core$_contains_key_QMARK_(coll,k){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll,k);\n} else {\nreturn cljs$core$IAssociative$_contains_key_QMARK_$dyn_20562(coll,k);\n}\n});\n\nvar cljs$core$IAssociative$_assoc$dyn_20573 \x3d (function (coll,k,v){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._assoc[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,v) : m__5351__auto__.call(null, coll,k,v));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._assoc[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,v) : m__5349__auto__.call(null, coll,k,v));\n} else {\nthrow cljs.core.missing_protocol(\x22IAssociative.-assoc\x22,coll);\n}\n}\n});\n/**\n * Returns a new collection of coll with a mapping from key k to\n *   value v added to it.\n */\ncljs.core._assoc \x3d (function cljs$core$_assoc(coll,k,v){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IAssociative$_assoc$arity$3 \x3d\x3d null)))))){\nreturn coll.cljs$core$IAssociative$_assoc$arity$3(coll,k,v);\n} else {\nreturn cljs$core$IAssociative$_assoc$dyn_20573(coll,k,v);\n}\n});\n\n\n/**\n * Protocol for implementing entry finding in collections.\n * @interface\n */\ncljs.core.IFind \x3d function(){};\n\nvar cljs$core$IFind$_find$dyn_20578 \x3d (function (coll,k){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._find[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__5351__auto__.call(null, coll,k));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._find[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__5349__auto__.call(null, coll,k));\n} else {\nthrow cljs.core.missing_protocol(\x22IFind.-find\x22,coll);\n}\n}\n});\n/**\n * Returns the map entry for key, or nil if key not present.\n */\ncljs.core._find \x3d (function cljs$core$_find(coll,k){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IFind$_find$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$IFind$_find$arity$2(coll,k);\n} else {\nreturn cljs$core$IFind$_find$dyn_20578(coll,k);\n}\n});\n\n\n/**\n * Protocol for adding mapping functionality to collections.\n * @interface\n */\ncljs.core.IMap \x3d function(){};\n\nvar cljs$core$IMap$_dissoc$dyn_20582 \x3d (function (coll,k){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._dissoc[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__5351__auto__.call(null, coll,k));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._dissoc[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__5349__auto__.call(null, coll,k));\n} else {\nthrow cljs.core.missing_protocol(\x22IMap.-dissoc\x22,coll);\n}\n}\n});\n/**\n * Returns a new collection of coll without the mapping for key k.\n */\ncljs.core._dissoc \x3d (function cljs$core$_dissoc(coll,k){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IMap$_dissoc$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$IMap$_dissoc$arity$2(coll,k);\n} else {\nreturn cljs$core$IMap$_dissoc$dyn_20582(coll,k);\n}\n});\n\n\n/**\n * Protocol for examining a map entry.\n * @interface\n */\ncljs.core.IMapEntry \x3d function(){};\n\nvar cljs$core$IMapEntry$_key$dyn_20585 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._key[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._key[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IMapEntry.-key\x22,coll);\n}\n}\n});\n/**\n * Returns the key of the map entry.\n */\ncljs.core._key \x3d (function cljs$core$_key(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IMapEntry$_key$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IMapEntry$_key$arity$1(coll);\n} else {\nreturn cljs$core$IMapEntry$_key$dyn_20585(coll);\n}\n});\n\nvar cljs$core$IMapEntry$_val$dyn_20587 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._val[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._val[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IMapEntry.-val\x22,coll);\n}\n}\n});\n/**\n * Returns the value of the map entry.\n */\ncljs.core._val \x3d (function cljs$core$_val(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IMapEntry$_val$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IMapEntry$_val$arity$1(coll);\n} else {\nreturn cljs$core$IMapEntry$_val$dyn_20587(coll);\n}\n});\n\n\n/**\n * Protocol for adding set functionality to a collection.\n * @interface\n */\ncljs.core.ISet \x3d function(){};\n\nvar cljs$core$ISet$_disjoin$dyn_20592 \x3d (function (coll,v){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._disjoin[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,v) : m__5351__auto__.call(null, coll,v));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._disjoin[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,v) : m__5349__auto__.call(null, coll,v));\n} else {\nthrow cljs.core.missing_protocol(\x22ISet.-disjoin\x22,coll);\n}\n}\n});\n/**\n * Returns a new collection of coll that does not contain v.\n */\ncljs.core._disjoin \x3d (function cljs$core$_disjoin(coll,v){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ISet$_disjoin$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$ISet$_disjoin$arity$2(coll,v);\n} else {\nreturn cljs$core$ISet$_disjoin$dyn_20592(coll,v);\n}\n});\n\n\n/**\n * Protocol for collections to provide access to their items as stacks. The top\n *   of the stack should be accessed in the most efficient way for the different\n *   data structures.\n * @interface\n */\ncljs.core.IStack \x3d function(){};\n\nvar cljs$core$IStack$_peek$dyn_20597 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._peek[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._peek[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IStack.-peek\x22,coll);\n}\n}\n});\n/**\n * Returns the item from the top of the stack. Is used by cljs.core/peek.\n */\ncljs.core._peek \x3d (function cljs$core$_peek(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IStack$_peek$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IStack$_peek$arity$1(coll);\n} else {\nreturn cljs$core$IStack$_peek$dyn_20597(coll);\n}\n});\n\nvar cljs$core$IStack$_pop$dyn_20607 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._pop[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._pop[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IStack.-pop\x22,coll);\n}\n}\n});\n/**\n * Returns a new stack without the item on top of the stack. Is used\n *   by cljs.core/pop.\n */\ncljs.core._pop \x3d (function cljs$core$_pop(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IStack$_pop$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IStack$_pop$arity$1(coll);\n} else {\nreturn cljs$core$IStack$_pop$dyn_20607(coll);\n}\n});\n\n\n/**\n * Protocol for adding vector functionality to collections.\n * @interface\n */\ncljs.core.IVector \x3d function(){};\n\nvar cljs$core$IVector$_assoc_n$dyn_20610 \x3d (function (coll,n,val){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._assoc_n[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(coll,n,val) : m__5351__auto__.call(null, coll,n,val));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._assoc_n[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(coll,n,val) : m__5349__auto__.call(null, coll,n,val));\n} else {\nthrow cljs.core.missing_protocol(\x22IVector.-assoc-n\x22,coll);\n}\n}\n});\n/**\n * Returns a new vector with value val added at position n.\n */\ncljs.core._assoc_n \x3d (function cljs$core$_assoc_n(coll,n,val){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IVector$_assoc_n$arity$3 \x3d\x3d null)))))){\nreturn coll.cljs$core$IVector$_assoc_n$arity$3(coll,n,val);\n} else {\nreturn cljs$core$IVector$_assoc_n$dyn_20610(coll,n,val);\n}\n});\n\n\n/**\n * Protocol for adding dereference functionality to a reference.\n * @interface\n */\ncljs.core.IDeref \x3d function(){};\n\nvar cljs$core$IDeref$_deref$dyn_20615 \x3d (function (o){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._deref[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5351__auto__.call(null, o));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._deref[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5349__auto__.call(null, o));\n} else {\nthrow cljs.core.missing_protocol(\x22IDeref.-deref\x22,o);\n}\n}\n});\n/**\n * Returns the value of the reference o.\n */\ncljs.core._deref \x3d (function cljs$core$_deref(o){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IDeref$_deref$arity$1 \x3d\x3d null)))))){\nreturn o.cljs$core$IDeref$_deref$arity$1(o);\n} else {\nreturn cljs$core$IDeref$_deref$dyn_20615(o);\n}\n});\n\n\n/**\n * @interface\n */\ncljs.core.IDerefWithTimeout \x3d function(){};\n\nvar cljs$core$IDerefWithTimeout$_deref_with_timeout$dyn_20617 \x3d (function (o,msec,timeout_val){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._deref_with_timeout[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(o,msec,timeout_val) : m__5351__auto__.call(null, o,msec,timeout_val));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._deref_with_timeout[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(o,msec,timeout_val) : m__5349__auto__.call(null, o,msec,timeout_val));\n} else {\nthrow cljs.core.missing_protocol(\x22IDerefWithTimeout.-deref-with-timeout\x22,o);\n}\n}\n});\ncljs.core._deref_with_timeout \x3d (function cljs$core$_deref_with_timeout(o,msec,timeout_val){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3 \x3d\x3d null)))))){\nreturn o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o,msec,timeout_val);\n} else {\nreturn cljs$core$IDerefWithTimeout$_deref_with_timeout$dyn_20617(o,msec,timeout_val);\n}\n});\n\n\n/**\n * Protocol for accessing the metadata of an object.\n * @interface\n */\ncljs.core.IMeta \x3d function(){};\n\nvar cljs$core$IMeta$_meta$dyn_20623 \x3d (function (o){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._meta[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5351__auto__.call(null, o));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._meta[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5349__auto__.call(null, o));\n} else {\nthrow cljs.core.missing_protocol(\x22IMeta.-meta\x22,o);\n}\n}\n});\n/**\n * Returns the metadata of object o.\n */\ncljs.core._meta \x3d (function cljs$core$_meta(o){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IMeta$_meta$arity$1 \x3d\x3d null)))))){\nreturn o.cljs$core$IMeta$_meta$arity$1(o);\n} else {\nreturn cljs$core$IMeta$_meta$dyn_20623(o);\n}\n});\n\n\n/**\n * Protocol for adding metadata to an object.\n * @interface\n */\ncljs.core.IWithMeta \x3d function(){};\n\nvar cljs$core$IWithMeta$_with_meta$dyn_20632 \x3d (function (o,meta){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._with_meta[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(o,meta) : m__5351__auto__.call(null, o,meta));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._with_meta[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(o,meta) : m__5349__auto__.call(null, o,meta));\n} else {\nthrow cljs.core.missing_protocol(\x22IWithMeta.-with-meta\x22,o);\n}\n}\n});\n/**\n * Returns a new object with value of o and metadata meta added to it.\n */\ncljs.core._with_meta \x3d (function cljs$core$_with_meta(o,meta){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IWithMeta$_with_meta$arity$2 \x3d\x3d null)))))){\nreturn o.cljs$core$IWithMeta$_with_meta$arity$2(o,meta);\n} else {\nreturn cljs$core$IWithMeta$_with_meta$dyn_20632(o,meta);\n}\n});\n\n\n/**\n * Protocol for seq types that can reduce themselves.\n *   Called by cljs.core/reduce.\n * @interface\n */\ncljs.core.IReduce \x3d function(){};\n\nvar cljs$core$IReduce$_reduce$dyn_20635 \x3d (function() {\nvar G__20636 \x3d null;\nvar G__20636__2 \x3d (function (coll,f){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._reduce[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,f) : m__5351__auto__.call(null, coll,f));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._reduce[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,f) : m__5349__auto__.call(null, coll,f));\n} else {\nthrow cljs.core.missing_protocol(\x22IReduce.-reduce\x22,coll);\n}\n}\n});\nvar G__20636__3 \x3d (function (coll,f,start){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._reduce[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(coll,f,start) : m__5351__auto__.call(null, coll,f,start));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._reduce[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(coll,f,start) : m__5349__auto__.call(null, coll,f,start));\n} else {\nthrow cljs.core.missing_protocol(\x22IReduce.-reduce\x22,coll);\n}\n}\n});\nG__20636 \x3d function(coll,f,start){\nswitch(arguments.length){\ncase 2:\nreturn G__20636__2.call(this,coll,f);\ncase 3:\nreturn G__20636__3.call(this,coll,f,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__20636.cljs$core$IFn$_invoke$arity$2 \x3d G__20636__2;\nG__20636.cljs$core$IFn$_invoke$arity$3 \x3d G__20636__3;\nreturn G__20636;\n})()\n;\n/**\n * f should be a function of 2 arguments. If start is not supplied,\n *   returns the result of applying f to the first 2 items in coll, then\n *   applying f to that result and the 3rd item, etc.\n */\ncljs.core._reduce \x3d (function cljs$core$_reduce(var_args){\nvar G__17458 \x3d arguments.length;\nswitch (G__17458) {\ncase 2:\nreturn cljs.core._reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core._reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core._reduce.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,f){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IReduce$_reduce$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$IReduce$_reduce$arity$2(coll,f);\n} else {\nreturn cljs$core$IReduce$_reduce$dyn_20635(coll,f);\n}\n}));\n\n(cljs.core._reduce.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,f,start){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IReduce$_reduce$arity$3 \x3d\x3d null)))))){\nreturn coll.cljs$core$IReduce$_reduce$arity$3(coll,f,start);\n} else {\nreturn cljs$core$IReduce$_reduce$dyn_20635(coll,f,start);\n}\n}));\n\n(cljs.core._reduce.cljs$lang$maxFixedArity \x3d 3);\n\n\n\n/**\n * Protocol for associative types that can reduce themselves\n *   via a function of key and val. Called by cljs.core/reduce-kv.\n * @interface\n */\ncljs.core.IKVReduce \x3d function(){};\n\nvar cljs$core$IKVReduce$_kv_reduce$dyn_20648 \x3d (function (coll,f,init){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._kv_reduce[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(coll,f,init) : m__5351__auto__.call(null, coll,f,init));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._kv_reduce[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(coll,f,init) : m__5349__auto__.call(null, coll,f,init));\n} else {\nthrow cljs.core.missing_protocol(\x22IKVReduce.-kv-reduce\x22,coll);\n}\n}\n});\n/**\n * Reduces an associative collection and returns the result. f should be\n *   a function that takes three arguments.\n */\ncljs.core._kv_reduce \x3d (function cljs$core$_kv_reduce(coll,f,init){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d\x3d null)))))){\nreturn coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll,f,init);\n} else {\nreturn cljs$core$IKVReduce$_kv_reduce$dyn_20648(coll,f,init);\n}\n});\n\n\n/**\n * Protocol for adding value comparison functionality to a type.\n * @interface\n */\ncljs.core.IEquiv \x3d function(){};\n\nvar cljs$core$IEquiv$_equiv$dyn_20657 \x3d (function (o,other){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._equiv[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(o,other) : m__5351__auto__.call(null, o,other));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._equiv[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(o,other) : m__5349__auto__.call(null, o,other));\n} else {\nthrow cljs.core.missing_protocol(\x22IEquiv.-equiv\x22,o);\n}\n}\n});\n/**\n * Returns true if o and other are equal, false otherwise.\n */\ncljs.core._equiv \x3d (function cljs$core$_equiv(o,other){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IEquiv$_equiv$arity$2 \x3d\x3d null)))))){\nreturn o.cljs$core$IEquiv$_equiv$arity$2(o,other);\n} else {\nreturn cljs$core$IEquiv$_equiv$dyn_20657(o,other);\n}\n});\n\n\n/**\n * Protocol for adding hashing functionality to a type.\n * @interface\n */\ncljs.core.IHash \x3d function(){};\n\nvar cljs$core$IHash$_hash$dyn_20662 \x3d (function (o){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._hash[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5351__auto__.call(null, o));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._hash[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5349__auto__.call(null, o));\n} else {\nthrow cljs.core.missing_protocol(\x22IHash.-hash\x22,o);\n}\n}\n});\n/**\n * Returns the hash code of o.\n */\ncljs.core._hash \x3d (function cljs$core$_hash(o){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IHash$_hash$arity$1 \x3d\x3d null)))))){\nreturn o.cljs$core$IHash$_hash$arity$1(o);\n} else {\nreturn cljs$core$IHash$_hash$dyn_20662(o);\n}\n});\n\n\n/**\n * Protocol for adding the ability to a type to be transformed into a sequence.\n * @interface\n */\ncljs.core.ISeqable \x3d function(){};\n\nvar cljs$core$ISeqable$_seq$dyn_20665 \x3d (function (o){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._seq[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5351__auto__.call(null, o));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._seq[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5349__auto__.call(null, o));\n} else {\nthrow cljs.core.missing_protocol(\x22ISeqable.-seq\x22,o);\n}\n}\n});\n/**\n * Returns a seq of o, or nil if o is empty.\n */\ncljs.core._seq \x3d (function cljs$core$_seq(o){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$ISeqable$_seq$arity$1 \x3d\x3d null)))))){\nreturn o.cljs$core$ISeqable$_seq$arity$1(o);\n} else {\nreturn cljs$core$ISeqable$_seq$dyn_20665(o);\n}\n});\n\n\n/**\n * Marker interface indicating a persistent collection of sequential items\n * @interface\n */\ncljs.core.ISequential \x3d function(){};\n\n\n/**\n * Marker interface indicating a persistent list\n * @interface\n */\ncljs.core.IList \x3d function(){};\n\n\n/**\n * Marker interface indicating a record object\n * @interface\n */\ncljs.core.IRecord \x3d function(){};\n\n\n/**\n * Protocol for reversing a seq.\n * @interface\n */\ncljs.core.IReversible \x3d function(){};\n\nvar cljs$core$IReversible$_rseq$dyn_20671 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._rseq[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._rseq[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IReversible.-rseq\x22,coll);\n}\n}\n});\n/**\n * Returns a seq of the items in coll in reversed order.\n */\ncljs.core._rseq \x3d (function cljs$core$_rseq(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IReversible$_rseq$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IReversible$_rseq$arity$1(coll);\n} else {\nreturn cljs$core$IReversible$_rseq$dyn_20671(coll);\n}\n});\n\n\n/**\n * Protocol for a collection which can represent their items\n *   in a sorted manner. \n * @interface\n */\ncljs.core.ISorted \x3d function(){};\n\nvar cljs$core$ISorted$_sorted_seq$dyn_20681 \x3d (function (coll,ascending_QMARK_){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._sorted_seq[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,ascending_QMARK_) : m__5351__auto__.call(null, coll,ascending_QMARK_));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._sorted_seq[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,ascending_QMARK_) : m__5349__auto__.call(null, coll,ascending_QMARK_));\n} else {\nthrow cljs.core.missing_protocol(\x22ISorted.-sorted-seq\x22,coll);\n}\n}\n});\n/**\n * Returns a sorted seq from coll in either ascending or descending order.\n */\ncljs.core._sorted_seq \x3d (function cljs$core$_sorted_seq(coll,ascending_QMARK_){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ISorted$_sorted_seq$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$ISorted$_sorted_seq$arity$2(coll,ascending_QMARK_);\n} else {\nreturn cljs$core$ISorted$_sorted_seq$dyn_20681(coll,ascending_QMARK_);\n}\n});\n\nvar cljs$core$ISorted$_sorted_seq_from$dyn_20694 \x3d (function (coll,k,ascending_QMARK_){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._sorted_seq_from[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,ascending_QMARK_) : m__5351__auto__.call(null, coll,k,ascending_QMARK_));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._sorted_seq_from[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,ascending_QMARK_) : m__5349__auto__.call(null, coll,k,ascending_QMARK_));\n} else {\nthrow cljs.core.missing_protocol(\x22ISorted.-sorted-seq-from\x22,coll);\n}\n}\n});\n/**\n * Returns a sorted seq from coll in either ascending or descending order.\n *   If ascending is true, the result should contain all items which are \x3e or \x3e\x3d\n *   than k. If ascending is false, the result should contain all items which\n *   are \x3c or \x3c\x3d than k, e.g.\n *   (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 true) \x3d\x3e (3 4 5)\n *   (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 false) \x3d\x3e (3 2 1)\n */\ncljs.core._sorted_seq_from \x3d (function cljs$core$_sorted_seq_from(coll,k,ascending_QMARK_){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ISorted$_sorted_seq_from$arity$3 \x3d\x3d null)))))){\nreturn coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll,k,ascending_QMARK_);\n} else {\nreturn cljs$core$ISorted$_sorted_seq_from$dyn_20694(coll,k,ascending_QMARK_);\n}\n});\n\nvar cljs$core$ISorted$_entry_key$dyn_20710 \x3d (function (coll,entry){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._entry_key[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,entry) : m__5351__auto__.call(null, coll,entry));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._entry_key[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,entry) : m__5349__auto__.call(null, coll,entry));\n} else {\nthrow cljs.core.missing_protocol(\x22ISorted.-entry-key\x22,coll);\n}\n}\n});\n/**\n * Returns the key for entry.\n */\ncljs.core._entry_key \x3d (function cljs$core$_entry_key(coll,entry){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ISorted$_entry_key$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$ISorted$_entry_key$arity$2(coll,entry);\n} else {\nreturn cljs$core$ISorted$_entry_key$dyn_20710(coll,entry);\n}\n});\n\nvar cljs$core$ISorted$_comparator$dyn_20713 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._comparator[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._comparator[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22ISorted.-comparator\x22,coll);\n}\n}\n});\n/**\n * Returns the comparator for coll.\n */\ncljs.core._comparator \x3d (function cljs$core$_comparator(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$ISorted$_comparator$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$ISorted$_comparator$arity$1(coll);\n} else {\nreturn cljs$core$ISorted$_comparator$dyn_20713(coll);\n}\n});\n\n\n/**\n * Protocol for writing. Currently only implemented by StringBufferWriter.\n * @interface\n */\ncljs.core.IWriter \x3d function(){};\n\nvar cljs$core$IWriter$_write$dyn_20717 \x3d (function (writer,s){\nvar x__5350__auto__ \x3d (((writer \x3d\x3d null))?null:writer);\nvar m__5351__auto__ \x3d (cljs.core._write[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(writer,s) : m__5351__auto__.call(null, writer,s));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._write[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(writer,s) : m__5349__auto__.call(null, writer,s));\n} else {\nthrow cljs.core.missing_protocol(\x22IWriter.-write\x22,writer);\n}\n}\n});\n/**\n * Writes s with writer and returns the result.\n */\ncljs.core._write \x3d (function cljs$core$_write(writer,s){\nif((((!((writer \x3d\x3d null)))) \x26\x26 ((!((writer.cljs$core$IWriter$_write$arity$2 \x3d\x3d null)))))){\nreturn writer.cljs$core$IWriter$_write$arity$2(writer,s);\n} else {\nreturn cljs$core$IWriter$_write$dyn_20717(writer,s);\n}\n});\n\nvar cljs$core$IWriter$_flush$dyn_20721 \x3d (function (writer){\nvar x__5350__auto__ \x3d (((writer \x3d\x3d null))?null:writer);\nvar m__5351__auto__ \x3d (cljs.core._flush[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(writer) : m__5351__auto__.call(null, writer));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._flush[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(writer) : m__5349__auto__.call(null, writer));\n} else {\nthrow cljs.core.missing_protocol(\x22IWriter.-flush\x22,writer);\n}\n}\n});\n/**\n * Flush writer.\n */\ncljs.core._flush \x3d (function cljs$core$_flush(writer){\nif((((!((writer \x3d\x3d null)))) \x26\x26 ((!((writer.cljs$core$IWriter$_flush$arity$1 \x3d\x3d null)))))){\nreturn writer.cljs$core$IWriter$_flush$arity$1(writer);\n} else {\nreturn cljs$core$IWriter$_flush$dyn_20721(writer);\n}\n});\n\n\n/**\n * The old IPrintable protocol\x27s implementation consisted of building a giant\n * list of strings to concatenate.  This involved lots of concat calls,\n * intermediate vectors, and lazy-seqs, and was very slow in some older JS\n * engines.  IPrintWithWriter implements printing via the IWriter protocol, so it\n * be implemented efficiently in terms of e.g. a StringBuffer append.\n * @interface\n */\ncljs.core.IPrintWithWriter \x3d function(){};\n\nvar cljs$core$IPrintWithWriter$_pr_writer$dyn_20724 \x3d (function (o,writer,opts){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._pr_writer[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(o,writer,opts) : m__5351__auto__.call(null, o,writer,opts));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._pr_writer[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(o,writer,opts) : m__5349__auto__.call(null, o,writer,opts));\n} else {\nthrow cljs.core.missing_protocol(\x22IPrintWithWriter.-pr-writer\x22,o);\n}\n}\n});\ncljs.core._pr_writer \x3d (function cljs$core$_pr_writer(o,writer,opts){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d\x3d null)))))){\nreturn o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o,writer,opts);\n} else {\nreturn cljs$core$IPrintWithWriter$_pr_writer$dyn_20724(o,writer,opts);\n}\n});\n\n\n/**\n * Protocol for types which can have a deferred realization. Currently only\n *   implemented by Delay and LazySeq.\n * @interface\n */\ncljs.core.IPending \x3d function(){};\n\nvar cljs$core$IPending$_realized_QMARK_$dyn_20732 \x3d (function (x){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (cljs.core._realized_QMARK_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5351__auto__.call(null, x));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._realized_QMARK_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5349__auto__.call(null, x));\n} else {\nthrow cljs.core.missing_protocol(\x22IPending.-realized?\x22,x);\n}\n}\n});\n/**\n * Returns true if a value for x has been produced, false otherwise.\n */\ncljs.core._realized_QMARK_ \x3d (function cljs$core$_realized_QMARK_(x){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.cljs$core$IPending$_realized_QMARK_$arity$1 \x3d\x3d null)))))){\nreturn x.cljs$core$IPending$_realized_QMARK_$arity$1(x);\n} else {\nreturn cljs$core$IPending$_realized_QMARK_$dyn_20732(x);\n}\n});\n\n\n/**\n * Protocol for types that can be watched. Currently only implemented by Atom.\n * @interface\n */\ncljs.core.IWatchable \x3d function(){};\n\nvar cljs$core$IWatchable$_notify_watches$dyn_20735 \x3d (function (this$,oldval,newval){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._notify_watches[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(this$,oldval,newval) : m__5351__auto__.call(null, this$,oldval,newval));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._notify_watches[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(this$,oldval,newval) : m__5349__auto__.call(null, this$,oldval,newval));\n} else {\nthrow cljs.core.missing_protocol(\x22IWatchable.-notify-watches\x22,this$);\n}\n}\n});\n/**\n * Calls all watchers with this, oldval and newval.\n */\ncljs.core._notify_watches \x3d (function cljs$core$_notify_watches(this$,oldval,newval){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IWatchable$_notify_watches$arity$3 \x3d\x3d null)))))){\nreturn this$.cljs$core$IWatchable$_notify_watches$arity$3(this$,oldval,newval);\n} else {\nreturn cljs$core$IWatchable$_notify_watches$dyn_20735(this$,oldval,newval);\n}\n});\n\nvar cljs$core$IWatchable$_add_watch$dyn_20740 \x3d (function (this$,key,f){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._add_watch[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(this$,key,f) : m__5351__auto__.call(null, this$,key,f));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._add_watch[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(this$,key,f) : m__5349__auto__.call(null, this$,key,f));\n} else {\nthrow cljs.core.missing_protocol(\x22IWatchable.-add-watch\x22,this$);\n}\n}\n});\n/**\n * Adds a watcher function f to this. Keys must be unique per reference,\n *   and can be used to remove the watch with -remove-watch.\n */\ncljs.core._add_watch \x3d (function cljs$core$_add_watch(this$,key,f){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IWatchable$_add_watch$arity$3 \x3d\x3d null)))))){\nreturn this$.cljs$core$IWatchable$_add_watch$arity$3(this$,key,f);\n} else {\nreturn cljs$core$IWatchable$_add_watch$dyn_20740(this$,key,f);\n}\n});\n\nvar cljs$core$IWatchable$_remove_watch$dyn_20745 \x3d (function (this$,key){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core._remove_watch[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(this$,key) : m__5351__auto__.call(null, this$,key));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._remove_watch[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(this$,key) : m__5349__auto__.call(null, this$,key));\n} else {\nthrow cljs.core.missing_protocol(\x22IWatchable.-remove-watch\x22,this$);\n}\n}\n});\n/**\n * Removes watcher that corresponds to key from this.\n */\ncljs.core._remove_watch \x3d (function cljs$core$_remove_watch(this$,key){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$IWatchable$_remove_watch$arity$2 \x3d\x3d null)))))){\nreturn this$.cljs$core$IWatchable$_remove_watch$arity$2(this$,key);\n} else {\nreturn cljs$core$IWatchable$_remove_watch$dyn_20745(this$,key);\n}\n});\n\n\n/**\n * Protocol for collections which can transformed to transients.\n * @interface\n */\ncljs.core.IEditableCollection \x3d function(){};\n\nvar cljs$core$IEditableCollection$_as_transient$dyn_20750 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._as_transient[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._as_transient[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IEditableCollection.-as-transient\x22,coll);\n}\n}\n});\n/**\n * Returns a new, transient version of the collection, in constant time.\n */\ncljs.core._as_transient \x3d (function cljs$core$_as_transient(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IEditableCollection$_as_transient$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll);\n} else {\nreturn cljs$core$IEditableCollection$_as_transient$dyn_20750(coll);\n}\n});\n\n\n/**\n * Protocol for adding basic functionality to transient collections.\n * @interface\n */\ncljs.core.ITransientCollection \x3d function(){};\n\nvar cljs$core$ITransientCollection$_conj_BANG_$dyn_20761 \x3d (function (tcoll,val){\nvar x__5350__auto__ \x3d (((tcoll \x3d\x3d null))?null:tcoll);\nvar m__5351__auto__ \x3d (cljs.core._conj_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,val) : m__5351__auto__.call(null, tcoll,val));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._conj_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,val) : m__5349__auto__.call(null, tcoll,val));\n} else {\nthrow cljs.core.missing_protocol(\x22ITransientCollection.-conj!\x22,tcoll);\n}\n}\n});\n/**\n * Adds value val to tcoll and returns tcoll.\n */\ncljs.core._conj_BANG_ \x3d (function cljs$core$_conj_BANG_(tcoll,val){\nif((((!((tcoll \x3d\x3d null)))) \x26\x26 ((!((tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2 \x3d\x3d null)))))){\nreturn tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll,val);\n} else {\nreturn cljs$core$ITransientCollection$_conj_BANG_$dyn_20761(tcoll,val);\n}\n});\n\nvar cljs$core$ITransientCollection$_persistent_BANG_$dyn_20771 \x3d (function (tcoll){\nvar x__5350__auto__ \x3d (((tcoll \x3d\x3d null))?null:tcoll);\nvar m__5351__auto__ \x3d (cljs.core._persistent_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(tcoll) : m__5351__auto__.call(null, tcoll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._persistent_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(tcoll) : m__5349__auto__.call(null, tcoll));\n} else {\nthrow cljs.core.missing_protocol(\x22ITransientCollection.-persistent!\x22,tcoll);\n}\n}\n});\n/**\n * Creates a persistent data structure from tcoll and returns it.\n */\ncljs.core._persistent_BANG_ \x3d (function cljs$core$_persistent_BANG_(tcoll){\nif((((!((tcoll \x3d\x3d null)))) \x26\x26 ((!((tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 \x3d\x3d null)))))){\nreturn tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll);\n} else {\nreturn cljs$core$ITransientCollection$_persistent_BANG_$dyn_20771(tcoll);\n}\n});\n\n\n/**\n * Protocol for adding associativity to transient collections.\n * @interface\n */\ncljs.core.ITransientAssociative \x3d function(){};\n\nvar cljs$core$ITransientAssociative$_assoc_BANG_$dyn_20784 \x3d (function (tcoll,key,val){\nvar x__5350__auto__ \x3d (((tcoll \x3d\x3d null))?null:tcoll);\nvar m__5351__auto__ \x3d (cljs.core._assoc_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(tcoll,key,val) : m__5351__auto__.call(null, tcoll,key,val));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._assoc_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(tcoll,key,val) : m__5349__auto__.call(null, tcoll,key,val));\n} else {\nthrow cljs.core.missing_protocol(\x22ITransientAssociative.-assoc!\x22,tcoll);\n}\n}\n});\n/**\n * Returns a new transient collection of tcoll with a mapping from key to\n *   val added to it.\n */\ncljs.core._assoc_BANG_ \x3d (function cljs$core$_assoc_BANG_(tcoll,key,val){\nif((((!((tcoll \x3d\x3d null)))) \x26\x26 ((!((tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 \x3d\x3d null)))))){\nreturn tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll,key,val);\n} else {\nreturn cljs$core$ITransientAssociative$_assoc_BANG_$dyn_20784(tcoll,key,val);\n}\n});\n\n\n/**\n * Protocol for adding mapping functionality to transient collections.\n * @interface\n */\ncljs.core.ITransientMap \x3d function(){};\n\nvar cljs$core$ITransientMap$_dissoc_BANG_$dyn_20800 \x3d (function (tcoll,key){\nvar x__5350__auto__ \x3d (((tcoll \x3d\x3d null))?null:tcoll);\nvar m__5351__auto__ \x3d (cljs.core._dissoc_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,key) : m__5351__auto__.call(null, tcoll,key));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._dissoc_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,key) : m__5349__auto__.call(null, tcoll,key));\n} else {\nthrow cljs.core.missing_protocol(\x22ITransientMap.-dissoc!\x22,tcoll);\n}\n}\n});\n/**\n * Returns a new transient collection of tcoll without the mapping for key.\n */\ncljs.core._dissoc_BANG_ \x3d (function cljs$core$_dissoc_BANG_(tcoll,key){\nif((((!((tcoll \x3d\x3d null)))) \x26\x26 ((!((tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 \x3d\x3d null)))))){\nreturn tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll,key);\n} else {\nreturn cljs$core$ITransientMap$_dissoc_BANG_$dyn_20800(tcoll,key);\n}\n});\n\n\n/**\n * Protocol for adding vector functionality to transient collections.\n * @interface\n */\ncljs.core.ITransientVector \x3d function(){};\n\nvar cljs$core$ITransientVector$_assoc_n_BANG_$dyn_20810 \x3d (function (tcoll,n,val){\nvar x__5350__auto__ \x3d (((tcoll \x3d\x3d null))?null:tcoll);\nvar m__5351__auto__ \x3d (cljs.core._assoc_n_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(tcoll,n,val) : m__5351__auto__.call(null, tcoll,n,val));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._assoc_n_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(tcoll,n,val) : m__5349__auto__.call(null, tcoll,n,val));\n} else {\nthrow cljs.core.missing_protocol(\x22ITransientVector.-assoc-n!\x22,tcoll);\n}\n}\n});\n/**\n * Returns tcoll with value val added at position n.\n */\ncljs.core._assoc_n_BANG_ \x3d (function cljs$core$_assoc_n_BANG_(tcoll,n,val){\nif((((!((tcoll \x3d\x3d null)))) \x26\x26 ((!((tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3 \x3d\x3d null)))))){\nreturn tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll,n,val);\n} else {\nreturn cljs$core$ITransientVector$_assoc_n_BANG_$dyn_20810(tcoll,n,val);\n}\n});\n\nvar cljs$core$ITransientVector$_pop_BANG_$dyn_20825 \x3d (function (tcoll){\nvar x__5350__auto__ \x3d (((tcoll \x3d\x3d null))?null:tcoll);\nvar m__5351__auto__ \x3d (cljs.core._pop_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(tcoll) : m__5351__auto__.call(null, tcoll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._pop_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(tcoll) : m__5349__auto__.call(null, tcoll));\n} else {\nthrow cljs.core.missing_protocol(\x22ITransientVector.-pop!\x22,tcoll);\n}\n}\n});\n/**\n * Returns tcoll with the last item removed from it.\n */\ncljs.core._pop_BANG_ \x3d (function cljs$core$_pop_BANG_(tcoll){\nif((((!((tcoll \x3d\x3d null)))) \x26\x26 ((!((tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1 \x3d\x3d null)))))){\nreturn tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll);\n} else {\nreturn cljs$core$ITransientVector$_pop_BANG_$dyn_20825(tcoll);\n}\n});\n\n\n/**\n * Protocol for adding set functionality to a transient collection.\n * @interface\n */\ncljs.core.ITransientSet \x3d function(){};\n\nvar cljs$core$ITransientSet$_disjoin_BANG_$dyn_20834 \x3d (function (tcoll,v){\nvar x__5350__auto__ \x3d (((tcoll \x3d\x3d null))?null:tcoll);\nvar m__5351__auto__ \x3d (cljs.core._disjoin_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,v) : m__5351__auto__.call(null, tcoll,v));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._disjoin_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,v) : m__5349__auto__.call(null, tcoll,v));\n} else {\nthrow cljs.core.missing_protocol(\x22ITransientSet.-disjoin!\x22,tcoll);\n}\n}\n});\n/**\n * Returns tcoll without v.\n */\ncljs.core._disjoin_BANG_ \x3d (function cljs$core$_disjoin_BANG_(tcoll,v){\nif((((!((tcoll \x3d\x3d null)))) \x26\x26 ((!((tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2 \x3d\x3d null)))))){\nreturn tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll,v);\n} else {\nreturn cljs$core$ITransientSet$_disjoin_BANG_$dyn_20834(tcoll,v);\n}\n});\n\n\n/**\n * Protocol for values that can be compared.\n * @interface\n */\ncljs.core.IComparable \x3d function(){};\n\nvar cljs$core$IComparable$_compare$dyn_20897 \x3d (function (x,y){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (cljs.core._compare[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(x,y) : m__5351__auto__.call(null, x,y));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._compare[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(x,y) : m__5349__auto__.call(null, x,y));\n} else {\nthrow cljs.core.missing_protocol(\x22IComparable.-compare\x22,x);\n}\n}\n});\n/**\n * Returns a negative number, zero, or a positive number when x is logically\n *   \x27less than\x27, \x27equal to\x27, or \x27greater than\x27 y.\n */\ncljs.core._compare \x3d (function cljs$core$_compare(x,y){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.cljs$core$IComparable$_compare$arity$2 \x3d\x3d null)))))){\nreturn x.cljs$core$IComparable$_compare$arity$2(x,y);\n} else {\nreturn cljs$core$IComparable$_compare$dyn_20897(x,y);\n}\n});\n\n\n/**\n * Protocol for accessing the items of a chunk.\n * @interface\n */\ncljs.core.IChunk \x3d function(){};\n\nvar cljs$core$IChunk$_drop_first$dyn_20911 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._drop_first[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._drop_first[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IChunk.-drop-first\x22,coll);\n}\n}\n});\n/**\n * Return a new chunk of coll with the first item removed.\n */\ncljs.core._drop_first \x3d (function cljs$core$_drop_first(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IChunk$_drop_first$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IChunk$_drop_first$arity$1(coll);\n} else {\nreturn cljs$core$IChunk$_drop_first$dyn_20911(coll);\n}\n});\n\n\n/**\n * Protocol for accessing a collection as sequential chunks.\n * @interface\n */\ncljs.core.IChunkedSeq \x3d function(){};\n\nvar cljs$core$IChunkedSeq$_chunked_first$dyn_20914 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._chunked_first[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._chunked_first[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IChunkedSeq.-chunked-first\x22,coll);\n}\n}\n});\n/**\n * Returns the first chunk in coll.\n */\ncljs.core._chunked_first \x3d (function cljs$core$_chunked_first(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IChunkedSeq$_chunked_first$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll);\n} else {\nreturn cljs$core$IChunkedSeq$_chunked_first$dyn_20914(coll);\n}\n});\n\nvar cljs$core$IChunkedSeq$_chunked_rest$dyn_20917 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._chunked_rest[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._chunked_rest[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IChunkedSeq.-chunked-rest\x22,coll);\n}\n}\n});\n/**\n * Return a new collection of coll with the first chunk removed.\n */\ncljs.core._chunked_rest \x3d (function cljs$core$_chunked_rest(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll);\n} else {\nreturn cljs$core$IChunkedSeq$_chunked_rest$dyn_20917(coll);\n}\n});\n\n\n/**\n * Protocol for accessing the chunks of a collection.\n * @interface\n */\ncljs.core.IChunkedNext \x3d function(){};\n\nvar cljs$core$IChunkedNext$_chunked_next$dyn_20924 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._chunked_next[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._chunked_next[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IChunkedNext.-chunked-next\x22,coll);\n}\n}\n});\n/**\n * Returns a new collection of coll without the first chunk.\n */\ncljs.core._chunked_next \x3d (function cljs$core$_chunked_next(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IChunkedNext$_chunked_next$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll);\n} else {\nreturn cljs$core$IChunkedNext$_chunked_next$dyn_20924(coll);\n}\n});\n\n\n/**\n * Protocol for adding a name.\n * @interface\n */\ncljs.core.INamed \x3d function(){};\n\nvar cljs$core$INamed$_name$dyn_20939 \x3d (function (x){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (cljs.core._name[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5351__auto__.call(null, x));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._name[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5349__auto__.call(null, x));\n} else {\nthrow cljs.core.missing_protocol(\x22INamed.-name\x22,x);\n}\n}\n});\n/**\n * Returns the name String of x.\n */\ncljs.core._name \x3d (function cljs$core$_name(x){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.cljs$core$INamed$_name$arity$1 \x3d\x3d null)))))){\nreturn x.cljs$core$INamed$_name$arity$1(x);\n} else {\nreturn cljs$core$INamed$_name$dyn_20939(x);\n}\n});\n\nvar cljs$core$INamed$_namespace$dyn_20944 \x3d (function (x){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (cljs.core._namespace[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5351__auto__.call(null, x));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._namespace[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5349__auto__.call(null, x));\n} else {\nthrow cljs.core.missing_protocol(\x22INamed.-namespace\x22,x);\n}\n}\n});\n/**\n * Returns the namespace String of x.\n */\ncljs.core._namespace \x3d (function cljs$core$_namespace(x){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.cljs$core$INamed$_namespace$arity$1 \x3d\x3d null)))))){\nreturn x.cljs$core$INamed$_namespace$arity$1(x);\n} else {\nreturn cljs$core$INamed$_namespace$dyn_20944(x);\n}\n});\n\n\n/**\n * Marker protocol indicating an atom.\n * @interface\n */\ncljs.core.IAtom \x3d function(){};\n\n\n/**\n * Protocol for adding resetting functionality.\n * @interface\n */\ncljs.core.IReset \x3d function(){};\n\nvar cljs$core$IReset$_reset_BANG_$dyn_20947 \x3d (function (o,new_value){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._reset_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__5351__auto__.call(null, o,new_value));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._reset_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__5349__auto__.call(null, o,new_value));\n} else {\nthrow cljs.core.missing_protocol(\x22IReset.-reset!\x22,o);\n}\n}\n});\n/**\n * Sets the value of o to new-value.\n */\ncljs.core._reset_BANG_ \x3d (function cljs$core$_reset_BANG_(o,new_value){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IReset$_reset_BANG_$arity$2 \x3d\x3d null)))))){\nreturn o.cljs$core$IReset$_reset_BANG_$arity$2(o,new_value);\n} else {\nreturn cljs$core$IReset$_reset_BANG_$dyn_20947(o,new_value);\n}\n});\n\n\n/**\n * Protocol for adding swapping functionality.\n * @interface\n */\ncljs.core.ISwap \x3d function(){};\n\nvar cljs$core$ISwap$_swap_BANG_$dyn_20949 \x3d (function() {\nvar G__20950 \x3d null;\nvar G__20950__2 \x3d (function (o,f){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._swap_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(o,f) : m__5351__auto__.call(null, o,f));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._swap_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(o,f) : m__5349__auto__.call(null, o,f));\n} else {\nthrow cljs.core.missing_protocol(\x22ISwap.-swap!\x22,o);\n}\n}\n});\nvar G__20950__3 \x3d (function (o,f,a){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._swap_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(o,f,a) : m__5351__auto__.call(null, o,f,a));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._swap_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(o,f,a) : m__5349__auto__.call(null, o,f,a));\n} else {\nthrow cljs.core.missing_protocol(\x22ISwap.-swap!\x22,o);\n}\n}\n});\nvar G__20950__4 \x3d (function (o,f,a,b){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._swap_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$4(o,f,a,b) : m__5351__auto__.call(null, o,f,a,b));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._swap_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$4(o,f,a,b) : m__5349__auto__.call(null, o,f,a,b));\n} else {\nthrow cljs.core.missing_protocol(\x22ISwap.-swap!\x22,o);\n}\n}\n});\nvar G__20950__5 \x3d (function (o,f,a,b,xs){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._swap_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$5 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$5(o,f,a,b,xs) : m__5351__auto__.call(null, o,f,a,b,xs));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._swap_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$5 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$5(o,f,a,b,xs) : m__5349__auto__.call(null, o,f,a,b,xs));\n} else {\nthrow cljs.core.missing_protocol(\x22ISwap.-swap!\x22,o);\n}\n}\n});\nG__20950 \x3d function(o,f,a,b,xs){\nswitch(arguments.length){\ncase 2:\nreturn G__20950__2.call(this,o,f);\ncase 3:\nreturn G__20950__3.call(this,o,f,a);\ncase 4:\nreturn G__20950__4.call(this,o,f,a,b);\ncase 5:\nreturn G__20950__5.call(this,o,f,a,b,xs);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__20950.cljs$core$IFn$_invoke$arity$2 \x3d G__20950__2;\nG__20950.cljs$core$IFn$_invoke$arity$3 \x3d G__20950__3;\nG__20950.cljs$core$IFn$_invoke$arity$4 \x3d G__20950__4;\nG__20950.cljs$core$IFn$_invoke$arity$5 \x3d G__20950__5;\nreturn G__20950;\n})()\n;\n/**\n * Swaps the value of o to be (apply f current-value-of-atom args).\n */\ncljs.core._swap_BANG_ \x3d (function cljs$core$_swap_BANG_(var_args){\nvar G__17460 \x3d arguments.length;\nswitch (G__17460) {\ncase 2:\nreturn cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (o,f){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$ISwap$_swap_BANG_$arity$2 \x3d\x3d null)))))){\nreturn o.cljs$core$ISwap$_swap_BANG_$arity$2(o,f);\n} else {\nreturn cljs$core$ISwap$_swap_BANG_$dyn_20949(o,f);\n}\n}));\n\n(cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (o,f,a){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$ISwap$_swap_BANG_$arity$3 \x3d\x3d null)))))){\nreturn o.cljs$core$ISwap$_swap_BANG_$arity$3(o,f,a);\n} else {\nreturn cljs$core$ISwap$_swap_BANG_$dyn_20949(o,f,a);\n}\n}));\n\n(cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4 \x3d (function (o,f,a,b){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$ISwap$_swap_BANG_$arity$4 \x3d\x3d null)))))){\nreturn o.cljs$core$ISwap$_swap_BANG_$arity$4(o,f,a,b);\n} else {\nreturn cljs$core$ISwap$_swap_BANG_$dyn_20949(o,f,a,b);\n}\n}));\n\n(cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5 \x3d (function (o,f,a,b,xs){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$ISwap$_swap_BANG_$arity$5 \x3d\x3d null)))))){\nreturn o.cljs$core$ISwap$_swap_BANG_$arity$5(o,f,a,b,xs);\n} else {\nreturn cljs$core$ISwap$_swap_BANG_$dyn_20949(o,f,a,b,xs);\n}\n}));\n\n(cljs.core._swap_BANG_.cljs$lang$maxFixedArity \x3d 5);\n\n\n\n/**\n * Protocol for adding volatile functionality.\n * @interface\n */\ncljs.core.IVolatile \x3d function(){};\n\nvar cljs$core$IVolatile$_vreset_BANG_$dyn_21018 \x3d (function (o,new_value){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (cljs.core._vreset_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__5351__auto__.call(null, o,new_value));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._vreset_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__5349__auto__.call(null, o,new_value));\n} else {\nthrow cljs.core.missing_protocol(\x22IVolatile.-vreset!\x22,o);\n}\n}\n});\n/**\n * Sets the value of volatile o to new-value without regard for the\n *   current value. Returns new-value.\n */\ncljs.core._vreset_BANG_ \x3d (function cljs$core$_vreset_BANG_(o,new_value){\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.cljs$core$IVolatile$_vreset_BANG_$arity$2 \x3d\x3d null)))))){\nreturn o.cljs$core$IVolatile$_vreset_BANG_$arity$2(o,new_value);\n} else {\nreturn cljs$core$IVolatile$_vreset_BANG_$dyn_21018(o,new_value);\n}\n});\n\n\n/**\n * Protocol for iterating over a collection.\n * @interface\n */\ncljs.core.IIterable \x3d function(){};\n\nvar cljs$core$IIterable$_iterator$dyn_21033 \x3d (function (coll){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._iterator[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5351__auto__.call(null, coll));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._iterator[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__5349__auto__.call(null, coll));\n} else {\nthrow cljs.core.missing_protocol(\x22IIterable.-iterator\x22,coll);\n}\n}\n});\n/**\n * Returns an iterator for coll.\n */\ncljs.core._iterator \x3d (function cljs$core$_iterator(coll){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IIterable$_iterator$arity$1 \x3d\x3d null)))))){\nreturn coll.cljs$core$IIterable$_iterator$arity$1(coll);\n} else {\nreturn cljs$core$IIterable$_iterator$dyn_21033(coll);\n}\n});\n\n\n/**\n * Protocol for persistent or algorithmically defined collections to provide a\n *   means of dropping N items that is more efficient than sequential walking.\n * @interface\n */\ncljs.core.IDrop \x3d function(){};\n\nvar cljs$core$IDrop$_drop$dyn_21036 \x3d (function (coll,n){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (cljs.core._drop[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(coll,n) : m__5351__auto__.call(null, coll,n));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._drop[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(coll,n) : m__5349__auto__.call(null, coll,n));\n} else {\nthrow cljs.core.missing_protocol(\x22IDrop.-drop\x22,coll);\n}\n}\n});\n/**\n * Returns a collection that is ISequential, ISeq, and IReduce, or nil if past\n *   the end. The number of items to drop n must be \x3e 0. It is also useful if the\n *   returned coll implements IDrop for subsequent use in a partition-like scenario.\n */\ncljs.core._drop \x3d (function cljs$core$_drop(coll,n){\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.cljs$core$IDrop$_drop$arity$2 \x3d\x3d null)))))){\nreturn coll.cljs$core$IDrop$_drop$arity$2(coll,n);\n} else {\nreturn cljs$core$IDrop$_drop$dyn_21036(coll,n);\n}\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n*/\ncljs.core.StringBufferWriter \x3d (function (sb){\nthis.sb \x3d sb;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1073741824;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (_,s){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.sb.append(s);\n}));\n\n(cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.StringBufferWriter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22sb\x22,\x22sb\x22,-1249746442,null)], null);\n}));\n\n(cljs.core.StringBufferWriter.cljs$lang$type \x3d true);\n\n(cljs.core.StringBufferWriter.cljs$lang$ctorStr \x3d \x22cljs.core/StringBufferWriter\x22);\n\n(cljs.core.StringBufferWriter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/StringBufferWriter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/StringBufferWriter.\n */\ncljs.core.__GT_StringBufferWriter \x3d (function cljs$core$__GT_StringBufferWriter(sb){\nreturn (new cljs.core.StringBufferWriter(sb));\n});\n\n/**\n * Support so that collections can implement toString without\n * loading all the printing machinery.\n */\ncljs.core.pr_str_STAR_ \x3d (function cljs$core$pr_str_STAR_(obj){\nvar sb \x3d (new goog.string.StringBuffer());\nvar writer \x3d (new cljs.core.StringBufferWriter(sb));\nobj.cljs$core$IPrintWithWriter$_pr_writer$arity$3(null, writer,cljs.core.pr_opts());\n\nwriter.cljs$core$IWriter$_flush$arity$1(null, );\n\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb);\n});\ncljs.core.int_rotate_left \x3d (function cljs$core$int_rotate_left(x,n){\nreturn ((x \x3c\x3c n) | (x \x3e\x3e\x3e (- n)));\n});\nif((((typeof Math !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof Math.imul !\x3d\x3d \x27undefined\x27)) \x26\x26 ((!((Math.imul((4294967295),(5)) \x3d\x3d\x3d (0))))))){\ncljs.core.imul \x3d (function cljs$core$imul(a,b){\nreturn Math.imul(a,b);\n});\n} else {\ncljs.core.imul \x3d (function cljs$core$imul(a,b){\nvar ah \x3d ((a \x3e\x3e\x3e (16)) \x26 (65535));\nvar al \x3d (a \x26 (65535));\nvar bh \x3d ((b \x3e\x3e\x3e (16)) \x26 (65535));\nvar bl \x3d (b \x26 (65535));\nreturn (((al * bl) + ((((ah * bl) + (al * bh)) \x3c\x3c (16)) \x3e\x3e\x3e (0))) | (0));\n});\n}\ncljs.core.m3_seed \x3d (0);\ncljs.core.m3_C1 \x3d ((3432918353) | (0));\ncljs.core.m3_C2 \x3d ((461845907) | (0));\ncljs.core.m3_mix_K1 \x3d (function cljs$core$m3_mix_K1(k1){\nreturn cljs.core.imul(cljs.core.int_rotate_left(cljs.core.imul((k1 | (0)),cljs.core.m3_C1),(15)),cljs.core.m3_C2);\n});\ncljs.core.m3_mix_H1 \x3d (function cljs$core$m3_mix_H1(h1,k1){\nreturn ((cljs.core.imul(cljs.core.int_rotate_left(((h1 | (0)) ^ (k1 | (0))),(13)),(5)) + ((3864292196) | (0))) | (0));\n});\ncljs.core.m3_fmix \x3d (function cljs$core$m3_fmix(h1,len){\nvar h1__$1 \x3d (h1 | (0));\nvar h1__$2 \x3d (h1__$1 ^ len);\nvar h1__$3 \x3d (h1__$2 ^ (h1__$2 \x3e\x3e\x3e (16)));\nvar h1__$4 \x3d cljs.core.imul(h1__$3,((2246822507) | (0)));\nvar h1__$5 \x3d (h1__$4 ^ (h1__$4 \x3e\x3e\x3e (13)));\nvar h1__$6 \x3d cljs.core.imul(h1__$5,((3266489909) | (0)));\nreturn (h1__$6 ^ (h1__$6 \x3e\x3e\x3e (16)));\n});\ncljs.core.m3_hash_int \x3d (function cljs$core$m3_hash_int(in$){\nif((in$ \x3d\x3d\x3d (0))){\nreturn in$;\n} else {\nvar k1 \x3d cljs.core.m3_mix_K1(in$);\nvar h1 \x3d cljs.core.m3_mix_H1(cljs.core.m3_seed,k1);\nreturn cljs.core.m3_fmix(h1,(4));\n}\n});\ncljs.core.hash_long \x3d (function cljs$core$hash_long(high,low){\nreturn (high ^ low);\n});\ncljs.core.hash_double \x3d (function cljs$core$hash_double(f){\nvar arr \x3d (function (){var G__17461 \x3d (new Float64Array((1)));\n(G__17461[(0)] \x3d f);\n\nreturn G__17461;\n})();\nvar buf \x3d arr.buffer;\nvar high \x3d (new DataView(buf,(0),(4))).getInt32();\nvar low \x3d (new DataView(buf,(4),(4))).getInt32();\nreturn cljs.core.hash_long(high,low);\n});\ncljs.core.m3_hash_unencoded_chars \x3d (function cljs$core$m3_hash_unencoded_chars(in$){\nvar h1 \x3d (function (){var i \x3d (1);\nvar h1 \x3d cljs.core.m3_seed;\nwhile(true){\nif((i \x3c in$.length)){\nvar G__21070 \x3d (i + (2));\nvar G__21071 \x3d cljs.core.m3_mix_H1(h1,cljs.core.m3_mix_K1((in$.charCodeAt((i - (1))) | (in$.charCodeAt(i) \x3c\x3c (16)))));\ni \x3d G__21070;\nh1 \x3d G__21071;\ncontinue;\n} else {\nreturn h1;\n}\nbreak;\n}\n})();\nvar h1__$1 \x3d ((((in$.length \x26 (1)) \x3d\x3d\x3d (1)))?(h1 ^ cljs.core.m3_mix_K1(in$.charCodeAt((in$.length - (1))))):h1);\nreturn cljs.core.m3_fmix(h1__$1,cljs.core.imul((2),in$.length));\n});\n\n\n\ncljs.core.string_hash_cache \x3d ({});\ncljs.core.string_hash_cache_count \x3d (0);\ncljs.core.hash_string_STAR_ \x3d (function cljs$core$hash_string_STAR_(s){\nif((!((s \x3d\x3d null)))){\nvar len \x3d s.length;\nif((len \x3e (0))){\nvar i \x3d (0);\nvar hash \x3d (0);\nwhile(true){\nif((i \x3c len)){\nvar G__21073 \x3d (i + (1));\nvar G__21074 \x3d (cljs.core.imul((31),hash) + s.charCodeAt(i));\ni \x3d G__21073;\nhash \x3d G__21074;\ncontinue;\n} else {\nreturn hash;\n}\nbreak;\n}\n} else {\nreturn (0);\n}\n} else {\nreturn (0);\n}\n});\ncljs.core.add_to_string_hash_cache \x3d (function cljs$core$add_to_string_hash_cache(k){\nvar h \x3d cljs.core.hash_string_STAR_(k);\ncljs.core.goog$module$goog$object.set(cljs.core.string_hash_cache,k,h);\n\n(cljs.core.string_hash_cache_count \x3d (cljs.core.string_hash_cache_count + (1)));\n\nreturn h;\n});\ncljs.core.hash_string \x3d (function cljs$core$hash_string(k){\nif((cljs.core.string_hash_cache_count \x3e (255))){\n(cljs.core.string_hash_cache \x3d ({}));\n\n(cljs.core.string_hash_cache_count \x3d (0));\n} else {\n}\n\nif((k \x3d\x3d null)){\nreturn (0);\n} else {\nvar h \x3d (cljs.core.string_hash_cache[k]);\nif(typeof h \x3d\x3d\x3d \x27number\x27){\nreturn h;\n} else {\nreturn cljs.core.add_to_string_hash_cache(k);\n}\n}\n});\n/**\n * Returns the hash code of its argument. Note this is the hash code\n * consistent with \x3d.\n */\ncljs.core.hash \x3d (function cljs$core$hash(o){\nif((((!((o \x3d\x3d null))))?(((((o.cljs$lang$protocol_mask$partition0$ \x26 (4194304))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d o.cljs$core$IHash$))))?true:false):false)){\nreturn (o.cljs$core$IHash$_hash$arity$1(null, ) ^ (0));\n} else {\nif(typeof o \x3d\x3d\x3d \x27number\x27){\nif(isFinite(o)){\nif((!(Number.isSafeInteger(o)))){\nreturn cljs.core.hash_double(o);\n} else {\nreturn (Math.floor(o) % (2147483647));\n}\n} else {\nvar G__17467 \x3d o;\nswitch (G__17467) {\ncase Infinity:\nreturn (2146435072);\n\nbreak;\ncase -Infinity:\nreturn (-1048576);\n\nbreak;\ndefault:\nreturn (2146959360);\n\n}\n}\n} else {\nif(o \x3d\x3d\x3d true){\nreturn (1231);\n} else {\nif(o \x3d\x3d\x3d false){\nreturn (1237);\n} else {\nif(typeof o \x3d\x3d\x3d \x27string\x27){\nreturn cljs.core.m3_hash_int(cljs.core.hash_string(o));\n} else {\nif((o instanceof Date)){\nreturn (o.valueOf() ^ (0));\n} else {\nif((o \x3d\x3d null)){\nreturn (0);\n} else {\nreturn (cljs.core._hash(o) ^ (0));\n\n}\n}\n}\n}\n}\n}\n}\n});\ncljs.core.hash_combine \x3d (function cljs$core$hash_combine(seed,hash){\nreturn (seed ^ (((hash + (2654435769)) + (seed \x3c\x3c (6))) + (seed \x3e\x3e (2))));\n});\n/**\n * Evaluates x and tests if it is an instance of the type\n *   c. Returns true or false\n */\ncljs.core.instance_QMARK_ \x3d (function cljs$core$instance_QMARK_(c,x){\nreturn (x instanceof c);\n});\n/**\n * Return true if x is a Symbol\n */\ncljs.core.symbol_QMARK_ \x3d (function cljs$core$symbol_QMARK_(x){\nreturn (x instanceof cljs.core.Symbol);\n});\ncljs.core.hash_symbol \x3d (function cljs$core$hash_symbol(sym){\nreturn cljs.core.hash_combine(cljs.core.m3_hash_unencoded_chars(sym.name),cljs.core.hash_string(sym.ns));\n});\ncljs.core.compare_symbols \x3d (function cljs$core$compare_symbols(a,b){\nif((a.str \x3d\x3d\x3d b.str)){\nreturn (0);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(a.ns);\nif(and__5000__auto__){\nreturn b.ns;\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn (-1);\n} else {\nif(cljs.core.truth_(a.ns)){\nif(cljs.core.not(b.ns)){\nreturn (1);\n} else {\nvar nsc \x3d cljs.core.goog$module$goog$array.defaultCompare(a.ns,b.ns);\nif(((0) \x3d\x3d\x3d nsc)){\nreturn cljs.core.goog$module$goog$array.defaultCompare(a.name,b.name);\n} else {\nreturn nsc;\n}\n}\n} else {\nreturn cljs.core.goog$module$goog$array.defaultCompare(a.name,b.name);\n\n}\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.INamed}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.Symbol \x3d (function (ns,name,str,_hash,_meta){\nthis.ns \x3d ns;\nthis.name \x3d name;\nthis.str \x3d str;\nthis._hash \x3d _hash;\nthis._meta \x3d _meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2154168321;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 4096;\n});\n(cljs.core.Symbol.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn self__.str;\n}));\n\n(cljs.core.Symbol.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (_,other){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((other instanceof cljs.core.Symbol)){\nreturn (self__.str \x3d\x3d\x3d other.str);\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.Symbol.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__17469 \x3d (arguments.length - (1));\nswitch (G__17469) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.Symbol.prototype.apply \x3d (function (self__,args17468){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args17468)));\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar sym \x3d this;\nreturn (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));\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,not_found){\nvar self__ \x3d this;\nvar sym \x3d this;\nreturn (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));\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__._meta;\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_,new_meta){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.Symbol(self__.ns,self__.name,self__.str,self__._hash,new_meta));\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (sym){\nvar self__ \x3d this;\nvar sym__$1 \x3d this;\nvar h__5111__auto__ \x3d self__._hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_symbol(sym__$1);\n(self__._hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$INamed$_name$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.name;\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$INamed$_namespace$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.ns;\n}));\n\n(cljs.core.Symbol.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (o,writer,_){\nvar self__ \x3d this;\nvar o__$1 \x3d this;\nreturn cljs.core._write(writer,self__.str);\n}));\n\n(cljs.core.Symbol.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22ns\x22,\x22ns\x22,2082130287,null),new cljs.core.Symbol(null,\x22name\x22,\x22name\x22,-810760592,null),new cljs.core.Symbol(null,\x22str\x22,\x22str\x22,-1564826950,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22_hash\x22,\x22_hash\x22,-2130838312,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22_meta\x22,\x22_meta\x22,-1716892533,null)], null);\n}));\n\n(cljs.core.Symbol.cljs$lang$type \x3d true);\n\n(cljs.core.Symbol.cljs$lang$ctorStr \x3d \x22cljs.core/Symbol\x22);\n\n(cljs.core.Symbol.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Symbol\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Symbol.\n */\ncljs.core.__GT_Symbol \x3d (function cljs$core$__GT_Symbol(ns,name,str,_hash,_meta){\nreturn (new cljs.core.Symbol(ns,name,str,_hash,_meta));\n});\n\n/**\n * Returns true if v is of type cljs.core.Var\n */\ncljs.core.var_QMARK_ \x3d (function cljs$core$var_QMARK_(v){\nreturn (v instanceof cljs.core.Var);\n});\n/**\n * Returns a Symbol with the given namespace and name. Arity-1 works\n *   on strings, keywords, and vars.\n */\ncljs.core.symbol \x3d (function cljs$core$symbol(var_args){\nvar G__17471 \x3d arguments.length;\nswitch (G__17471) {\ncase 1:\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.symbol.cljs$core$IFn$_invoke$arity$1 \x3d (function (name){\nwhile(true){\nif((name instanceof cljs.core.Symbol)){\nreturn name;\n} else {\nif(typeof name \x3d\x3d\x3d \x27string\x27){\nvar idx \x3d name.indexOf(\x22/\x22);\nif((idx \x3c (1))){\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(null,name);\n} else {\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(name.substring((0),idx),name.substring((idx + (1)),name.length));\n}\n} else {\nif(cljs.core.var_QMARK_(name)){\nreturn name.sym;\n} else {\nif((name instanceof cljs.core.Keyword)){\nvar G__21194 \x3d name.fqn;\nname \x3d G__21194;\ncontinue;\n} else {\nthrow (new Error(\x22no conversion to symbol\x22));\n\n}\n}\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.symbol.cljs$core$IFn$_invoke$arity$2 \x3d (function (ns,name){\nvar sym_str \x3d (((!((ns \x3d\x3d null))))?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns),\x22/\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(name)].join(\x27\x27):name);\nreturn (new cljs.core.Symbol(ns,name,sym_str,null,null));\n}));\n\n(cljs.core.symbol.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.Fn}\n * @implements {cljs.core.IDeref}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.Var \x3d (function (val,sym,_meta){\nthis.val \x3d val;\nthis.sym \x3d sym;\nthis._meta \x3d _meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 6717441;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.Var.prototype.isMacro \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, )).cljs$lang$macro;\n}));\n\n(cljs.core.Var.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn [\x22#\x27\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.sym)].join(\x27\x27);\n}));\n\n(cljs.core.Var.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__._meta;\n}));\n\n(cljs.core.Var.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_,new_meta){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.Var(self__.val,self__.sym,new_meta));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this$,other){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((other instanceof cljs.core.Var)){\nvar G__17473 \x3d this$__$1.sym;\nvar G__17474 \x3d other.sym;\nreturn (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2 ? cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(G__17473,G__17474) : cljs.core._EQ_.call(null, G__17473,G__17474));\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.Var.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.hash_symbol(self__.sym);\n}));\n\n(cljs.core.Var.prototype.cljs$core$Fn$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Var.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__17475 \x3d (arguments.length - (1));\nswitch (G__17475) {\ncase (0):\nreturn self__.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase (3):\nreturn self__.cljs$core$IFn$_invoke$arity$3((arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase (4):\nreturn self__.cljs$core$IFn$_invoke$arity$4((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase (5):\nreturn self__.cljs$core$IFn$_invoke$arity$5((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ncase (6):\nreturn self__.cljs$core$IFn$_invoke$arity$6((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]));\n\nbreak;\ncase (7):\nreturn self__.cljs$core$IFn$_invoke$arity$7((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]));\n\nbreak;\ncase (8):\nreturn self__.cljs$core$IFn$_invoke$arity$8((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]));\n\nbreak;\ncase (9):\nreturn self__.cljs$core$IFn$_invoke$arity$9((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]));\n\nbreak;\ncase (10):\nreturn self__.cljs$core$IFn$_invoke$arity$10((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]));\n\nbreak;\ncase (11):\nreturn self__.cljs$core$IFn$_invoke$arity$11((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]));\n\nbreak;\ncase (12):\nreturn self__.cljs$core$IFn$_invoke$arity$12((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]));\n\nbreak;\ncase (13):\nreturn self__.cljs$core$IFn$_invoke$arity$13((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)]));\n\nbreak;\ncase (14):\nreturn self__.cljs$core$IFn$_invoke$arity$14((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)]));\n\nbreak;\ncase (15):\nreturn self__.cljs$core$IFn$_invoke$arity$15((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)]));\n\nbreak;\ncase (16):\nreturn self__.cljs$core$IFn$_invoke$arity$16((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)]));\n\nbreak;\ncase (17):\nreturn self__.cljs$core$IFn$_invoke$arity$17((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)]));\n\nbreak;\ncase (18):\nreturn self__.cljs$core$IFn$_invoke$arity$18((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)]));\n\nbreak;\ncase (19):\nreturn self__.cljs$core$IFn$_invoke$arity$19((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)]));\n\nbreak;\ncase (20):\nreturn self__.cljs$core$IFn$_invoke$arity$20((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)]));\n\nbreak;\ncase (21):\nreturn self__.cljs$core$IFn$_invoke$arity$21((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)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.Var.prototype.apply \x3d (function (self__,args17472){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args17472)));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17476 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17476.cljs$core$IFn$_invoke$arity$0 ? fexpr__17476.cljs$core$IFn$_invoke$arity$0() : fexpr__17476.call(null, ));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (a){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17477 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17477.cljs$core$IFn$_invoke$arity$1 ? fexpr__17477.cljs$core$IFn$_invoke$arity$1(a) : fexpr__17477.call(null, a));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (a,b){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17478 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17478.cljs$core$IFn$_invoke$arity$2 ? fexpr__17478.cljs$core$IFn$_invoke$arity$2(a,b) : fexpr__17478.call(null, a,b));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$3 \x3d (function (a,b,c){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17479 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17479.cljs$core$IFn$_invoke$arity$3 ? fexpr__17479.cljs$core$IFn$_invoke$arity$3(a,b,c) : fexpr__17479.call(null, a,b,c));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$4 \x3d (function (a,b,c,d){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17480 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17480.cljs$core$IFn$_invoke$arity$4 ? fexpr__17480.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : fexpr__17480.call(null, a,b,c,d));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$5 \x3d (function (a,b,c,d,e){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17481 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17481.cljs$core$IFn$_invoke$arity$5 ? fexpr__17481.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : fexpr__17481.call(null, a,b,c,d,e));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$6 \x3d (function (a,b,c,d,e,f){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17482 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17482.cljs$core$IFn$_invoke$arity$6 ? fexpr__17482.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : fexpr__17482.call(null, a,b,c,d,e,f));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$7 \x3d (function (a,b,c,d,e,f,g){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17483 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17483.cljs$core$IFn$_invoke$arity$7 ? fexpr__17483.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : fexpr__17483.call(null, a,b,c,d,e,f,g));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$8 \x3d (function (a,b,c,d,e,f,g,h){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17484 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17484.cljs$core$IFn$_invoke$arity$8 ? fexpr__17484.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : fexpr__17484.call(null, a,b,c,d,e,f,g,h));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$9 \x3d (function (a,b,c,d,e,f,g,h,i){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17485 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17485.cljs$core$IFn$_invoke$arity$9 ? fexpr__17485.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : fexpr__17485.call(null, a,b,c,d,e,f,g,h,i));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$10 \x3d (function (a,b,c,d,e,f,g,h,i,j){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17486 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17486.cljs$core$IFn$_invoke$arity$10 ? fexpr__17486.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : fexpr__17486.call(null, a,b,c,d,e,f,g,h,i,j));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$11 \x3d (function (a,b,c,d,e,f,g,h,i,j,k){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17487 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17487.cljs$core$IFn$_invoke$arity$11 ? fexpr__17487.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : fexpr__17487.call(null, a,b,c,d,e,f,g,h,i,j,k));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$12 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17488 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17488.cljs$core$IFn$_invoke$arity$12 ? fexpr__17488.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : fexpr__17488.call(null, a,b,c,d,e,f,g,h,i,j,k,l));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$13 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17489 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17489.cljs$core$IFn$_invoke$arity$13 ? fexpr__17489.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : fexpr__17489.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$14 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17490 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17490.cljs$core$IFn$_invoke$arity$14 ? fexpr__17490.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : fexpr__17490.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$15 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17491 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17491.cljs$core$IFn$_invoke$arity$15 ? fexpr__17491.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : fexpr__17491.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$16 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17492 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17492.cljs$core$IFn$_invoke$arity$16 ? fexpr__17492.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : fexpr__17492.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$17 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17493 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17493.cljs$core$IFn$_invoke$arity$17 ? fexpr__17493.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : fexpr__17493.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$18 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17494 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17494.cljs$core$IFn$_invoke$arity$18 ? fexpr__17494.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : fexpr__17494.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$19 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17495 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17495.cljs$core$IFn$_invoke$arity$19 ? fexpr__17495.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) : fexpr__17495.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$20 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar fexpr__17496 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nreturn (fexpr__17496.cljs$core$IFn$_invoke$arity$20 ? fexpr__17496.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) : fexpr__17496.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t));\n}));\n\n(cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$21 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar G__17497 \x3d (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null, ));\nvar G__17498 \x3d a;\nvar G__17499 \x3d b;\nvar G__17500 \x3d c;\nvar G__17501 \x3d d;\nvar G__17502 \x3d e;\nvar G__17503 \x3d f;\nvar G__17504 \x3d g;\nvar G__17505 \x3d h;\nvar G__17506 \x3d i;\nvar G__17507 \x3d j;\nvar G__17508 \x3d k;\nvar G__17509 \x3d l;\nvar G__17510 \x3d m;\nvar G__17511 \x3d n;\nvar G__17512 \x3d o;\nvar G__17513 \x3d p;\nvar G__17514 \x3d q;\nvar G__17515 \x3d r;\nvar G__17516 \x3d s;\nvar G__17517 \x3d t;\nvar G__17518 \x3d rest;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$21 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$21(G__17497,G__17498,G__17499,G__17500,G__17501,G__17502,G__17503,G__17504,G__17505,G__17506,G__17507,G__17508,G__17509,G__17510,G__17511,G__17512,G__17513,G__17514,G__17515,G__17516, new cljs.core.IndexedSeq([G__17517,G__17518],0,null)) : cljs.core.apply.call(null, G__17497,G__17498,G__17499,G__17500,G__17501,G__17502,G__17503,G__17504,G__17505,G__17506,G__17507,G__17508,G__17509,G__17510,G__17511,G__17512,G__17513,G__17514,G__17515,G__17516,G__17517,G__17518));\n}));\n\n(cljs.core.Var.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.Symbol(null,\x22sym\x22,\x22sym\x22,195671222,null),new cljs.core.Symbol(null,\x22_meta\x22,\x22_meta\x22,-1716892533,null)], null);\n}));\n\n(cljs.core.Var.cljs$lang$type \x3d true);\n\n(cljs.core.Var.cljs$lang$ctorStr \x3d \x22cljs.core/Var\x22);\n\n(cljs.core.Var.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Var\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Var.\n */\ncljs.core.__GT_Var \x3d (function cljs$core$__GT_Var(val,sym,_meta){\nreturn (new cljs.core.Var(val,sym,_meta));\n});\n\n\n\n/**\n * Return true if x implements IIterable protocol.\n */\ncljs.core.iterable_QMARK_ \x3d (function cljs$core$iterable_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition1$ \x26 (131072))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IIterable$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition1$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IIterable,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IIterable,x);\n}\n});\n/**\n * Return true if x has a JavaScript iterator property\n */\ncljs.core.js_iterable_QMARK_ \x3d (function cljs$core$js_iterable_QMARK_(x){\nreturn (((!((x \x3d\x3d null)))) \x26\x26 ((!((x[cljs.core.ITER_SYMBOL] \x3d\x3d null)))));\n});\n/**\n * Clone the supplied value which must implement ICloneable.\n */\ncljs.core.clone \x3d (function cljs$core$clone(value){\nreturn cljs.core._clone(value);\n});\n/**\n * Return true if x implements ICloneable protocol.\n */\ncljs.core.cloneable_QMARK_ \x3d (function cljs$core$cloneable_QMARK_(value){\nif((!((value \x3d\x3d null)))){\nif((((value.cljs$lang$protocol_mask$partition1$ \x26 (8192))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d value.cljs$core$ICloneable$)))){\nreturn true;\n} else {\nif((!value.cljs$lang$protocol_mask$partition1$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ICloneable,value);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ICloneable,value);\n}\n});\n/**\n * Returns a seq on the collection. If the collection is\n *   empty, returns nil.  (seq nil) returns nil. seq also works on\n *   Strings.\n */\ncljs.core.seq \x3d (function cljs$core$seq(coll){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (8388608))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISeqable$))))?true:false):false)){\nreturn coll.cljs$core$ISeqable$_seq$arity$1(null, );\n} else {\nif(cljs.core.array_QMARK_(coll)){\nif((coll.length \x3d\x3d\x3d (0))){\nreturn null;\n} else {\nreturn (new cljs.core.IndexedSeq(coll,(0),null));\n}\n} else {\nif(typeof coll \x3d\x3d\x3d \x27string\x27){\nif((coll.length \x3d\x3d\x3d (0))){\nreturn null;\n} else {\nreturn (new cljs.core.IndexedSeq(coll,(0),null));\n}\n} else {\nif(cljs.core.js_iterable_QMARK_(coll)){\nvar G__17522 \x3d cljs.core.goog$module$goog$object.get(coll,cljs.core.ITER_SYMBOL).call(coll);\nreturn (cljs.core.es6_iterator_seq.cljs$core$IFn$_invoke$arity$1 ? cljs.core.es6_iterator_seq.cljs$core$IFn$_invoke$arity$1(G__17522) : cljs.core.es6_iterator_seq.call(null, G__17522));\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.ISeqable,coll)){\nreturn cljs.core._seq(coll);\n} else {\nthrow (new Error([cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll),\x22 is not ISeqable\x22].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n});\n/**\n * Returns the first item in the collection. Calls seq on its\n *   argument. If coll is nil, returns nil.\n */\ncljs.core.first \x3d (function cljs$core$first(coll){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (64))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISeq$))))?true:false):false)){\nreturn coll.cljs$core$ISeq$_first$arity$1(null, );\n} else {\nvar s \x3d cljs.core.seq(coll);\nif((s \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core._first(s);\n}\n}\n}\n});\n/**\n * Returns a possibly empty seq of the items after the first. Calls seq on its\n *   argument.\n */\ncljs.core.rest \x3d (function cljs$core$rest(coll){\nif((!((coll \x3d\x3d null)))){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (64))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISeq$))))?true:false):false)){\nreturn coll.cljs$core$ISeq$_rest$arity$1(null, );\n} else {\nvar s \x3d cljs.core.seq(coll);\nif(s){\nreturn s.cljs$core$ISeq$_rest$arity$1(null, );\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}\n} else {\nreturn cljs.core.List.EMPTY;\n}\n});\n/**\n * Returns a seq of the items after the first. Calls seq on its\n *   argument.  If there are no more items, returns nil\n */\ncljs.core.next \x3d (function cljs$core$next(coll){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (128))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$INext$))))?true:false):false)){\nreturn coll.cljs$core$INext$_next$arity$1(null, );\n} else {\nreturn cljs.core.seq(cljs.core.rest(coll));\n}\n}\n});\n/**\n * Equality. Returns true if x equals y, false if not. Compares\n *   numbers and collections in a type-independent manner.  Clojure\x27s immutable data\n *   structures define -equiv (and thus \x3d) as a value, not an identity,\n *   comparison.\n */\ncljs.core._EQ_ \x3d (function cljs$core$_EQ_(var_args){\nvar G__17530 \x3d arguments.length;\nswitch (G__17530) {\ncase 1:\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___21400 \x3d arguments.length;\nvar i__5727__auto___21401 \x3d (0);\nwhile(true){\nif((i__5727__auto___21401 \x3c len__5726__auto___21400)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___21401]));\n\nvar G__21402 \x3d (i__5727__auto___21401 + (1));\ni__5727__auto___21401 \x3d G__21402;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn true;\n}));\n\n(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nif((x \x3d\x3d null)){\nreturn (y \x3d\x3d null);\n} else {\nreturn (((x \x3d\x3d\x3d y)) || (cljs.core._equiv(x,y)));\n}\n}));\n\n(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nwhile(true){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)){\nif(cljs.core.next(more)){\nvar G__21418 \x3d y;\nvar G__21419 \x3d cljs.core.first(more);\nvar G__21420 \x3d cljs.core.next(more);\nx \x3d G__21418;\ny \x3d G__21419;\nmore \x3d G__21420;\ncontinue;\n} else {\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(y,cljs.core.first(more));\n}\n} else {\nreturn false;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core._EQ_.cljs$lang$applyTo \x3d (function (seq17527){\nvar G__17528 \x3d cljs.core.first(seq17527);\nvar seq17527__$1 \x3d cljs.core.next(seq17527);\nvar G__17529 \x3d cljs.core.first(seq17527__$1);\nvar seq17527__$2 \x3d cljs.core.next(seq17527__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17528,G__17529,seq17527__$2);\n}));\n\n(cljs.core._EQ_.cljs$lang$maxFixedArity \x3d (2));\n\n\n/**\n* @constructor\n*/\ncljs.core.ES6Iterator \x3d (function (s){\nthis.s \x3d s;\n});\n(cljs.core.ES6Iterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((!((self__.s \x3d\x3d null)))){\nvar x \x3d cljs.core.first(self__.s);\n(self__.s \x3d cljs.core.next(self__.s));\n\nreturn ({\x22value\x22: x, \x22done\x22: false});\n} else {\nreturn ({\x22value\x22: null, \x22done\x22: true});\n}\n}));\n\n(cljs.core.ES6Iterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22s\x22,\x22s\x22,-948495851,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ES6Iterator.cljs$lang$type \x3d true);\n\n(cljs.core.ES6Iterator.cljs$lang$ctorStr \x3d \x22cljs.core/ES6Iterator\x22);\n\n(cljs.core.ES6Iterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ES6Iterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ES6Iterator.\n */\ncljs.core.__GT_ES6Iterator \x3d (function cljs$core$__GT_ES6Iterator(s){\nreturn (new cljs.core.ES6Iterator(s));\n});\n\n/**\n * Return a ES2015+ compatible iterator for coll.\n */\ncljs.core.es6_iterator \x3d (function cljs$core$es6_iterator(coll){\nreturn (new cljs.core.ES6Iterator(cljs.core.seq(coll)));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.ISeqable}\n*/\ncljs.core.ES6IteratorSeq \x3d (function (value,iter,_rest){\nthis.value \x3d value;\nthis.iter \x3d iter;\nthis._rest \x3d _rest;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 8388672;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn this$__$1;\n}));\n\n(cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.value;\n}));\n\n(cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((self__._rest \x3d\x3d null)){\n(self__._rest \x3d (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)));\n} else {\n}\n\nreturn self__._rest;\n}));\n\n(cljs.core.ES6IteratorSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22value\x22,\x22value\x22,1946509744,null),new cljs.core.Symbol(null,\x22iter\x22,\x22iter\x22,-1346195486,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22_rest\x22,\x22_rest\x22,-2100466189,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ES6IteratorSeq.cljs$lang$type \x3d true);\n\n(cljs.core.ES6IteratorSeq.cljs$lang$ctorStr \x3d \x22cljs.core/ES6IteratorSeq\x22);\n\n(cljs.core.ES6IteratorSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ES6IteratorSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ES6IteratorSeq.\n */\ncljs.core.__GT_ES6IteratorSeq \x3d (function cljs$core$__GT_ES6IteratorSeq(value,iter,_rest){\nreturn (new cljs.core.ES6IteratorSeq(value,iter,_rest));\n});\n\n/**\n * Given an ES2015+ compatible iterator return a seq.\n */\ncljs.core.es6_iterator_seq \x3d (function cljs$core$es6_iterator_seq(iter){\nvar v \x3d iter.next();\nif(cljs.core.truth_(v.done)){\nreturn null;\n} else {\nreturn (new cljs.core.ES6IteratorSeq(v.value,iter,null));\n}\n});\n/**\n * Mix final collection hash for ordered or unordered collections.\n * hash-basis is the combined collection hash, count is the number\n * of elements included in the basis. Note this is the hash code\n * consistent with \x3d, different from .hashCode.\n * See http://clojure.org/data_structures#hash for full algorithms.\n */\ncljs.core.mix_collection_hash \x3d (function cljs$core$mix_collection_hash(hash_basis,count){\nvar h1 \x3d cljs.core.m3_seed;\nvar k1 \x3d cljs.core.m3_mix_K1(hash_basis);\nvar h1__$1 \x3d cljs.core.m3_mix_H1(h1,k1);\nreturn cljs.core.m3_fmix(h1__$1,count);\n});\n/**\n * Returns the hash code, consistent with \x3d, for an external ordered\n * collection implementing Iterable.\n * See http://clojure.org/data_structures#hash for full algorithms.\n */\ncljs.core.hash_ordered_coll \x3d (function cljs$core$hash_ordered_coll(coll){\nvar n \x3d (0);\nvar hash_code \x3d (1);\nvar coll__$1 \x3d cljs.core.seq(coll);\nwhile(true){\nif((!((coll__$1 \x3d\x3d null)))){\nvar G__21442 \x3d (n + (1));\nvar G__21443 \x3d ((cljs.core.imul((31),hash_code) + cljs.core.hash(cljs.core.first(coll__$1))) | (0));\nvar G__21444 \x3d cljs.core.next(coll__$1);\nn \x3d G__21442;\nhash_code \x3d G__21443;\ncoll__$1 \x3d G__21444;\ncontinue;\n} else {\nreturn cljs.core.mix_collection_hash(hash_code,n);\n}\nbreak;\n}\n});\ncljs.core.empty_ordered_hash \x3d cljs.core.mix_collection_hash((1),(0));\n/**\n * Returns the hash code, consistent with \x3d, for an external unordered\n * collection implementing Iterable. For maps, the iterator should\n * return map entries whose hash is computed as\n *   (hash-ordered-coll [k v]).\n * See http://clojure.org/data_structures#hash for full algorithms.\n */\ncljs.core.hash_unordered_coll \x3d (function cljs$core$hash_unordered_coll(coll){\nvar n \x3d (0);\nvar hash_code \x3d (0);\nvar coll__$1 \x3d cljs.core.seq(coll);\nwhile(true){\nif((!((coll__$1 \x3d\x3d null)))){\nvar G__21448 \x3d (n + (1));\nvar G__21449 \x3d ((hash_code + cljs.core.hash(cljs.core.first(coll__$1))) | (0));\nvar G__21450 \x3d cljs.core.next(coll__$1);\nn \x3d G__21448;\nhash_code \x3d G__21449;\ncoll__$1 \x3d G__21450;\ncontinue;\n} else {\nreturn cljs.core.mix_collection_hash(hash_code,n);\n}\nbreak;\n}\n});\ncljs.core.empty_unordered_hash \x3d cljs.core.mix_collection_hash((0),(0));\n\n\n(cljs.core.ICounted[\x22null\x22] \x3d true);\n\n(cljs.core._count[\x22null\x22] \x3d (function (_){\nreturn (0);\n}));\n(Date.prototype.cljs$core$IEquiv$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(Date.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (o,other){\nvar o__$1 \x3d this;\nreturn (((other instanceof Date)) \x26\x26 ((o__$1.valueOf() \x3d\x3d\x3d other.valueOf())));\n}));\n\n(Date.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(Date.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (this$,other){\nvar this$__$1 \x3d this;\nif((other instanceof Date)){\nreturn cljs.core.goog$module$goog$array.defaultCompare(this$__$1.valueOf(),other.valueOf());\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(other)].join(\x27\x27)));\n}\n}));\n\n/**\n * @interface\n */\ncljs.core.Inst \x3d function(){};\n\nvar cljs$core$Inst$inst_ms_STAR_$dyn_21457 \x3d (function (inst){\nvar x__5350__auto__ \x3d (((inst \x3d\x3d null))?null:inst);\nvar m__5351__auto__ \x3d (cljs.core.inst_ms_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(inst) : m__5351__auto__.call(null, inst));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.inst_ms_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(inst) : m__5349__auto__.call(null, inst));\n} else {\nthrow cljs.core.missing_protocol(\x22Inst.inst-ms*\x22,inst);\n}\n}\n});\ncljs.core.inst_ms_STAR_ \x3d (function cljs$core$inst_ms_STAR_(inst){\nif((((!((inst \x3d\x3d null)))) \x26\x26 ((!((inst.cljs$core$Inst$inst_ms_STAR_$arity$1 \x3d\x3d null)))))){\nreturn inst.cljs$core$Inst$inst_ms_STAR_$arity$1(inst);\n} else {\nreturn cljs$core$Inst$inst_ms_STAR_$dyn_21457(inst);\n}\n});\n\n(Date.prototype.cljs$core$Inst$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(Date.prototype.cljs$core$Inst$inst_ms_STAR_$arity$1 \x3d (function (inst){\nvar inst__$1 \x3d this;\nreturn inst__$1.getTime();\n}));\n/**\n * Return the number of milliseconds since January 1, 1970, 00:00:00 GMT\n */\ncljs.core.inst_ms \x3d (function cljs$core$inst_ms(inst){\nreturn cljs.core.inst_ms_STAR_(inst);\n});\n/**\n * Return true if x satisfies Inst\n */\ncljs.core.inst_QMARK_ \x3d (function cljs$core$inst_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif(((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$Inst$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.Inst,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.Inst,x);\n}\n});\n(cljs.core.IEquiv[\x22number\x22] \x3d true);\n\n(cljs.core._equiv[\x22number\x22] \x3d (function (x,o){\nreturn (x \x3d\x3d\x3d o);\n}));\n(cljs.core.Fn[\x22function\x22] \x3d true);\n\n(cljs.core.IMeta[\x22function\x22] \x3d true);\n\n(cljs.core._meta[\x22function\x22] \x3d (function (_){\nreturn null;\n}));\n(cljs.core.IHash[\x22_\x22] \x3d true);\n\n(cljs.core._hash[\x22_\x22] \x3d (function (o){\nreturn goog.getUid(o);\n}));\n/**\n * Returns a number one greater than num.\n */\ncljs.core.inc \x3d (function cljs$core$inc(x){\nreturn (x + (1));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IDeref}\n*/\ncljs.core.Reduced \x3d (function (val){\nthis.val \x3d val;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32768;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.Reduced.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (o){\nvar self__ \x3d this;\nvar o__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.Reduced.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null)], null);\n}));\n\n(cljs.core.Reduced.cljs$lang$type \x3d true);\n\n(cljs.core.Reduced.cljs$lang$ctorStr \x3d \x22cljs.core/Reduced\x22);\n\n(cljs.core.Reduced.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Reduced\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Reduced.\n */\ncljs.core.__GT_Reduced \x3d (function cljs$core$__GT_Reduced(val){\nreturn (new cljs.core.Reduced(val));\n});\n\n/**\n * Wraps x in a way such that a reduce will terminate with the value x\n */\ncljs.core.reduced \x3d (function cljs$core$reduced(x){\nreturn (new cljs.core.Reduced(x));\n});\n/**\n * Returns true if x is the result of a call to reduced\n */\ncljs.core.reduced_QMARK_ \x3d (function cljs$core$reduced_QMARK_(r){\nreturn (r instanceof cljs.core.Reduced);\n});\n/**\n * If x is already reduced?, returns it, else returns (reduced x)\n */\ncljs.core.ensure_reduced \x3d (function cljs$core$ensure_reduced(x){\nif(cljs.core.reduced_QMARK_(x)){\nreturn x;\n} else {\nreturn cljs.core.reduced(x);\n}\n});\n/**\n * If x is reduced?, returns (deref x), else returns x\n */\ncljs.core.unreduced \x3d (function cljs$core$unreduced(x){\nif(cljs.core.reduced_QMARK_(x)){\nreturn (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));\n} else {\nreturn x;\n}\n});\n/**\n * Also reader macro: @var/@atom/@delay. Returns the\n * most-recently-committed value of ref. When applied to a var\n * or atom, returns its current state. When applied to a delay, forces\n * it if not already forced. See also - realized?.\n */\ncljs.core.deref \x3d (function cljs$core$deref(o){\nreturn cljs.core._deref(o);\n});\n/**\n * Accepts any collection which satisfies the ICount and IIndexed protocols and\n * reduces them without incurring seq initialization\n */\ncljs.core.ci_reduce \x3d (function cljs$core$ci_reduce(var_args){\nvar G__17533 \x3d arguments.length;\nswitch (G__17533) {\ncase 2:\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2 \x3d (function (cicoll,f){\nvar cnt \x3d cicoll.cljs$core$ICounted$_count$arity$1(null, );\nif((cnt \x3d\x3d\x3d (0))){\nreturn (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n} else {\nvar val \x3d cicoll.cljs$core$IIndexed$_nth$arity$2(null, (0));\nvar n \x3d (1);\nwhile(true){\nif((n \x3c cnt)){\nvar nval \x3d (function (){var G__17534 \x3d val;\nvar G__17535 \x3d cicoll.cljs$core$IIndexed$_nth$arity$2(null, n);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17534,G__17535) : f.call(null, G__17534,G__17535));\n})();\nif(cljs.core.reduced_QMARK_(nval)){\nreturn cljs.core.deref(nval);\n} else {\nvar G__21477 \x3d nval;\nvar G__21478 \x3d (n + (1));\nval \x3d G__21477;\nn \x3d G__21478;\ncontinue;\n}\n} else {\nreturn val;\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3 \x3d (function (cicoll,f,val){\nvar cnt \x3d cicoll.cljs$core$ICounted$_count$arity$1(null, );\nvar val__$1 \x3d val;\nvar n \x3d (0);\nwhile(true){\nif((n \x3c cnt)){\nvar nval \x3d (function (){var G__17536 \x3d val__$1;\nvar G__17537 \x3d cicoll.cljs$core$IIndexed$_nth$arity$2(null, n);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17536,G__17537) : f.call(null, G__17536,G__17537));\n})();\nif(cljs.core.reduced_QMARK_(nval)){\nreturn cljs.core.deref(nval);\n} else {\nvar G__21480 \x3d nval;\nvar G__21481 \x3d (n + (1));\nval__$1 \x3d G__21480;\nn \x3d G__21481;\ncontinue;\n}\n} else {\nreturn val__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.ci_reduce.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.array_reduce \x3d (function cljs$core$array_reduce(var_args){\nvar G__17539 \x3d arguments.length;\nswitch (G__17539) {\ncase 2:\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2 \x3d (function (arr,f){\nvar cnt \x3d arr.length;\nif((arr.length \x3d\x3d\x3d (0))){\nreturn (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n} else {\nvar val \x3d (arr[(0)]);\nvar n \x3d (1);\nwhile(true){\nif((n \x3c cnt)){\nvar nval \x3d (function (){var G__17540 \x3d val;\nvar G__17541 \x3d (arr[n]);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17540,G__17541) : f.call(null, G__17540,G__17541));\n})();\nif(cljs.core.reduced_QMARK_(nval)){\nreturn cljs.core.deref(nval);\n} else {\nvar G__21514 \x3d nval;\nvar G__21515 \x3d (n + (1));\nval \x3d G__21514;\nn \x3d G__21515;\ncontinue;\n}\n} else {\nreturn val;\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3 \x3d (function (arr,f,val){\nvar cnt \x3d arr.length;\nvar val__$1 \x3d val;\nvar n \x3d (0);\nwhile(true){\nif((n \x3c cnt)){\nvar nval \x3d (function (){var G__17542 \x3d val__$1;\nvar G__17543 \x3d (arr[n]);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17542,G__17543) : f.call(null, G__17542,G__17543));\n})();\nif(cljs.core.reduced_QMARK_(nval)){\nreturn cljs.core.deref(nval);\n} else {\nvar G__21517 \x3d nval;\nvar G__21518 \x3d (n + (1));\nval__$1 \x3d G__21517;\nn \x3d G__21518;\ncontinue;\n}\n} else {\nreturn val__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4 \x3d (function (arr,f,val,idx){\nvar cnt \x3d arr.length;\nvar val__$1 \x3d val;\nvar n \x3d idx;\nwhile(true){\nif((n \x3c cnt)){\nvar nval \x3d (function (){var G__17544 \x3d val__$1;\nvar G__17545 \x3d (arr[n]);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17544,G__17545) : f.call(null, G__17544,G__17545));\n})();\nif(cljs.core.reduced_QMARK_(nval)){\nreturn cljs.core.deref(nval);\n} else {\nvar G__21520 \x3d nval;\nvar G__21521 \x3d (n + (1));\nval__$1 \x3d G__21520;\nn \x3d G__21521;\ncontinue;\n}\n} else {\nreturn val__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.array_reduce.cljs$lang$maxFixedArity \x3d 4);\n\n\n\n\n\n\n\n/**\n * Returns true if coll implements count in constant time\n */\ncljs.core.counted_QMARK_ \x3d (function cljs$core$counted_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (2))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$ICounted$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ICounted,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ICounted,x);\n}\n});\n/**\n * Returns true if coll implements nth in constant time\n */\ncljs.core.indexed_QMARK_ \x3d (function cljs$core$indexed_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (16))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IIndexed$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,x);\n}\n});\ncljs.core._indexOf \x3d (function cljs$core$_indexOf(var_args){\nvar G__17549 \x3d arguments.length;\nswitch (G__17549) {\ncase 2:\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core._indexOf.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,x){\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n}));\n\n(cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,x,start){\nvar len \x3d (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));\nif((start \x3e\x3d len)){\nreturn (-1);\n} else {\nvar idx \x3d (((start \x3e (0)))?start:(((start \x3c (0)))?(function (){var x__5087__auto__ \x3d (0);\nvar y__5088__auto__ \x3d (start + len);\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})():start\n));\nwhile(true){\nif((idx \x3c len)){\nif(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)){\nreturn idx;\n} else {\nvar G__21529 \x3d (idx + (1));\nidx \x3d G__21529;\ncontinue;\n}\n} else {\nreturn (-1);\n}\nbreak;\n}\n}\n}));\n\n(cljs.core._indexOf.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core._lastIndexOf \x3d (function cljs$core$_lastIndexOf(var_args){\nvar G__17551 \x3d arguments.length;\nswitch (G__17551) {\ncase 2:\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,x){\nreturn 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)));\n}));\n\n(cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,x,start){\nvar len \x3d (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));\nif((len \x3d\x3d\x3d (0))){\nreturn (-1);\n} else {\nvar idx \x3d (((start \x3e (0)))?(function (){var x__5090__auto__ \x3d (len - (1));\nvar y__5091__auto__ \x3d start;\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})():(((start \x3c (0)))?(len + start):start\n));\nwhile(true){\nif((idx \x3e\x3d (0))){\nif(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)){\nreturn idx;\n} else {\nvar G__21536 \x3d (idx - (1));\nidx \x3d G__21536;\ncontinue;\n}\n} else {\nreturn (-1);\n}\nbreak;\n}\n}\n}));\n\n(cljs.core._lastIndexOf.cljs$lang$maxFixedArity \x3d 3);\n\n\n/**\n* @constructor\n*/\ncljs.core.IndexedSeqIterator \x3d (function (arr,i){\nthis.arr \x3d arr;\nthis.i \x3d i;\n});\n(cljs.core.IndexedSeqIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.i \x3c self__.arr.length);\n}));\n\n(cljs.core.IndexedSeqIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d (self__.arr[self__.i]);\n(self__.i \x3d (self__.i + (1)));\n\nreturn ret;\n}));\n\n(cljs.core.IndexedSeqIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.IndexedSeqIterator.cljs$lang$type \x3d true);\n\n(cljs.core.IndexedSeqIterator.cljs$lang$ctorStr \x3d \x22cljs.core/IndexedSeqIterator\x22);\n\n(cljs.core.IndexedSeqIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/IndexedSeqIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/IndexedSeqIterator.\n */\ncljs.core.__GT_IndexedSeqIterator \x3d (function cljs$core$__GT_IndexedSeqIterator(arr,i){\nreturn (new cljs.core.IndexedSeqIterator(arr,i));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IDrop}\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ASeq}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.IndexedSeq \x3d (function (arr,i,meta){\nthis.arr \x3d arr;\nthis.i \x3d i;\nthis.meta \x3d meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 166592766;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 401408;\n});\n(cljs.core.IndexedSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.IndexedSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.IndexedSeq.prototype.indexOf \x3d (function() {\nvar G__21539 \x3d null;\nvar G__21539__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__21539__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__21539 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__21539__1.call(this,x);\ncase 2:\nreturn G__21539__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__21539.cljs$core$IFn$_invoke$arity$1 \x3d G__21539__1;\nG__21539.cljs$core$IFn$_invoke$arity$2 \x3d G__21539__2;\nreturn G__21539;\n})()\n);\n\n(cljs.core.IndexedSeq.prototype.lastIndexOf \x3d (function() {\nvar G__21542 \x3d null;\nvar G__21542__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn 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)));\n});\nvar G__21542__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__21542 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__21542__1.call(this,x);\ncase 2:\nreturn G__21542__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__21542.cljs$core$IFn$_invoke$arity$1 \x3d G__21542__1;\nG__21542.cljs$core$IFn$_invoke$arity$2 \x3d G__21542__2;\nreturn G__21542;\n})()\n);\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar i__$1 \x3d (n + self__.i);\nif(((((0) \x3c\x3d i__$1)) \x26\x26 ((i__$1 \x3c self__.arr.length)))){\nreturn (self__.arr[i__$1]);\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n}\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (coll,n,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar i__$1 \x3d (n + self__.i);\nif(((((0) \x3c\x3d i__$1)) \x26\x26 ((i__$1 \x3c self__.arr.length)))){\nreturn (self__.arr[i__$1]);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.IndexedSeqIterator(self__.arr,self__.i));\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.IndexedSeq(self__.arr,self__.i,self__.meta));\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(((self__.i + (1)) \x3c self__.arr.length)){\nreturn (new cljs.core.IndexedSeq(self__.arr,(self__.i + (1)),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar x__5087__auto__ \x3d (0);\nvar y__5088__auto__ \x3d (self__.arr.length - self__.i);\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar c \x3d coll__$1.cljs$core$ICounted$_count$arity$1(null, );\nif((c \x3e (0))){\nreturn (new cljs.core.RSeq(coll__$1,(c - (1)),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.hash_ordered_coll(coll__$1);\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (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));\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,(self__.arr[self__.i]),(self__.i + (1)));\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,start,self__.i);\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (self__.arr[self__.i]);\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(((self__.i + (1)) \x3c self__.arr.length)){\nreturn (new cljs.core.IndexedSeq(self__.arr,(self__.i + (1)),null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((self__.i \x3c self__.arr.length)){\nreturn this$__$1;\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.IndexedSeq(self__.arr,self__.i,new_meta));\n}\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (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));\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IDrop$_drop$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((n \x3e (0))){\nif(((self__.i + n) \x3c self__.arr.length)){\nreturn (new cljs.core.IndexedSeq(self__.arr,(self__.i + n),null));\n} else {\nreturn null;\n}\n} else {\nreturn coll__$1;\n}\n}));\n\n(cljs.core.IndexedSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null)], null);\n}));\n\n(cljs.core.IndexedSeq.cljs$lang$type \x3d true);\n\n(cljs.core.IndexedSeq.cljs$lang$ctorStr \x3d \x22cljs.core/IndexedSeq\x22);\n\n(cljs.core.IndexedSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/IndexedSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/IndexedSeq.\n */\ncljs.core.__GT_IndexedSeq \x3d (function cljs$core$__GT_IndexedSeq(arr,i,meta){\nreturn (new cljs.core.IndexedSeq(arr,i,meta));\n});\n\n(cljs.core.IndexedSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Create seq from a primitive JavaScript Array-like.\n */\ncljs.core.prim_seq \x3d (function cljs$core$prim_seq(var_args){\nvar G__17553 \x3d arguments.length;\nswitch (G__17553) {\ncase 1:\nreturn cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$1 \x3d (function (prim){\nreturn cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(prim,(0));\n}));\n\n(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2 \x3d (function (prim,i){\nif((i \x3c prim.length)){\nreturn (new cljs.core.IndexedSeq(prim,i,null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.prim_seq.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Create a seq from a JavaScript array.\n */\ncljs.core.array_seq \x3d (function cljs$core$array_seq(var_args){\nvar G__17555 \x3d arguments.length;\nswitch (G__17555) {\ncase 1:\nreturn cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.array_seq.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1 \x3d (function (array){\nreturn cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(array,(0));\n}));\n\n(cljs.core.array_seq.cljs$core$IFn$_invoke$arity$2 \x3d (function (array,i){\nreturn cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(array,i);\n}));\n\n(cljs.core.array_seq.cljs$lang$maxFixedArity \x3d 2);\n\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.RSeq \x3d (function (ci,i,meta){\nthis.ci \x3d ci;\nthis.i \x3d i;\nthis.meta \x3d meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374990;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 8192;\n});\n(cljs.core.RSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.RSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.RSeq.prototype.indexOf \x3d (function() {\nvar G__21559 \x3d null;\nvar G__21559__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__21559__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__21559 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__21559__1.call(this,x);\ncase 2:\nreturn G__21559__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__21559.cljs$core$IFn$_invoke$arity$1 \x3d G__21559__1;\nG__21559.cljs$core$IFn$_invoke$arity$2 \x3d G__21559__2;\nreturn G__21559;\n})()\n);\n\n(cljs.core.RSeq.prototype.lastIndexOf \x3d (function() {\nvar G__21560 \x3d null;\nvar G__21560__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn 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)));\n});\nvar G__21560__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__21560 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__21560__1.call(this,x);\ncase 2:\nreturn G__21560__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__21560.cljs$core$IFn$_invoke$arity$1 \x3d G__21560__1;\nG__21560.cljs$core$IFn$_invoke$arity$2 \x3d G__21560__2;\nreturn G__21560;\n})()\n);\n\n(cljs.core.RSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.RSeq(self__.ci,self__.i,self__.meta));\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.i \x3e (0))){\nreturn (new cljs.core.RSeq(self__.ci,(self__.i - (1)),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (self__.i + (1));\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.hash_ordered_coll(coll__$1);\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (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));\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (col,f){\nvar self__ \x3d this;\nvar col__$1 \x3d this;\nreturn (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));\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (col,f,start){\nvar self__ \x3d this;\nvar col__$1 \x3d this;\nreturn (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));\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._nth(self__.ci,self__.i);\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.i \x3e (0))){\nreturn (new cljs.core.RSeq(self__.ci,(self__.i - (1)),null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.RSeq(self__.ci,self__.i,new_meta));\n}\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (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));\n}));\n\n(cljs.core.RSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22ci\x22,\x22ci\x22,2049808339,null),new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null)], null);\n}));\n\n(cljs.core.RSeq.cljs$lang$type \x3d true);\n\n(cljs.core.RSeq.cljs$lang$ctorStr \x3d \x22cljs.core/RSeq\x22);\n\n(cljs.core.RSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/RSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/RSeq.\n */\ncljs.core.__GT_RSeq \x3d (function cljs$core$__GT_RSeq(ci,i,meta){\nreturn (new cljs.core.RSeq(ci,i,meta));\n});\n\n(cljs.core.RSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Same as (first (next x))\n */\ncljs.core.second \x3d (function cljs$core$second(coll){\nreturn cljs.core.first(cljs.core.next(coll));\n});\n/**\n * Same as (first (first x))\n */\ncljs.core.ffirst \x3d (function cljs$core$ffirst(coll){\nreturn cljs.core.first(cljs.core.first(coll));\n});\n/**\n * Same as (next (first x))\n */\ncljs.core.nfirst \x3d (function cljs$core$nfirst(coll){\nreturn cljs.core.next(cljs.core.first(coll));\n});\n/**\n * Same as (first (next x))\n */\ncljs.core.fnext \x3d (function cljs$core$fnext(coll){\nreturn cljs.core.first(cljs.core.next(coll));\n});\n/**\n * Same as (next (next x))\n */\ncljs.core.nnext \x3d (function cljs$core$nnext(coll){\nreturn cljs.core.next(cljs.core.next(coll));\n});\n/**\n * Return the last item in coll, in linear time\n */\ncljs.core.last \x3d (function cljs$core$last(s){\nwhile(true){\nvar sn \x3d cljs.core.next(s);\nif((!((sn \x3d\x3d null)))){\nvar G__21568 \x3d sn;\ns \x3d G__21568;\ncontinue;\n} else {\nreturn cljs.core.first(s);\n}\nbreak;\n}\n});\n(cljs.core.IEquiv[\x22_\x22] \x3d true);\n\n(cljs.core._equiv[\x22_\x22] \x3d (function (x,o){\nreturn (x \x3d\x3d\x3d o);\n}));\n/**\n * conj[oin]. Returns a new collection with the xs\n *   \x27added\x27. (conj nil item) returns (item).\n *   (conj coll) returns coll. (conj) returns [].\n *   The \x27addition\x27 may happen at different \x27places\x27 depending\n *   on the concrete type.\n */\ncljs.core.conj \x3d (function cljs$core$conj(var_args){\nvar G__17560 \x3d arguments.length;\nswitch (G__17560) {\ncase 0:\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___21570 \x3d arguments.length;\nvar i__5727__auto___21571 \x3d (0);\nwhile(true){\nif((i__5727__auto___21571 \x3c len__5726__auto___21570)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___21571]));\n\nvar G__21572 \x3d (i__5727__auto___21571 + (1));\ni__5727__auto___21571 \x3d G__21572;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.conj.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cljs.core.conj.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nreturn coll;\n}));\n\n(cljs.core.conj.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,x){\nif((!((coll \x3d\x3d null)))){\nreturn cljs.core._conj(coll,x);\n} else {\nreturn (new cljs.core.List(null,x,null,(1),null));\n}\n}));\n\n(cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic \x3d (function (coll,x,xs){\nwhile(true){\nif(cljs.core.truth_(xs)){\nvar G__21574 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(coll,x);\nvar G__21575 \x3d cljs.core.first(xs);\nvar G__21576 \x3d cljs.core.next(xs);\ncoll \x3d G__21574;\nx \x3d G__21575;\nxs \x3d G__21576;\ncontinue;\n} else {\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(coll,x);\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.conj.cljs$lang$applyTo \x3d (function (seq17557){\nvar G__17558 \x3d cljs.core.first(seq17557);\nvar seq17557__$1 \x3d cljs.core.next(seq17557);\nvar G__17559 \x3d cljs.core.first(seq17557__$1);\nvar seq17557__$2 \x3d cljs.core.next(seq17557__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17558,G__17559,seq17557__$2);\n}));\n\n(cljs.core.conj.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns an empty collection of the same category as coll, or nil\n */\ncljs.core.empty \x3d (function cljs$core$empty(coll){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (4))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IEmptyableCollection$))))?true:false):false)){\nreturn coll.cljs$core$IEmptyableCollection$_empty$arity$1(null, );\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (4))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IEmptyableCollection$))))?true:(((!coll.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IEmptyableCollection,coll):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IEmptyableCollection,coll))){\nreturn cljs.core._empty(coll);\n} else {\nreturn null;\n\n}\n}\n}\n});\ncljs.core.accumulating_seq_count \x3d (function cljs$core$accumulating_seq_count(coll){\nvar s \x3d cljs.core.seq(coll);\nvar acc \x3d (0);\nwhile(true){\nif(cljs.core.counted_QMARK_(s)){\nreturn (acc + cljs.core._count(s));\n} else {\nvar G__21577 \x3d cljs.core.next(s);\nvar G__21578 \x3d (acc + (1));\ns \x3d G__21577;\nacc \x3d G__21578;\ncontinue;\n}\nbreak;\n}\n});\n/**\n * Returns the number of items in the collection. (count nil) returns\n *   0.  Also works on strings, arrays, and Maps\n */\ncljs.core.count \x3d (function cljs$core$count(coll){\nif((!((coll \x3d\x3d null)))){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (2))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ICounted$))))?true:false):false)){\nreturn coll.cljs$core$ICounted$_count$arity$1(null, );\n} else {\nif(cljs.core.array_QMARK_(coll)){\nreturn coll.length;\n} else {\nif(typeof coll \x3d\x3d\x3d \x27string\x27){\nreturn coll.length;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (8388608))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISeqable$))))?true:false):false)){\nreturn cljs.core.accumulating_seq_count(coll);\n} else {\nreturn cljs.core._count(coll);\n\n}\n}\n}\n}\n} else {\nreturn (0);\n}\n});\ncljs.core.linear_traversal_nth \x3d (function cljs$core$linear_traversal_nth(var_args){\nvar G__17566 \x3d arguments.length;\nswitch (G__17566) {\ncase 2:\nreturn cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,n){\nwhile(true){\nif((coll \x3d\x3d null)){\nthrow (new Error(\x22Index out of bounds\x22));\n} else {\nif((n \x3d\x3d\x3d (0))){\nif(cljs.core.seq(coll)){\nreturn cljs.core.first(coll);\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n}\n} else {\nif(cljs.core.indexed_QMARK_(coll)){\nreturn cljs.core._nth(coll,n);\n} else {\nif(cljs.core.seq(coll)){\nvar G__21582 \x3d cljs.core.next(coll);\nvar G__21583 \x3d (n - (1));\ncoll \x3d G__21582;\nn \x3d G__21583;\ncontinue;\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n\n}\n}\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,n,not_found){\nwhile(true){\nif((coll \x3d\x3d null)){\nreturn not_found;\n} else {\nif((n \x3d\x3d\x3d (0))){\nif(cljs.core.seq(coll)){\nreturn cljs.core.first(coll);\n} else {\nreturn not_found;\n}\n} else {\nif(cljs.core.indexed_QMARK_(coll)){\nreturn cljs.core._nth(coll,n,not_found);\n} else {\nif(cljs.core.seq(coll)){\nvar G__21584 \x3d cljs.core.next(coll);\nvar G__21585 \x3d (n - (1));\nvar G__21586 \x3d not_found;\ncoll \x3d G__21584;\nn \x3d G__21585;\nnot_found \x3d G__21586;\ncontinue;\n} else {\nreturn not_found;\n\n}\n}\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.linear_traversal_nth.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns the value at the index. get returns nil if index out of\n *   bounds, nth throws an exception unless not-found is supplied.  nth\n *   also works for strings, arrays, regex Matchers and Lists, and,\n *   in O(n) time, for sequences.\n */\ncljs.core.nth \x3d (function cljs$core$nth(var_args){\nvar G__17568 \x3d arguments.length;\nswitch (G__17568) {\ncase 2:\nreturn cljs.core.nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.nth.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.nth.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,n){\nif((!(typeof n \x3d\x3d\x3d \x27number\x27))){\nthrow (new Error(\x22Index argument to nth must be a number\x22));\n} else {\nif((coll \x3d\x3d null)){\nreturn coll;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (16))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IIndexed$))))?true:false):false)){\nreturn coll.cljs$core$IIndexed$_nth$arity$2(null, n);\n} else {\nif(cljs.core.array_QMARK_(coll)){\nif(((((-1) \x3c n)) \x26\x26 ((n \x3c coll.length)))){\nreturn (coll[(n | (0))]);\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n}\n} else {\nif(typeof coll \x3d\x3d\x3d \x27string\x27){\nif(((((-1) \x3c n)) \x26\x26 ((n \x3c coll.length)))){\nreturn coll.charAt((n | (0)));\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n}\n} else {\nif((function (){var or__5002__auto__ \x3d (((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (64))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISeq$))))?true:false):false);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nif((!((coll \x3d\x3d null)))){\nif((((coll.cljs$lang$protocol_mask$partition0$ \x26 (16777216))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISequential$)))){\nreturn true;\n} else {\nreturn false;\n}\n} else {\nreturn false;\n}\n}\n})()){\nif((n \x3c (0))){\nthrow (new Error(\x22Index out of bounds\x22));\n} else {\nreturn cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2(coll,n);\n}\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,coll)){\nreturn cljs.core._nth(coll,n);\n} else {\nthrow (new Error([\x22nth not supported on this type \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.type__GT_str(cljs.core.type(coll)))].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n}\n}));\n\n(cljs.core.nth.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,n,not_found){\nif((!(typeof n \x3d\x3d\x3d \x27number\x27))){\nthrow (new Error(\x22Index argument to nth must be a number.\x22));\n} else {\nif((coll \x3d\x3d null)){\nreturn not_found;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (16))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IIndexed$))))?true:false):false)){\nreturn coll.cljs$core$IIndexed$_nth$arity$3(null, n,not_found);\n} else {\nif(cljs.core.array_QMARK_(coll)){\nif(((((-1) \x3c n)) \x26\x26 ((n \x3c coll.length)))){\nreturn (coll[(n | (0))]);\n} else {\nreturn not_found;\n}\n} else {\nif(typeof coll \x3d\x3d\x3d \x27string\x27){\nif(((((-1) \x3c n)) \x26\x26 ((n \x3c coll.length)))){\nreturn coll.charAt((n | (0)));\n} else {\nreturn not_found;\n}\n} else {\nif((function (){var or__5002__auto__ \x3d (((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (64))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISeq$))))?true:false):false);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nif((!((coll \x3d\x3d null)))){\nif((((coll.cljs$lang$protocol_mask$partition0$ \x26 (16777216))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISequential$)))){\nreturn true;\n} else {\nreturn false;\n}\n} else {\nreturn false;\n}\n}\n})()){\nif((n \x3c (0))){\nreturn not_found;\n} else {\nreturn cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3(coll,n,not_found);\n}\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,coll)){\nreturn cljs.core._nth(coll,n,not_found);\n} else {\nthrow (new Error([\x22nth not supported on this type \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.type__GT_str(cljs.core.type(coll)))].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n}\n}));\n\n(cljs.core.nth.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns the nth rest of coll, coll when n is 0.\n */\ncljs.core.nthrest \x3d (function cljs$core$nthrest(coll,n){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition1$ \x26 (262144))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IDrop$))))?true:false):false)){\nif((n \x3e (0))){\nvar or__5002__auto__ \x3d coll.cljs$core$IDrop$_drop$arity$2(null, Math.ceil(n));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n} else {\nreturn coll;\n}\n} else {\nvar n__$1 \x3d n;\nvar xs \x3d coll;\nwhile(true){\nvar temp__5802__auto__ \x3d (((n__$1 \x3e (0))) \x26\x26 (cljs.core.seq(xs)));\nif(temp__5802__auto__){\nvar xs__$1 \x3d temp__5802__auto__;\nvar G__21601 \x3d (n__$1 - (1));\nvar G__21602 \x3d cljs.core.rest(xs__$1);\nn__$1 \x3d G__21601;\nxs \x3d G__21602;\ncontinue;\n} else {\nreturn xs;\n}\nbreak;\n}\n}\n});\n/**\n * Returns the value mapped to key, not-found or nil if key not present\n *   in associative collection, set, string, array, or ILookup instance.\n */\ncljs.core.get \x3d (function cljs$core$get(var_args){\nvar G__17577 \x3d arguments.length;\nswitch (G__17577) {\ncase 2:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.get.cljs$core$IFn$_invoke$arity$2 \x3d (function (o,k){\nif((o \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((o \x3d\x3d null))))?(((((o.cljs$lang$protocol_mask$partition0$ \x26 (256))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d o.cljs$core$ILookup$))))?true:false):false)){\nreturn o.cljs$core$ILookup$_lookup$arity$2(null, k);\n} else {\nif(cljs.core.array_QMARK_(o)){\nif((((!((k \x3d\x3d null)))) \x26\x26 ((k \x3c o.length)))){\nreturn (o[(k | (0))]);\n} else {\nreturn null;\n}\n} else {\nif(typeof o \x3d\x3d\x3d \x27string\x27){\nif((((!((k \x3d\x3d null)))) \x26\x26 (((((-1) \x3c k)) \x26\x26 ((k \x3c o.length)))))){\nreturn o.charAt((k | (0)));\n} else {\nreturn null;\n}\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.ILookup,o)){\nreturn cljs.core._lookup(o,k);\n} else {\nreturn null;\n\n}\n}\n}\n}\n}\n}));\n\n(cljs.core.get.cljs$core$IFn$_invoke$arity$3 \x3d (function (o,k,not_found){\nif((!((o \x3d\x3d null)))){\nif((((!((o \x3d\x3d null))))?(((((o.cljs$lang$protocol_mask$partition0$ \x26 (256))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d o.cljs$core$ILookup$))))?true:false):false)){\nreturn o.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n} else {\nif(cljs.core.array_QMARK_(o)){\nif((((!((k \x3d\x3d null)))) \x26\x26 (((((-1) \x3c k)) \x26\x26 ((k \x3c o.length)))))){\nreturn (o[(k | (0))]);\n} else {\nreturn not_found;\n}\n} else {\nif(typeof o \x3d\x3d\x3d \x27string\x27){\nif((((!((k \x3d\x3d null)))) \x26\x26 (((((-1) \x3c k)) \x26\x26 ((k \x3c o.length)))))){\nreturn o.charAt((k | (0)));\n} else {\nreturn not_found;\n}\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.ILookup,o)){\nreturn cljs.core._lookup(o,k,not_found);\n} else {\nreturn not_found;\n\n}\n}\n}\n}\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.get.cljs$lang$maxFixedArity \x3d 3);\n\n\n\n/**\n * assoc[iate]. When applied to a map, returns a new map of the\n * same (hashed/sorted) type, that contains the mapping of key(s) to\n * val(s). When applied to a vector, returns a new vector that\n * contains val at index. Note - index must be \x3c\x3d (count vector).\n */\ncljs.core.assoc \x3d (function cljs$core$assoc(var_args){\nvar G__17585 \x3d arguments.length;\nswitch (G__17585) {\ncase 3:\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___21613 \x3d arguments.length;\nvar i__5727__auto___21614 \x3d (0);\nwhile(true){\nif((i__5727__auto___21614 \x3c len__5726__auto___21613)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___21614]));\n\nvar G__21615 \x3d (i__5727__auto___21614 + (1));\ni__5727__auto___21614 \x3d G__21615;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.assoc.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,k,v){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (512))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IAssociative$))))?true:false):false)){\nreturn coll.cljs$core$IAssociative$_assoc$arity$3(null, k,v);\n} else {\nif((!((coll \x3d\x3d null)))){\nreturn cljs.core._assoc(coll,k,v);\n} else {\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([k,v]);\n}\n}\n}));\n\n(cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic \x3d (function (coll,k,v,kvs){\nwhile(true){\nvar ret \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(coll,k,v);\nif(cljs.core.truth_(kvs)){\nvar G__21621 \x3d ret;\nvar G__21622 \x3d cljs.core.first(kvs);\nvar G__21623 \x3d cljs.core.second(kvs);\nvar G__21624 \x3d cljs.core.nnext(kvs);\ncoll \x3d G__21621;\nk \x3d G__21622;\nv \x3d G__21623;\nkvs \x3d G__21624;\ncontinue;\n} else {\nreturn ret;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.assoc.cljs$lang$applyTo \x3d (function (seq17581){\nvar G__17582 \x3d cljs.core.first(seq17581);\nvar seq17581__$1 \x3d cljs.core.next(seq17581);\nvar G__17583 \x3d cljs.core.first(seq17581__$1);\nvar seq17581__$2 \x3d cljs.core.next(seq17581__$1);\nvar G__17584 \x3d cljs.core.first(seq17581__$2);\nvar seq17581__$3 \x3d cljs.core.next(seq17581__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17582,G__17583,G__17584,seq17581__$3);\n}));\n\n(cljs.core.assoc.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n *   that does not contain a mapping for key(s).\n */\ncljs.core.dissoc \x3d (function cljs$core$dissoc(var_args){\nvar G__17591 \x3d arguments.length;\nswitch (G__17591) {\ncase 1:\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___21630 \x3d arguments.length;\nvar i__5727__auto___21633 \x3d (0);\nwhile(true){\nif((i__5727__auto___21633 \x3c len__5726__auto___21630)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___21633]));\n\nvar G__21636 \x3d (i__5727__auto___21633 + (1));\ni__5727__auto___21633 \x3d G__21636;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nreturn coll;\n}));\n\n(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,k){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core._dissoc(coll,k);\n}\n}));\n\n(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic \x3d (function (coll,k,ks){\nwhile(true){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nvar ret \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(coll,k);\nif(cljs.core.truth_(ks)){\nvar G__21638 \x3d ret;\nvar G__21639 \x3d cljs.core.first(ks);\nvar G__21640 \x3d cljs.core.next(ks);\ncoll \x3d G__21638;\nk \x3d G__21639;\nks \x3d G__21640;\ncontinue;\n} else {\nreturn ret;\n}\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.dissoc.cljs$lang$applyTo \x3d (function (seq17588){\nvar G__17589 \x3d cljs.core.first(seq17588);\nvar seq17588__$1 \x3d cljs.core.next(seq17588);\nvar G__17590 \x3d cljs.core.first(seq17588__$1);\nvar seq17588__$2 \x3d cljs.core.next(seq17588__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17589,G__17590,seq17588__$2);\n}));\n\n(cljs.core.dissoc.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Return true if f is a JavaScript function or satisfies the Fn protocol.\n */\ncljs.core.fn_QMARK_ \x3d (function cljs$core$fn_QMARK_(f){\nvar or__5002__auto__ \x3d typeof f \x3d\x3d\x3d \x27function\x27;\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nif((!((f \x3d\x3d null)))){\nif(((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d f.cljs$core$Fn$)))){\nreturn true;\n} else {\nif((!f.cljs$lang$protocol_mask$partition$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.Fn,f);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.Fn,f);\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.Fn}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.MetaFn \x3d (function (afn,meta){\nthis.afn \x3d afn;\nthis.meta \x3d meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393217;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.MetaFn.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_,new_meta){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.MetaFn(self__.afn,new_meta));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$Fn$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.MetaFn.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__17594 \x3d (arguments.length - (1));\nswitch (G__17594) {\ncase (0):\nreturn self__.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase (3):\nreturn self__.cljs$core$IFn$_invoke$arity$3((arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase (4):\nreturn self__.cljs$core$IFn$_invoke$arity$4((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase (5):\nreturn self__.cljs$core$IFn$_invoke$arity$5((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ncase (6):\nreturn self__.cljs$core$IFn$_invoke$arity$6((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]));\n\nbreak;\ncase (7):\nreturn self__.cljs$core$IFn$_invoke$arity$7((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]));\n\nbreak;\ncase (8):\nreturn self__.cljs$core$IFn$_invoke$arity$8((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]));\n\nbreak;\ncase (9):\nreturn self__.cljs$core$IFn$_invoke$arity$9((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]));\n\nbreak;\ncase (10):\nreturn self__.cljs$core$IFn$_invoke$arity$10((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]));\n\nbreak;\ncase (11):\nreturn self__.cljs$core$IFn$_invoke$arity$11((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]));\n\nbreak;\ncase (12):\nreturn self__.cljs$core$IFn$_invoke$arity$12((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]));\n\nbreak;\ncase (13):\nreturn self__.cljs$core$IFn$_invoke$arity$13((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)]));\n\nbreak;\ncase (14):\nreturn self__.cljs$core$IFn$_invoke$arity$14((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)]));\n\nbreak;\ncase (15):\nreturn self__.cljs$core$IFn$_invoke$arity$15((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)]));\n\nbreak;\ncase (16):\nreturn self__.cljs$core$IFn$_invoke$arity$16((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)]));\n\nbreak;\ncase (17):\nreturn self__.cljs$core$IFn$_invoke$arity$17((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)]));\n\nbreak;\ncase (18):\nreturn self__.cljs$core$IFn$_invoke$arity$18((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)]));\n\nbreak;\ncase (19):\nreturn self__.cljs$core$IFn$_invoke$arity$19((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)]));\n\nbreak;\ncase (20):\nreturn self__.cljs$core$IFn$_invoke$arity$20((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)]));\n\nbreak;\ncase (21):\nreturn self__.cljs$core$IFn$_invoke$arity$21((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)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.MetaFn.prototype.apply \x3d (function (self__,args17593){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args17593)));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.afn.cljs$core$IFn$_invoke$arity$0 ? self__.afn.cljs$core$IFn$_invoke$arity$0() : self__.afn.call(null, ));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (a){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.afn.cljs$core$IFn$_invoke$arity$1 ? self__.afn.cljs$core$IFn$_invoke$arity$1(a) : self__.afn.call(null, a));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (a,b){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.afn.cljs$core$IFn$_invoke$arity$2 ? self__.afn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.afn.call(null, a,b));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$3 \x3d (function (a,b,c){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$4 \x3d (function (a,b,c,d){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$5 \x3d (function (a,b,c,d,e){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$6 \x3d (function (a,b,c,d,e,f){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$7 \x3d (function (a,b,c,d,e,f,g){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$8 \x3d (function (a,b,c,d,e,f,g,h){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$9 \x3d (function (a,b,c,d,e,f,g,h,i){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$10 \x3d (function (a,b,c,d,e,f,g,h,i,j){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$11 \x3d (function (a,b,c,d,e,f,g,h,i,j,k){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$12 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$13 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$14 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$15 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$16 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$17 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$18 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$19 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$20 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (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));\n}));\n\n(cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$21 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$21 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$21(self__.afn,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s, new cljs.core.IndexedSeq([t,rest],0,null)) : 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));\n}));\n\n(cljs.core.MetaFn.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22afn\x22,\x22afn\x22,216963467,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null)], null);\n}));\n\n(cljs.core.MetaFn.cljs$lang$type \x3d true);\n\n(cljs.core.MetaFn.cljs$lang$ctorStr \x3d \x22cljs.core/MetaFn\x22);\n\n(cljs.core.MetaFn.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/MetaFn\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/MetaFn.\n */\ncljs.core.__GT_MetaFn \x3d (function cljs$core$__GT_MetaFn(afn,meta){\nreturn (new cljs.core.MetaFn(afn,meta));\n});\n\n/**\n * Returns an object of the same type and value as obj, with\n *   map m as its metadata.\n */\ncljs.core.with_meta \x3d (function cljs$core$with_meta(o,meta){\nif(typeof o \x3d\x3d\x3d \x27function\x27){\nreturn (new cljs.core.MetaFn(o,meta));\n} else {\nif((o \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core._with_meta(o,meta);\n}\n}\n});\n/**\n * Returns the metadata of obj, returns nil if there is no metadata.\n */\ncljs.core.meta \x3d (function cljs$core$meta(o){\nif((function (){var and__5000__auto__ \x3d (!((o \x3d\x3d null)));\nif(and__5000__auto__){\nif((!((o \x3d\x3d null)))){\nif((((o.cljs$lang$protocol_mask$partition0$ \x26 (131072))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d o.cljs$core$IMeta$)))){\nreturn true;\n} else {\nif((!o.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IMeta,o);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IMeta,o);\n}\n} else {\nreturn and__5000__auto__;\n}\n})()){\nreturn cljs.core._meta(o);\n} else {\nreturn null;\n}\n});\n/**\n * For a list or queue, same as first, for a vector, same as, but much\n *   more efficient than, last. If the collection is empty, returns nil.\n */\ncljs.core.peek \x3d (function cljs$core$peek(coll){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core._peek(coll);\n}\n});\n/**\n * For a list or queue, returns a new list/queue without the first\n *   item, for a vector, returns a new vector without the last item.\n *   Note - not the same as next/butlast.\n */\ncljs.core.pop \x3d (function cljs$core$pop(coll){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core._pop(coll);\n}\n});\n/**\n * disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n *   does not contain key(s).\n */\ncljs.core.disj \x3d (function cljs$core$disj(var_args){\nvar G__17600 \x3d arguments.length;\nswitch (G__17600) {\ncase 1:\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___21785 \x3d arguments.length;\nvar i__5727__auto___21786 \x3d (0);\nwhile(true){\nif((i__5727__auto___21786 \x3c len__5726__auto___21785)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___21786]));\n\nvar G__21787 \x3d (i__5727__auto___21786 + (1));\ni__5727__auto___21786 \x3d G__21787;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.disj.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nreturn coll;\n}));\n\n(cljs.core.disj.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,k){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core._disjoin(coll,k);\n}\n}));\n\n(cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic \x3d (function (coll,k,ks){\nwhile(true){\nif((coll \x3d\x3d null)){\nreturn null;\n} else {\nvar ret \x3d cljs.core.disj.cljs$core$IFn$_invoke$arity$2(coll,k);\nif(cljs.core.truth_(ks)){\nvar G__21788 \x3d ret;\nvar G__21789 \x3d cljs.core.first(ks);\nvar G__21790 \x3d cljs.core.next(ks);\ncoll \x3d G__21788;\nk \x3d G__21789;\nks \x3d G__21790;\ncontinue;\n} else {\nreturn ret;\n}\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.disj.cljs$lang$applyTo \x3d (function (seq17597){\nvar G__17598 \x3d cljs.core.first(seq17597);\nvar seq17597__$1 \x3d cljs.core.next(seq17597);\nvar G__17599 \x3d cljs.core.first(seq17597__$1);\nvar seq17597__$2 \x3d cljs.core.next(seq17597__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17598,G__17599,seq17597__$2);\n}));\n\n(cljs.core.disj.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns true if coll has no items. To check the emptiness of a seq,\n *   please use the idiom (seq x) rather than (not (empty? x))\n */\ncljs.core.empty_QMARK_ \x3d (function cljs$core$empty_QMARK_(coll){\nif((coll \x3d\x3d null)){\nreturn true;\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (2))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ICounted$))))?true:(((!coll.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ICounted,coll):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ICounted,coll))){\nreturn (cljs.core._count(coll) \x3d\x3d\x3d (0));\n} else {\nreturn cljs.core.not(cljs.core.seq(coll));\n\n}\n}\n});\n/**\n * Returns true if x satisfies ICollection\n */\ncljs.core.coll_QMARK_ \x3d (function cljs$core$coll_QMARK_(x){\nif((x \x3d\x3d null)){\nreturn false;\n} else {\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (8))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$ICollection$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ICollection,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ICollection,x);\n}\n}\n});\n/**\n * Returns true if x satisfies ISet\n */\ncljs.core.set_QMARK_ \x3d (function cljs$core$set_QMARK_(x){\nif((x \x3d\x3d null)){\nreturn false;\n} else {\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (4096))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$ISet$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x);\n}\n}\n});\n/**\n * Returns true if coll implements IAssociative\n */\ncljs.core.associative_QMARK_ \x3d (function cljs$core$associative_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (512))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IAssociative$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IAssociative,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IAssociative,x);\n}\n});\n/**\n * Returns true if coll implements IFind\n */\ncljs.core.ifind_QMARK_ \x3d (function cljs$core$ifind_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif(((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IFind$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IFind,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IFind,x);\n}\n});\n/**\n * Returns true if coll satisfies ISequential\n */\ncljs.core.sequential_QMARK_ \x3d (function cljs$core$sequential_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (16777216))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$ISequential$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x);\n}\n});\n/**\n * Returns true if coll satisfies ISorted\n */\ncljs.core.sorted_QMARK_ \x3d (function cljs$core$sorted_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (268435456))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$ISorted$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISorted,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISorted,x);\n}\n});\n/**\n * Returns true if coll satisfies IReduce\n */\ncljs.core.reduceable_QMARK_ \x3d (function cljs$core$reduceable_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (524288))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IReduce$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,x);\n}\n});\n/**\n * Return true if x satisfies IMap\n */\ncljs.core.map_QMARK_ \x3d (function cljs$core$map_QMARK_(x){\nif((x \x3d\x3d null)){\nreturn false;\n} else {\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (1024))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IMap$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x);\n}\n}\n});\n/**\n * Return true if x satisfies IRecord\n */\ncljs.core.record_QMARK_ \x3d (function cljs$core$record_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (67108864))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IRecord$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IRecord,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IRecord,x);\n}\n});\n/**\n * Return true if x satisfies IVector\n */\ncljs.core.vector_QMARK_ \x3d (function cljs$core$vector_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (16384))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IVector$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IVector,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IVector,x);\n}\n});\n\n/**\n * Return true if x satisfies IChunkedSeq.\n */\ncljs.core.chunked_seq_QMARK_ \x3d (function cljs$core$chunked_seq_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition1$ \x26 (512))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IChunkedSeq$)))){\nreturn true;\n} else {\nreturn false;\n}\n} else {\nreturn false;\n}\n});\n/**\n * Create JavaSript object from an even number arguments representing\n *   interleaved keys and values.\n */\ncljs.core.js_obj \x3d (function cljs$core$js_obj(var_args){\nvar G__17615 \x3d arguments.length;\nswitch (G__17615) {\ncase 0:\nreturn cljs.core.js_obj.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___21822 \x3d arguments.length;\nvar i__5727__auto___21823 \x3d (0);\nwhile(true){\nif((i__5727__auto___21823 \x3c len__5726__auto___21822)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___21823]));\n\nvar G__21824 \x3d (i__5727__auto___21823 + (1));\ni__5727__auto___21823 \x3d G__21824;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((0) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.js_obj.cljs$core$IFn$_invoke$arity$variadic(argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.js_obj.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn ({});\n}));\n\n(cljs.core.js_obj.cljs$core$IFn$_invoke$arity$variadic \x3d (function (keyvals){\nreturn (cljs.core.apply.cljs$core$IFn$_invoke$arity$2 ? cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.goog$module$goog$object.create,keyvals) : cljs.core.apply.call(null, cljs.core.goog$module$goog$object.create,keyvals));\n}));\n\n/** @this {Function} */\n(cljs.core.js_obj.cljs$lang$applyTo \x3d (function (seq17614){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq17614));\n}));\n\n(cljs.core.js_obj.cljs$lang$maxFixedArity \x3d (0));\n\n/**\n * Return the JavaScript keys for an object.\n */\ncljs.core.js_keys \x3d (function cljs$core$js_keys(obj){\nreturn cljs.core.goog$module$goog$object.getKeys(obj);\n});\n/**\n * Delete a property from a JavaScript object.\n *   Returns true upon success, false otherwise.\n */\ncljs.core.js_delete \x3d (function cljs$core$js_delete(obj,key){\nreturn delete obj[key];\n});\ncljs.core.array_copy \x3d (function cljs$core$array_copy(from,i,to,j,len){\nvar i__$1 \x3d i;\nvar j__$1 \x3d j;\nvar len__$1 \x3d len;\nwhile(true){\nif((len__$1 \x3d\x3d\x3d (0))){\nreturn to;\n} else {\n(to[j__$1] \x3d (from[i__$1]));\n\nvar G__21835 \x3d (i__$1 + (1));\nvar G__21836 \x3d (j__$1 + (1));\nvar G__21837 \x3d (len__$1 - (1));\ni__$1 \x3d G__21835;\nj__$1 \x3d G__21836;\nlen__$1 \x3d G__21837;\ncontinue;\n}\nbreak;\n}\n});\ncljs.core.array_copy_downward \x3d (function cljs$core$array_copy_downward(from,i,to,j,len){\nvar i__$1 \x3d (i + (len - (1)));\nvar j__$1 \x3d (j + (len - (1)));\nvar len__$1 \x3d len;\nwhile(true){\nif((len__$1 \x3d\x3d\x3d (0))){\nreturn to;\n} else {\n(to[j__$1] \x3d (from[i__$1]));\n\nvar G__21841 \x3d (i__$1 - (1));\nvar G__21842 \x3d (j__$1 - (1));\nvar G__21843 \x3d (len__$1 - (1));\ni__$1 \x3d G__21841;\nj__$1 \x3d G__21842;\nlen__$1 \x3d G__21843;\ncontinue;\n}\nbreak;\n}\n});\ncljs.core.lookup_sentinel \x3d ({});\n/**\n * Returns true if x is the value false, false otherwise.\n */\ncljs.core.false_QMARK_ \x3d (function cljs$core$false_QMARK_(x){\nreturn x \x3d\x3d\x3d false;\n});\n/**\n * Returns true if x is the value true, false otherwise.\n */\ncljs.core.true_QMARK_ \x3d (function cljs$core$true_QMARK_(x){\nreturn x \x3d\x3d\x3d true;\n});\n/**\n * Return true if x is a Boolean\n */\ncljs.core.boolean_QMARK_ \x3d (function cljs$core$boolean_QMARK_(x){\nreturn ((x \x3d\x3d\x3d true) || (x \x3d\x3d\x3d false));\n});\n/**\n * Returns true if x identical to the JavaScript undefined value.\n */\ncljs.core.undefined_QMARK_ \x3d (function cljs$core$undefined_QMARK_(x){\nreturn (void 0 \x3d\x3d\x3d x);\n});\n/**\n * Return true if s satisfies ISeq\n */\ncljs.core.seq_QMARK_ \x3d (function cljs$core$seq_QMARK_(s){\nif((s \x3d\x3d null)){\nreturn false;\n} else {\nif((!((s \x3d\x3d null)))){\nif((((s.cljs$lang$protocol_mask$partition0$ \x26 (64))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d s.cljs$core$ISeq$)))){\nreturn true;\n} else {\nif((!s.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISeq,s);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.ISeq,s);\n}\n}\n});\n/**\n * Return true if the seq function is supported for s\n */\ncljs.core.seqable_QMARK_ \x3d (function cljs$core$seqable_QMARK_(s){\nvar or__5002__auto__ \x3d (s \x3d\x3d null);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (((!((s \x3d\x3d null))))?(((((s.cljs$lang$protocol_mask$partition0$ \x26 (8388608))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d 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));\nif(or__5002__auto____$1){\nreturn or__5002__auto____$1;\n} else {\nreturn ((cljs.core.array_QMARK_(s)) || (typeof s \x3d\x3d\x3d \x27string\x27));\n}\n}\n});\n/**\n * Coerce to boolean\n */\ncljs.core.boolean$ \x3d (function cljs$core$boolean(x){\nif((x \x3d\x3d null)){\nreturn false;\n} else {\nif(x \x3d\x3d\x3d false){\nreturn false;\n} else {\nreturn true;\n\n}\n}\n});\n/**\n * Returns true if f returns true for fn? or satisfies IFn.\n */\ncljs.core.ifn_QMARK_ \x3d (function cljs$core$ifn_QMARK_(f){\nvar or__5002__auto__ \x3d cljs.core.fn_QMARK_(f);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nif((!((f \x3d\x3d null)))){\nif((((f.cljs$lang$protocol_mask$partition0$ \x26 (1))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d f.cljs$core$IFn$)))){\nreturn true;\n} else {\nif((!f.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IFn,f);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IFn,f);\n}\n}\n});\n/**\n * Returns true if n is a JavaScript number with no decimal part.\n */\ncljs.core.integer_QMARK_ \x3d (function cljs$core$integer_QMARK_(n){\nreturn ((typeof n \x3d\x3d\x3d \x27number\x27) \x26\x26 ((((!(isNaN(n)))) \x26\x26 ((((!((n \x3d\x3d\x3d Infinity)))) \x26\x26 ((parseFloat(n) \x3d\x3d\x3d parseInt(n,(10)))))))));\n});\n/**\n * INTERNAL: do not use\n */\ncljs.core.LongImpl \x3d cljs.core.goog$module$goog$math$Long;\n/**\n * Return true if x satisfies integer? or is an instance of goog.math.Integer\n * or goog.math.Long.\n */\ncljs.core.int_QMARK_ \x3d (function cljs$core$int_QMARK_(x){\nreturn ((cljs.core.integer_QMARK_(x)) || ((((x instanceof goog.math.Integer)) || ((x instanceof cljs.core.goog$module$goog$math$Long)))));\n});\n/**\n * Return true if x satisfies int? and is positive.\n */\ncljs.core.pos_int_QMARK_ \x3d (function cljs$core$pos_int_QMARK_(x){\nif(cljs.core.integer_QMARK_(x)){\nreturn (x \x3e (0));\n} else {\nif((x instanceof goog.math.Integer)){\nreturn ((cljs.core.not(x.isNegative())) \x26\x26 (cljs.core.not(x.isZero())));\n} else {\nif((x instanceof cljs.core.goog$module$goog$math$Long)){\nreturn ((cljs.core.not(x.isNegative())) \x26\x26 (cljs.core.not(x.isZero())));\n} else {\nreturn false;\n\n}\n}\n}\n});\n/**\n * Return true if x satisfies int? and is negative.\n */\ncljs.core.neg_int_QMARK_ \x3d (function cljs$core$neg_int_QMARK_(x){\nif(cljs.core.integer_QMARK_(x)){\nreturn (x \x3c (0));\n} else {\nif((x instanceof goog.math.Integer)){\nreturn x.isNegative();\n} else {\nif((x instanceof cljs.core.goog$module$goog$math$Long)){\nreturn x.isNegative();\n} else {\nreturn false;\n\n}\n}\n}\n});\n/**\n * Return true if x satisfies int? and is a natural integer value.\n */\ncljs.core.nat_int_QMARK_ \x3d (function cljs$core$nat_int_QMARK_(x){\nif(cljs.core.integer_QMARK_(x)){\nreturn (!((x \x3c (0))));\n} else {\nif((x instanceof goog.math.Integer)){\nreturn cljs.core.not(x.isNegative());\n} else {\nif((x instanceof cljs.core.goog$module$goog$math$Long)){\nreturn cljs.core.not(x.isNegative());\n} else {\nreturn false;\n\n}\n}\n}\n});\n/**\n * Returns true for JavaScript numbers, false otherwise.\n */\ncljs.core.float_QMARK_ \x3d (function cljs$core$float_QMARK_(x){\nreturn typeof x \x3d\x3d\x3d \x27number\x27;\n});\n/**\n * Returns true for JavaScript numbers, false otherwise.\n */\ncljs.core.double_QMARK_ \x3d (function cljs$core$double_QMARK_(x){\nreturn typeof x \x3d\x3d\x3d \x27number\x27;\n});\n/**\n * Returns true for Infinity and -Infinity values.\n */\ncljs.core.infinite_QMARK_ \x3d (function cljs$core$infinite_QMARK_(x){\nreturn (((x \x3d\x3d\x3d Number.POSITIVE_INFINITY)) || ((x \x3d\x3d\x3d Number.NEGATIVE_INFINITY)));\n});\n/**\n * Returns true if key is present in the given collection, otherwise\n *   returns false.  Note that for numerically indexed collections like\n *   vectors and arrays, this tests if the numeric key is within the\n *   range of indexes. \x27contains?\x27 operates constant or logarithmic time;\n *   it will not perform a linear search for a value.  See also \x27some\x27.\n */\ncljs.core.contains_QMARK_ \x3d (function cljs$core$contains_QMARK_(coll,v){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (512))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IAssociative$))))?true:false):false)){\nreturn coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(null, v);\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.IAssociative,coll)){\nreturn cljs.core._contains_key_QMARK_(coll,v);\n} else {\nif((cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll,v,cljs.core.lookup_sentinel) \x3d\x3d\x3d cljs.core.lookup_sentinel)){\nreturn false;\n} else {\nreturn true;\n\n}\n}\n}\n});\n/**\n * Returns the map entry for key, or nil if key not present.\n */\ncljs.core.find \x3d (function cljs$core$find(coll,k){\nif(cljs.core.ifind_QMARK_(coll)){\nreturn cljs.core._find(coll,k);\n} else {\nif((((!((coll \x3d\x3d null)))) \x26\x26 (((cljs.core.associative_QMARK_(coll)) \x26\x26 (cljs.core.contains_QMARK_(coll,k)))))){\nreturn (new cljs.core.MapEntry(k,cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll,k),null));\n} else {\nreturn null;\n}\n}\n});\n/**\n * Returns true if no two of the arguments are \x3d\n */\ncljs.core.distinct_QMARK_ \x3d (function cljs$core$distinct_QMARK_(var_args){\nvar G__17628 \x3d arguments.length;\nswitch (G__17628) {\ncase 1:\nreturn cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___21887 \x3d arguments.length;\nvar i__5727__auto___21889 \x3d (0);\nwhile(true){\nif((i__5727__auto___21889 \x3c len__5726__auto___21887)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___21889]));\n\nvar G__21891 \x3d (i__5727__auto___21889 + (1));\ni__5727__auto___21889 \x3d G__21891;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn true;\n}));\n\n(cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)));\n}));\n\n(cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nif((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)))){\nvar s \x3d cljs.core.PersistentHashSet.createAsIfByAssoc([x,y]);\nvar xs \x3d more;\nwhile(true){\nvar x__$1 \x3d cljs.core.first(xs);\nvar etc \x3d cljs.core.next(xs);\nif(cljs.core.truth_(xs)){\nif(cljs.core.contains_QMARK_(s,x__$1)){\nreturn false;\n} else {\nvar G__21922 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(s,x__$1);\nvar G__21923 \x3d etc;\ns \x3d G__21922;\nxs \x3d G__21923;\ncontinue;\n}\n} else {\nreturn true;\n}\nbreak;\n}\n} else {\nreturn false;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.distinct_QMARK_.cljs$lang$applyTo \x3d (function (seq17625){\nvar G__17626 \x3d cljs.core.first(seq17625);\nvar seq17625__$1 \x3d cljs.core.next(seq17625);\nvar G__17627 \x3d cljs.core.first(seq17625__$1);\nvar seq17625__$2 \x3d cljs.core.next(seq17625__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17626,G__17627,seq17625__$2);\n}));\n\n(cljs.core.distinct_QMARK_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Comparator. Returns a negative number, zero, or a positive number\n *   when x is logically \x27less than\x27, \x27equal to\x27, or \x27greater than\x27\n *   y. Uses IComparable if available and google.array.defaultCompare for objects\n *  of the same type and special-cases nil to be less than any other object.\n */\ncljs.core.compare \x3d (function cljs$core$compare(x,y){\nif((x \x3d\x3d\x3d y)){\nreturn (0);\n} else {\nif((x \x3d\x3d null)){\nreturn (-1);\n} else {\nif((y \x3d\x3d null)){\nreturn (1);\n} else {\nif(typeof x \x3d\x3d\x3d \x27number\x27){\nif(typeof y \x3d\x3d\x3d \x27number\x27){\nreturn cljs.core.goog$module$goog$array.defaultCompare(x,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n} else {\nif((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition1$ \x26 (2048))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d 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))){\nreturn cljs.core._compare(x,y);\n} else {\nif(((((typeof x \x3d\x3d\x3d \x27string\x27) || (((cljs.core.array_QMARK_(x)) || (((x \x3d\x3d\x3d true) || (x \x3d\x3d\x3d false))))))) \x26\x26 ((cljs.core.type(x) \x3d\x3d\x3d cljs.core.type(y))))){\nreturn cljs.core.goog$module$goog$array.defaultCompare(x,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n\n}\n}\n}\n}\n}\n});\n/**\n * Compare indexed collection.\n */\ncljs.core.compare_indexed \x3d (function cljs$core$compare_indexed(var_args){\nvar G__17631 \x3d arguments.length;\nswitch (G__17631) {\ncase 2:\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 4:\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2 \x3d (function (xs,ys){\nvar xl \x3d cljs.core.count(xs);\nvar yl \x3d cljs.core.count(ys);\nif((xl \x3c yl)){\nreturn (-1);\n} else {\nif((xl \x3e yl)){\nreturn (1);\n} else {\nif((xl \x3d\x3d\x3d (0))){\nreturn (0);\n} else {\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4(xs,ys,xl,(0));\n\n}\n}\n}\n}));\n\n(cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4 \x3d (function (xs,ys,len,n){\nwhile(true){\nvar d \x3d 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));\nif((((d \x3d\x3d\x3d (0))) \x26\x26 (((n + (1)) \x3c len)))){\nvar G__21946 \x3d xs;\nvar G__21947 \x3d ys;\nvar G__21948 \x3d len;\nvar G__21949 \x3d (n + (1));\nxs \x3d G__21946;\nys \x3d G__21947;\nlen \x3d G__21948;\nn \x3d G__21949;\ncontinue;\n} else {\nreturn d;\n}\nbreak;\n}\n}));\n\n(cljs.core.compare_indexed.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Given a fn that might be boolean valued or a comparator,\n * return a fn that is a comparator.\n */\ncljs.core.fn__GT_comparator \x3d (function cljs$core$fn__GT_comparator(f){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(f,cljs.core.compare)){\nreturn cljs.core.compare;\n} else {\nreturn (function (x,y){\nvar r \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null, x,y));\nif(typeof r \x3d\x3d\x3d \x27number\x27){\nreturn r;\n} else {\nif(cljs.core.truth_(r)){\nreturn (-1);\n} else {\nif(cljs.core.truth_((f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(y,x) : f.call(null, y,x)))){\nreturn (1);\n} else {\nreturn (0);\n}\n}\n}\n});\n}\n});\n/**\n * Returns a sorted sequence of the items in coll. Comp can be\n * boolean-valued comparison function, or a -/0/+ valued comparator.\n * Comp defaults to compare.\n */\ncljs.core.sort \x3d (function cljs$core$sort(var_args){\nvar G__17633 \x3d arguments.length;\nswitch (G__17633) {\ncase 1:\nreturn cljs.core.sort.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.sort.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.sort.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nreturn cljs.core.sort.cljs$core$IFn$_invoke$arity$2(cljs.core.compare,coll);\n}));\n\n(cljs.core.sort.cljs$core$IFn$_invoke$arity$2 \x3d (function (comp,coll){\nif(cljs.core.seq(coll)){\nvar a \x3d (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));\ncljs.core.goog$module$goog$array.stableSort(a,cljs.core.fn__GT_comparator(comp));\n\nreturn cljs.core.with_meta(cljs.core.seq(a),cljs.core.meta(coll));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.sort.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a sorted sequence of the items in coll, where the sort\n * order is determined by comparing (keyfn item).  Comp can be\n * boolean-valued comparison function, or a -/0/+ valued comparator.\n * Comp defaults to compare.\n */\ncljs.core.sort_by \x3d (function cljs$core$sort_by(var_args){\nvar G__17635 \x3d arguments.length;\nswitch (G__17635) {\ncase 2:\nreturn cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2 \x3d (function (keyfn,coll){\nreturn cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3(keyfn,cljs.core.compare,coll);\n}));\n\n(cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3 \x3d (function (keyfn,comp,coll){\nreturn cljs.core.sort.cljs$core$IFn$_invoke$arity$2((function (x,y){\nvar G__17637 \x3d (keyfn.cljs$core$IFn$_invoke$arity$1 ? keyfn.cljs$core$IFn$_invoke$arity$1(x) : keyfn.call(null, x));\nvar G__17638 \x3d (keyfn.cljs$core$IFn$_invoke$arity$1 ? keyfn.cljs$core$IFn$_invoke$arity$1(y) : keyfn.call(null, y));\nvar fexpr__17636 \x3d cljs.core.fn__GT_comparator(comp);\nreturn (fexpr__17636.cljs$core$IFn$_invoke$arity$2 ? fexpr__17636.cljs$core$IFn$_invoke$arity$2(G__17637,G__17638) : fexpr__17636.call(null, G__17637,G__17638));\n}),coll);\n}));\n\n(cljs.core.sort_by.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.seq_reduce \x3d (function cljs$core$seq_reduce(var_args){\nvar G__17640 \x3d arguments.length;\nswitch (G__17640) {\ncase 2:\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nvar temp__5802__auto__ \x3d cljs.core.seq(coll);\nif(temp__5802__auto__){\nvar s \x3d temp__5802__auto__;\nvar G__17641 \x3d f;\nvar G__17642 \x3d cljs.core.first(s);\nvar G__17643 \x3d cljs.core.next(s);\nreturn (cljs.core.reduce.cljs$core$IFn$_invoke$arity$3 ? cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(G__17641,G__17642,G__17643) : cljs.core.reduce.call(null, G__17641,G__17642,G__17643));\n} else {\nreturn (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n}\n}));\n\n(cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,val,coll){\nvar val__$1 \x3d val;\nvar coll__$1 \x3d cljs.core.seq(coll);\nwhile(true){\nif(coll__$1){\nvar nval \x3d (function (){var G__17644 \x3d val__$1;\nvar G__17645 \x3d cljs.core.first(coll__$1);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17644,G__17645) : f.call(null, G__17644,G__17645));\n})();\nif(cljs.core.reduced_QMARK_(nval)){\nreturn cljs.core.deref(nval);\n} else {\nvar G__21977 \x3d nval;\nvar G__21978 \x3d cljs.core.next(coll__$1);\nval__$1 \x3d G__21977;\ncoll__$1 \x3d G__21978;\ncontinue;\n}\n} else {\nreturn val__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.seq_reduce.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Return a random permutation of coll\n */\ncljs.core.shuffle \x3d (function cljs$core$shuffle(coll){\nvar a \x3d (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));\ncljs.core.goog$module$goog$array.shuffle(a);\n\nreturn (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));\n});\ncljs.core.iter_reduce \x3d (function cljs$core$iter_reduce(var_args){\nvar G__17647 \x3d arguments.length;\nswitch (G__17647) {\ncase 2:\nreturn cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,f){\nvar iter \x3d cljs.core._iterator(coll);\nif(cljs.core.truth_(iter.hasNext())){\nvar init \x3d iter.next();\nvar acc \x3d init;\nwhile(true){\nif(iter.hasNext()){\nvar nacc \x3d (function (){var G__17648 \x3d acc;\nvar G__17649 \x3d iter.next();\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17648,G__17649) : f.call(null, G__17648,G__17649));\n})();\nif(cljs.core.reduced_QMARK_(nacc)){\nreturn cljs.core.deref(nacc);\n} else {\nvar G__21983 \x3d nacc;\nacc \x3d G__21983;\ncontinue;\n}\n} else {\nreturn acc;\n}\nbreak;\n}\n} else {\nreturn (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n}\n}));\n\n(cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3 \x3d (function (coll,f,init){\nvar iter \x3d cljs.core._iterator(coll);\nvar acc \x3d init;\nwhile(true){\nif(iter.hasNext()){\nvar nacc \x3d (function (){var G__17650 \x3d acc;\nvar G__17651 \x3d iter.next();\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17650,G__17651) : f.call(null, G__17650,G__17651));\n})();\nif(cljs.core.reduced_QMARK_(nacc)){\nreturn cljs.core.deref(nacc);\n} else {\nvar G__21984 \x3d nacc;\nacc \x3d G__21984;\ncontinue;\n}\n} else {\nreturn acc;\n}\nbreak;\n}\n}));\n\n(cljs.core.iter_reduce.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * f should be a function of 2 arguments. If val is not supplied,\n *   returns the result of applying f to the first 2 items in coll, then\n *   applying f to that result and the 3rd item, etc. If coll contains no\n *   items, f must accept no arguments as well, and reduce returns the\n *   result of calling f with no arguments.  If coll has only 1 item, it\n *   is returned and f is not called.  If val is supplied, returns the\n *   result of applying f to val and the first item in coll, then\n *   applying f to that result and the 2nd item, etc. If coll contains no\n *   items, returns val and f is not called.\n */\ncljs.core.reduce \x3d (function cljs$core$reduce(var_args){\nvar G__17653 \x3d arguments.length;\nswitch (G__17653) {\ncase 2:\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.reduce.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (524288))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IReduce$))))?true:false):false)){\nreturn coll.cljs$core$IReduce$_reduce$arity$2(null, f);\n} else {\nif(cljs.core.array_QMARK_(coll)){\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2(coll,f);\n} else {\nif(typeof coll \x3d\x3d\x3d \x27string\x27){\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2(coll,f);\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,coll)){\nreturn cljs.core._reduce(coll,f);\n} else {\nif(cljs.core.iterable_QMARK_(coll)){\nreturn cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2(coll,f);\n} else {\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll);\n\n}\n}\n}\n}\n}\n}));\n\n(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,val,coll){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (524288))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IReduce$))))?true:false):false)){\nreturn coll.cljs$core$IReduce$_reduce$arity$3(null, f,val);\n} else {\nif(cljs.core.array_QMARK_(coll)){\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3(coll,f,val);\n} else {\nif(typeof coll \x3d\x3d\x3d \x27string\x27){\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3(coll,f,val);\n} else {\nif(cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,coll)){\nreturn cljs.core._reduce(coll,f,val);\n} else {\nif(cljs.core.iterable_QMARK_(coll)){\nreturn cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3(coll,f,val);\n} else {\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,val,coll);\n\n}\n}\n}\n}\n}\n}));\n\n(cljs.core.reduce.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Reduces an associative collection. f should be a function of 3\n *   arguments. Returns the result of applying f to init, the first key\n *   and the first value in coll, then applying f to that result and the\n *   2nd key and value, etc. If coll contains no entries, returns init\n *   and f is not called. Note that reduce-kv is supported on vectors,\n *   where the keys will be the ordinals.\n */\ncljs.core.reduce_kv \x3d (function cljs$core$reduce_kv(f,init,coll){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (1048576))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IKVReduce$))))?true:(((!coll.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IKVReduce,coll):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IKVReduce,coll))){\nreturn cljs.core._kv_reduce(coll,f,init);\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret,me){\nvar G__17657 \x3d ret;\nvar G__17658 \x3d cljs.core._key(me);\nvar G__17659 \x3d cljs.core._val(me);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__17657,G__17658,G__17659) : f.call(null, G__17657,G__17658,G__17659));\n}),init,coll);\n}\n});\n/**\n * Returns its argument.\n */\ncljs.core.identity \x3d (function cljs$core$identity(x){\nreturn x;\n});\n/**\n * Takes a reducing function f of 2 args and returns a fn suitable for\n *   transduce by adding an arity-1 signature that calls cf (default -\n *   identity) on the result argument.\n */\ncljs.core.completing \x3d (function cljs$core$completing(var_args){\nvar G__17661 \x3d arguments.length;\nswitch (G__17661) {\ncase 1:\nreturn cljs.core.completing.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.completing.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.completing.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn cljs.core.completing.cljs$core$IFn$_invoke$arity$2(f,cljs.core.identity);\n}));\n\n(cljs.core.completing.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,cf){\nreturn (function() {\nvar G__22007 \x3d null;\nvar G__22007__0 \x3d (function (){\nreturn (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n});\nvar G__22007__1 \x3d (function (x){\nreturn (cf.cljs$core$IFn$_invoke$arity$1 ? cf.cljs$core$IFn$_invoke$arity$1(x) : cf.call(null, x));\n});\nvar G__22007__2 \x3d (function (x,y){\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null, x,y));\n});\nG__22007 \x3d function(x,y){\nswitch(arguments.length){\ncase 0:\nreturn G__22007__0.call(this);\ncase 1:\nreturn G__22007__1.call(this,x);\ncase 2:\nreturn G__22007__2.call(this,x,y);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22007.cljs$core$IFn$_invoke$arity$0 \x3d G__22007__0;\nG__22007.cljs$core$IFn$_invoke$arity$1 \x3d G__22007__1;\nG__22007.cljs$core$IFn$_invoke$arity$2 \x3d G__22007__2;\nreturn G__22007;\n})()\n}));\n\n(cljs.core.completing.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * reduce with a transformation of f (xf). If init is not\n *   supplied, (f) will be called to produce it. f should be a reducing\n *   step function that accepts both 1 and 2 arguments, if it accepts\n *   only 2 you can add the arity-1 with \x27completing\x27. Returns the result\n *   of applying (the transformed) xf to init and the first item in coll,\n *   then applying xf to that result and the 2nd item, etc. If coll\n *   contains no items, returns init and f is not called. Note that\n *   certain transforms may inject or skip items.\n */\ncljs.core.transduce \x3d (function cljs$core$transduce(var_args){\nvar G__17663 \x3d arguments.length;\nswitch (G__17663) {\ncase 3:\nreturn cljs.core.transduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.transduce.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.transduce.cljs$core$IFn$_invoke$arity$3 \x3d (function (xform,f,coll){\nreturn 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);\n}));\n\n(cljs.core.transduce.cljs$core$IFn$_invoke$arity$4 \x3d (function (xform,f,init,coll){\nvar f__$1 \x3d (xform.cljs$core$IFn$_invoke$arity$1 ? xform.cljs$core$IFn$_invoke$arity$1(f) : xform.call(null, f));\nvar ret \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(f__$1,init,coll);\nreturn (f__$1.cljs$core$IFn$_invoke$arity$1 ? f__$1.cljs$core$IFn$_invoke$arity$1(ret) : f__$1.call(null, ret));\n}));\n\n(cljs.core.transduce.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Returns the sum of nums. (+) returns 0.\n */\ncljs.core._PLUS_ \x3d (function cljs$core$_PLUS_(var_args){\nvar G__17668 \x3d arguments.length;\nswitch (G__17668) {\ncase 0:\nreturn cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22023 \x3d arguments.length;\nvar i__5727__auto___22024 \x3d (0);\nwhile(true){\nif((i__5727__auto___22024 \x3c len__5726__auto___22023)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22024]));\n\nvar G__22026 \x3d (i__5727__auto___22024 + (1));\ni__5727__auto___22024 \x3d G__22026;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (0);\n}));\n\n(cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x + y);\n}));\n\n(cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._PLUS_,(x + y),more);\n}));\n\n/** @this {Function} */\n(cljs.core._PLUS_.cljs$lang$applyTo \x3d (function (seq17665){\nvar G__17666 \x3d cljs.core.first(seq17665);\nvar seq17665__$1 \x3d cljs.core.next(seq17665);\nvar G__17667 \x3d cljs.core.first(seq17665__$1);\nvar seq17665__$2 \x3d cljs.core.next(seq17665__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17666,G__17667,seq17665__$2);\n}));\n\n(cljs.core._PLUS_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * If no ys are supplied, returns the negation of x, else subtracts\n *   the ys from x and returns the result.\n */\ncljs.core._ \x3d (function cljs$core$_(var_args){\nvar G__17673 \x3d arguments.length;\nswitch (G__17673) {\ncase 1:\nreturn cljs.core._.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22052 \x3d arguments.length;\nvar i__5727__auto___22053 \x3d (0);\nwhile(true){\nif((i__5727__auto___22053 \x3c len__5726__auto___22052)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22053]));\n\nvar G__22058 \x3d (i__5727__auto___22053 + (1));\ni__5727__auto___22053 \x3d G__22058;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn (- x);\n}));\n\n(cljs.core._.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x - y);\n}));\n\n(cljs.core._.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._,(x - y),more);\n}));\n\n/** @this {Function} */\n(cljs.core._.cljs$lang$applyTo \x3d (function (seq17670){\nvar G__17671 \x3d cljs.core.first(seq17670);\nvar seq17670__$1 \x3d cljs.core.next(seq17670);\nvar G__17672 \x3d cljs.core.first(seq17670__$1);\nvar seq17670__$2 \x3d cljs.core.next(seq17670__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17671,G__17672,seq17670__$2);\n}));\n\n(cljs.core._.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns the product of nums. (*) returns 1.\n */\ncljs.core._STAR_ \x3d (function cljs$core$_STAR_(var_args){\nvar G__17678 \x3d arguments.length;\nswitch (G__17678) {\ncase 0:\nreturn cljs.core._STAR_.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core._STAR_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._STAR_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22078 \x3d arguments.length;\nvar i__5727__auto___22079 \x3d (0);\nwhile(true){\nif((i__5727__auto___22079 \x3c len__5726__auto___22078)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22079]));\n\nvar G__22083 \x3d (i__5727__auto___22079 + (1));\ni__5727__auto___22079 \x3d G__22083;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._STAR_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._STAR_.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (1);\n}));\n\n(cljs.core._STAR_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core._STAR_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x * y);\n}));\n\n(cljs.core._STAR_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._STAR_,(x * y),more);\n}));\n\n/** @this {Function} */\n(cljs.core._STAR_.cljs$lang$applyTo \x3d (function (seq17675){\nvar G__17676 \x3d cljs.core.first(seq17675);\nvar seq17675__$1 \x3d cljs.core.next(seq17675);\nvar G__17677 \x3d cljs.core.first(seq17675__$1);\nvar seq17675__$2 \x3d cljs.core.next(seq17675__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17676,G__17677,seq17675__$2);\n}));\n\n(cljs.core._STAR_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * If no denominators are supplied, returns 1/numerator,\n *   else returns numerator divided by all of the denominators.\n */\ncljs.core._SLASH_ \x3d (function cljs$core$_SLASH_(var_args){\nvar G__17683 \x3d arguments.length;\nswitch (G__17683) {\ncase 1:\nreturn cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22113 \x3d arguments.length;\nvar i__5727__auto___22114 \x3d (0);\nwhile(true){\nif((i__5727__auto___22114 \x3c len__5726__auto___22113)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22114]));\n\nvar G__22115 \x3d (i__5727__auto___22114 + (1));\ni__5727__auto___22114 \x3d G__22115;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn ((1) / x);\n}));\n\n(cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x / y);\n}));\n\n(cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._SLASH_,(x / y),more);\n}));\n\n/** @this {Function} */\n(cljs.core._SLASH_.cljs$lang$applyTo \x3d (function (seq17680){\nvar G__17681 \x3d cljs.core.first(seq17680);\nvar seq17680__$1 \x3d cljs.core.next(seq17680);\nvar G__17682 \x3d cljs.core.first(seq17680__$1);\nvar seq17680__$2 \x3d cljs.core.next(seq17680__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17681,G__17682,seq17680__$2);\n}));\n\n(cljs.core._SLASH_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns non-nil if nums are in monotonically increasing order,\n *   otherwise false.\n */\ncljs.core._LT_ \x3d (function cljs$core$_LT_(var_args){\nvar G__17688 \x3d arguments.length;\nswitch (G__17688) {\ncase 1:\nreturn cljs.core._LT_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._LT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22124 \x3d arguments.length;\nvar i__5727__auto___22125 \x3d (0);\nwhile(true){\nif((i__5727__auto___22125 \x3c len__5726__auto___22124)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22125]));\n\nvar G__22126 \x3d (i__5727__auto___22125 + (1));\ni__5727__auto___22125 \x3d G__22126;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._LT_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._LT_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn true;\n}));\n\n(cljs.core._LT_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x \x3c y);\n}));\n\n(cljs.core._LT_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nwhile(true){\nif((x \x3c y)){\nif(cljs.core.next(more)){\nvar G__22129 \x3d y;\nvar G__22130 \x3d cljs.core.first(more);\nvar G__22131 \x3d cljs.core.next(more);\nx \x3d G__22129;\ny \x3d G__22130;\nmore \x3d G__22131;\ncontinue;\n} else {\nreturn (y \x3c cljs.core.first(more));\n}\n} else {\nreturn false;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core._LT_.cljs$lang$applyTo \x3d (function (seq17685){\nvar G__17686 \x3d cljs.core.first(seq17685);\nvar seq17685__$1 \x3d cljs.core.next(seq17685);\nvar G__17687 \x3d cljs.core.first(seq17685__$1);\nvar seq17685__$2 \x3d cljs.core.next(seq17685__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17686,G__17687,seq17685__$2);\n}));\n\n(cljs.core._LT_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns non-nil if nums are in monotonically non-decreasing order,\n *   otherwise false.\n */\ncljs.core._LT__EQ_ \x3d (function cljs$core$_LT__EQ_(var_args){\nvar G__17693 \x3d arguments.length;\nswitch (G__17693) {\ncase 1:\nreturn cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22137 \x3d arguments.length;\nvar i__5727__auto___22138 \x3d (0);\nwhile(true){\nif((i__5727__auto___22138 \x3c len__5726__auto___22137)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22138]));\n\nvar G__22139 \x3d (i__5727__auto___22138 + (1));\ni__5727__auto___22138 \x3d G__22139;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn true;\n}));\n\n(cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x \x3c\x3d y);\n}));\n\n(cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nwhile(true){\nif((x \x3c\x3d y)){\nif(cljs.core.next(more)){\nvar G__22141 \x3d y;\nvar G__22142 \x3d cljs.core.first(more);\nvar G__22143 \x3d cljs.core.next(more);\nx \x3d G__22141;\ny \x3d G__22142;\nmore \x3d G__22143;\ncontinue;\n} else {\nreturn (y \x3c\x3d cljs.core.first(more));\n}\n} else {\nreturn false;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core._LT__EQ_.cljs$lang$applyTo \x3d (function (seq17690){\nvar G__17691 \x3d cljs.core.first(seq17690);\nvar seq17690__$1 \x3d cljs.core.next(seq17690);\nvar G__17692 \x3d cljs.core.first(seq17690__$1);\nvar seq17690__$2 \x3d cljs.core.next(seq17690__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17691,G__17692,seq17690__$2);\n}));\n\n(cljs.core._LT__EQ_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns non-nil if nums are in monotonically decreasing order,\n *   otherwise false.\n */\ncljs.core._GT_ \x3d (function cljs$core$_GT_(var_args){\nvar G__17698 \x3d arguments.length;\nswitch (G__17698) {\ncase 1:\nreturn cljs.core._GT_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._GT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22148 \x3d arguments.length;\nvar i__5727__auto___22154 \x3d (0);\nwhile(true){\nif((i__5727__auto___22154 \x3c len__5726__auto___22148)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22154]));\n\nvar G__22156 \x3d (i__5727__auto___22154 + (1));\ni__5727__auto___22154 \x3d G__22156;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._GT_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._GT_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn true;\n}));\n\n(cljs.core._GT_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x \x3e y);\n}));\n\n(cljs.core._GT_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nwhile(true){\nif((x \x3e y)){\nif(cljs.core.next(more)){\nvar G__22157 \x3d y;\nvar G__22158 \x3d cljs.core.first(more);\nvar G__22159 \x3d cljs.core.next(more);\nx \x3d G__22157;\ny \x3d G__22158;\nmore \x3d G__22159;\ncontinue;\n} else {\nreturn (y \x3e cljs.core.first(more));\n}\n} else {\nreturn false;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core._GT_.cljs$lang$applyTo \x3d (function (seq17695){\nvar G__17696 \x3d cljs.core.first(seq17695);\nvar seq17695__$1 \x3d cljs.core.next(seq17695);\nvar G__17697 \x3d cljs.core.first(seq17695__$1);\nvar seq17695__$2 \x3d cljs.core.next(seq17695__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17696,G__17697,seq17695__$2);\n}));\n\n(cljs.core._GT_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns non-nil if nums are in monotonically non-increasing order,\n *   otherwise false.\n */\ncljs.core._GT__EQ_ \x3d (function cljs$core$_GT__EQ_(var_args){\nvar G__17703 \x3d arguments.length;\nswitch (G__17703) {\ncase 1:\nreturn cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22167 \x3d arguments.length;\nvar i__5727__auto___22169 \x3d (0);\nwhile(true){\nif((i__5727__auto___22169 \x3c len__5726__auto___22167)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22169]));\n\nvar G__22170 \x3d (i__5727__auto___22169 + (1));\ni__5727__auto___22169 \x3d G__22170;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn true;\n}));\n\n(cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x \x3e\x3d y);\n}));\n\n(cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nwhile(true){\nif((x \x3e\x3d y)){\nif(cljs.core.next(more)){\nvar G__22175 \x3d y;\nvar G__22176 \x3d cljs.core.first(more);\nvar G__22177 \x3d cljs.core.next(more);\nx \x3d G__22175;\ny \x3d G__22176;\nmore \x3d G__22177;\ncontinue;\n} else {\nreturn (y \x3e\x3d cljs.core.first(more));\n}\n} else {\nreturn false;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core._GT__EQ_.cljs$lang$applyTo \x3d (function (seq17700){\nvar G__17701 \x3d cljs.core.first(seq17700);\nvar seq17700__$1 \x3d cljs.core.next(seq17700);\nvar G__17702 \x3d cljs.core.first(seq17700__$1);\nvar seq17700__$2 \x3d cljs.core.next(seq17700__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17701,G__17702,seq17700__$2);\n}));\n\n(cljs.core._GT__EQ_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns a number one less than num.\n */\ncljs.core.dec \x3d (function cljs$core$dec(x){\nreturn (x - (1));\n});\n/**\n * Returns the absolute value of a.\n */\ncljs.core.abs \x3d (function cljs$core$abs(a){\nreturn Math.abs(a);\n});\n/**\n * Returns the greatest of the nums.\n */\ncljs.core.max \x3d (function cljs$core$max(var_args){\nvar G__17708 \x3d arguments.length;\nswitch (G__17708) {\ncase 1:\nreturn cljs.core.max.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.max.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22195 \x3d arguments.length;\nvar i__5727__auto___22196 \x3d (0);\nwhile(true){\nif((i__5727__auto___22196 \x3c len__5726__auto___22195)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22196]));\n\nvar G__22199 \x3d (i__5727__auto___22196 + (1));\ni__5727__auto___22196 \x3d G__22199;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.max.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.max.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core.max.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nvar x__5087__auto__ \x3d x;\nvar y__5088__auto__ \x3d y;\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n}));\n\n(cljs.core.max.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.max,(function (){var x__5087__auto__ \x3d x;\nvar y__5088__auto__ \x3d y;\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})(),more);\n}));\n\n/** @this {Function} */\n(cljs.core.max.cljs$lang$applyTo \x3d (function (seq17705){\nvar G__17706 \x3d cljs.core.first(seq17705);\nvar seq17705__$1 \x3d cljs.core.next(seq17705);\nvar G__17707 \x3d cljs.core.first(seq17705__$1);\nvar seq17705__$2 \x3d cljs.core.next(seq17705__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17706,G__17707,seq17705__$2);\n}));\n\n(cljs.core.max.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns the least of the nums.\n */\ncljs.core.min \x3d (function cljs$core$min(var_args){\nvar G__17713 \x3d arguments.length;\nswitch (G__17713) {\ncase 1:\nreturn cljs.core.min.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.min.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22217 \x3d arguments.length;\nvar i__5727__auto___22218 \x3d (0);\nwhile(true){\nif((i__5727__auto___22218 \x3c len__5726__auto___22217)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22218]));\n\nvar G__22221 \x3d (i__5727__auto___22218 + (1));\ni__5727__auto___22218 \x3d G__22221;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.min.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.min.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core.min.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nvar x__5090__auto__ \x3d x;\nvar y__5091__auto__ \x3d y;\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n}));\n\n(cljs.core.min.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.min,(function (){var x__5090__auto__ \x3d x;\nvar y__5091__auto__ \x3d y;\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})(),more);\n}));\n\n/** @this {Function} */\n(cljs.core.min.cljs$lang$applyTo \x3d (function (seq17710){\nvar G__17711 \x3d cljs.core.first(seq17710);\nvar seq17710__$1 \x3d cljs.core.next(seq17710);\nvar G__17712 \x3d cljs.core.first(seq17710__$1);\nvar seq17710__$2 \x3d cljs.core.next(seq17710__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17711,G__17712,seq17710__$2);\n}));\n\n(cljs.core.min.cljs$lang$maxFixedArity \x3d (2));\n\ncljs.core.byte$ \x3d (function cljs$core$byte(x){\nreturn x;\n});\n/**\n * Coerce to char\n */\ncljs.core.char$ \x3d (function cljs$core$char(x){\nif(typeof x \x3d\x3d\x3d \x27number\x27){\nreturn String.fromCharCode(x);\n} else {\nif(((typeof x \x3d\x3d\x3d \x27string\x27) \x26\x26 ((x.length \x3d\x3d\x3d (1))))){\nreturn x;\n} else {\nthrow (new Error(\x22Argument to char must be a character or number\x22));\n\n}\n}\n});\ncljs.core.short$ \x3d (function cljs$core$short(x){\nreturn x;\n});\ncljs.core.float$ \x3d (function cljs$core$float(x){\nreturn x;\n});\ncljs.core.double$ \x3d (function cljs$core$double(x){\nreturn x;\n});\ncljs.core.unchecked_byte \x3d (function cljs$core$unchecked_byte(x){\nreturn x;\n});\ncljs.core.unchecked_char \x3d (function cljs$core$unchecked_char(x){\nreturn x;\n});\ncljs.core.unchecked_short \x3d (function cljs$core$unchecked_short(x){\nreturn x;\n});\ncljs.core.unchecked_float \x3d (function cljs$core$unchecked_float(x){\nreturn x;\n});\ncljs.core.unchecked_double \x3d (function cljs$core$unchecked_double(x){\nreturn x;\n});\n/**\n * Returns the sum of nums. (+) returns 0.\n */\ncljs.core.unchecked_add \x3d (function cljs$core$unchecked_add(var_args){\nvar G__17718 \x3d arguments.length;\nswitch (G__17718) {\ncase 0:\nreturn cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22253 \x3d arguments.length;\nvar i__5727__auto___22255 \x3d (0);\nwhile(true){\nif((i__5727__auto___22255 \x3c len__5726__auto___22253)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22255]));\n\nvar G__22263 \x3d (i__5727__auto___22255 + (1));\ni__5727__auto___22255 \x3d G__22263;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (0);\n}));\n\n(cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x + y);\n}));\n\n(cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_add,(x + y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.unchecked_add.cljs$lang$applyTo \x3d (function (seq17715){\nvar G__17716 \x3d cljs.core.first(seq17715);\nvar seq17715__$1 \x3d cljs.core.next(seq17715);\nvar G__17717 \x3d cljs.core.first(seq17715__$1);\nvar seq17715__$2 \x3d cljs.core.next(seq17715__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17716,G__17717,seq17715__$2);\n}));\n\n(cljs.core.unchecked_add.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns the sum of nums. (+) returns 0.\n */\ncljs.core.unchecked_add_int \x3d (function cljs$core$unchecked_add_int(var_args){\nvar G__17723 \x3d arguments.length;\nswitch (G__17723) {\ncase 0:\nreturn cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22295 \x3d arguments.length;\nvar i__5727__auto___22296 \x3d (0);\nwhile(true){\nif((i__5727__auto___22296 \x3c len__5726__auto___22295)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22296]));\n\nvar G__22297 \x3d (i__5727__auto___22296 + (1));\ni__5727__auto___22296 \x3d G__22297;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (0);\n}));\n\n(cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x + y);\n}));\n\n(cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_add_int,(x + y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.unchecked_add_int.cljs$lang$applyTo \x3d (function (seq17720){\nvar G__17721 \x3d cljs.core.first(seq17720);\nvar seq17720__$1 \x3d cljs.core.next(seq17720);\nvar G__17722 \x3d cljs.core.first(seq17720__$1);\nvar seq17720__$2 \x3d cljs.core.next(seq17720__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17721,G__17722,seq17720__$2);\n}));\n\n(cljs.core.unchecked_add_int.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns a number one less than x, an int.\n */\ncljs.core.unchecked_dec \x3d (function cljs$core$unchecked_dec(x){\nreturn (x - (1));\n});\n/**\n * Returns a number one less than x, an int.\n */\ncljs.core.unchecked_dec_int \x3d (function cljs$core$unchecked_dec_int(x){\nreturn (x - (1));\n});\n/**\n * If no denominators are supplied, returns 1/numerator,\n *   else returns numerator divided by all of the denominators.\n */\ncljs.core.unchecked_divide_int \x3d (function cljs$core$unchecked_divide_int(var_args){\nvar G__17728 \x3d arguments.length;\nswitch (G__17728) {\ncase 1:\nreturn cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22311 \x3d arguments.length;\nvar i__5727__auto___22312 \x3d (0);\nwhile(true){\nif((i__5727__auto___22312 \x3c len__5726__auto___22311)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22312]));\n\nvar G__22313 \x3d (i__5727__auto___22312 + (1));\ni__5727__auto___22312 \x3d G__22313;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn ((1) / x);\n}));\n\n(cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x / y);\n}));\n\n(cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_divide_int,(x / y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.unchecked_divide_int.cljs$lang$applyTo \x3d (function (seq17725){\nvar G__17726 \x3d cljs.core.first(seq17725);\nvar seq17725__$1 \x3d cljs.core.next(seq17725);\nvar G__17727 \x3d cljs.core.first(seq17725__$1);\nvar seq17725__$2 \x3d cljs.core.next(seq17725__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17726,G__17727,seq17725__$2);\n}));\n\n(cljs.core.unchecked_divide_int.cljs$lang$maxFixedArity \x3d (2));\n\ncljs.core.unchecked_inc \x3d (function cljs$core$unchecked_inc(x){\nreturn (x + (1));\n});\ncljs.core.unchecked_inc_int \x3d (function cljs$core$unchecked_inc_int(x){\nreturn (x + (1));\n});\n/**\n * Returns the product of nums. (*) returns 1.\n */\ncljs.core.unchecked_multiply \x3d (function cljs$core$unchecked_multiply(var_args){\nvar G__17733 \x3d arguments.length;\nswitch (G__17733) {\ncase 0:\nreturn cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22322 \x3d arguments.length;\nvar i__5727__auto___22323 \x3d (0);\nwhile(true){\nif((i__5727__auto___22323 \x3c len__5726__auto___22322)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22323]));\n\nvar G__22324 \x3d (i__5727__auto___22323 + (1));\ni__5727__auto___22323 \x3d G__22324;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (1);\n}));\n\n(cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x * y);\n}));\n\n(cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_multiply,(x * y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.unchecked_multiply.cljs$lang$applyTo \x3d (function (seq17730){\nvar G__17731 \x3d cljs.core.first(seq17730);\nvar seq17730__$1 \x3d cljs.core.next(seq17730);\nvar G__17732 \x3d cljs.core.first(seq17730__$1);\nvar seq17730__$2 \x3d cljs.core.next(seq17730__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17731,G__17732,seq17730__$2);\n}));\n\n(cljs.core.unchecked_multiply.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns the product of nums. (*) returns 1.\n */\ncljs.core.unchecked_multiply_int \x3d (function cljs$core$unchecked_multiply_int(var_args){\nvar G__17738 \x3d arguments.length;\nswitch (G__17738) {\ncase 0:\nreturn cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22341 \x3d arguments.length;\nvar i__5727__auto___22342 \x3d (0);\nwhile(true){\nif((i__5727__auto___22342 \x3c len__5726__auto___22341)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22342]));\n\nvar G__22343 \x3d (i__5727__auto___22342 + (1));\ni__5727__auto___22342 \x3d G__22343;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (1);\n}));\n\n(cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn x;\n}));\n\n(cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x * y);\n}));\n\n(cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_multiply_int,(x * y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.unchecked_multiply_int.cljs$lang$applyTo \x3d (function (seq17735){\nvar G__17736 \x3d cljs.core.first(seq17735);\nvar seq17735__$1 \x3d cljs.core.next(seq17735);\nvar G__17737 \x3d cljs.core.first(seq17735__$1);\nvar seq17735__$2 \x3d cljs.core.next(seq17735__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17736,G__17737,seq17735__$2);\n}));\n\n(cljs.core.unchecked_multiply_int.cljs$lang$maxFixedArity \x3d (2));\n\ncljs.core.unchecked_negate \x3d (function cljs$core$unchecked_negate(x){\nreturn (- x);\n});\ncljs.core.unchecked_negate_int \x3d (function cljs$core$unchecked_negate_int(x){\nreturn (- x);\n});\ncljs.core.unchecked_remainder_int \x3d (function cljs$core$unchecked_remainder_int(x,n){\nreturn (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));\n});\n/**\n * If no ys are supplied, returns the negation of x, else subtracts\n *   the ys from x and returns the result.\n */\ncljs.core.unchecked_subtract \x3d (function cljs$core$unchecked_subtract(var_args){\nvar G__17743 \x3d arguments.length;\nswitch (G__17743) {\ncase 1:\nreturn cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22356 \x3d arguments.length;\nvar i__5727__auto___22357 \x3d (0);\nwhile(true){\nif((i__5727__auto___22357 \x3c len__5726__auto___22356)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22357]));\n\nvar G__22358 \x3d (i__5727__auto___22357 + (1));\ni__5727__auto___22357 \x3d G__22358;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn (- x);\n}));\n\n(cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x - y);\n}));\n\n(cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_subtract,(x - y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.unchecked_subtract.cljs$lang$applyTo \x3d (function (seq17740){\nvar G__17741 \x3d cljs.core.first(seq17740);\nvar seq17740__$1 \x3d cljs.core.next(seq17740);\nvar G__17742 \x3d cljs.core.first(seq17740__$1);\nvar seq17740__$2 \x3d cljs.core.next(seq17740__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17741,G__17742,seq17740__$2);\n}));\n\n(cljs.core.unchecked_subtract.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * If no ys are supplied, returns the negation of x, else subtracts\n *   the ys from x and returns the result.\n */\ncljs.core.unchecked_subtract_int \x3d (function cljs$core$unchecked_subtract_int(var_args){\nvar G__17748 \x3d arguments.length;\nswitch (G__17748) {\ncase 1:\nreturn cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22361 \x3d arguments.length;\nvar i__5727__auto___22362 \x3d (0);\nwhile(true){\nif((i__5727__auto___22362 \x3c len__5726__auto___22361)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22362]));\n\nvar G__22364 \x3d (i__5727__auto___22362 + (1));\ni__5727__auto___22362 \x3d G__22364;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn (- x);\n}));\n\n(cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x - y);\n}));\n\n(cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_subtract_int,(x - y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.unchecked_subtract_int.cljs$lang$applyTo \x3d (function (seq17745){\nvar G__17746 \x3d cljs.core.first(seq17745);\nvar seq17745__$1 \x3d cljs.core.next(seq17745);\nvar G__17747 \x3d cljs.core.first(seq17745__$1);\nvar seq17745__$2 \x3d cljs.core.next(seq17745__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17746,G__17747,seq17745__$2);\n}));\n\n(cljs.core.unchecked_subtract_int.cljs$lang$maxFixedArity \x3d (2));\n\ncljs.core.fix \x3d (function cljs$core$fix(q){\nif((q \x3e\x3d (0))){\nreturn Math.floor(q);\n} else {\nreturn Math.ceil(q);\n}\n});\n/**\n * Coerce to int by stripping decimal places.\n */\ncljs.core.int$ \x3d (function cljs$core$int(x){\nreturn (x | (0));\n});\n/**\n * Coerce to int by stripping decimal places.\n */\ncljs.core.unchecked_int \x3d (function cljs$core$unchecked_int(x){\nreturn cljs.core.fix(x);\n});\n/**\n * Coerce to long by stripping decimal places. Identical to `int\x27.\n */\ncljs.core.long$ \x3d (function cljs$core$long(x){\nreturn cljs.core.fix(x);\n});\n/**\n * Coerce to long by stripping decimal places. Identical to `int\x27.\n */\ncljs.core.unchecked_long \x3d (function cljs$core$unchecked_long(x){\nreturn cljs.core.fix(x);\n});\ncljs.core.booleans \x3d (function cljs$core$booleans(x){\nreturn x;\n});\ncljs.core.bytes \x3d (function cljs$core$bytes(x){\nreturn x;\n});\ncljs.core.chars \x3d (function cljs$core$chars(x){\nreturn x;\n});\ncljs.core.shorts \x3d (function cljs$core$shorts(x){\nreturn x;\n});\ncljs.core.ints \x3d (function cljs$core$ints(x){\nreturn x;\n});\ncljs.core.floats \x3d (function cljs$core$floats(x){\nreturn x;\n});\ncljs.core.doubles \x3d (function cljs$core$doubles(x){\nreturn x;\n});\ncljs.core.longs \x3d (function cljs$core$longs(x){\nreturn x;\n});\n/**\n * Modulus of num and div with original javascript behavior. i.e. bug for negative numbers\n */\ncljs.core.js_mod \x3d (function cljs$core$js_mod(n,d){\nreturn (n % d);\n});\n/**\n * Modulus of num and div. Truncates toward negative infinity.\n */\ncljs.core.mod \x3d (function cljs$core$mod(n,d){\nreturn (((n % d) + d) % d);\n});\n/**\n * quot[ient] of dividing numerator by denominator.\n */\ncljs.core.quot \x3d (function cljs$core$quot(n,d){\nvar rem \x3d (n % d);\nreturn cljs.core.fix(((n - rem) / d));\n});\n/**\n * remainder of dividing numerator by denominator.\n */\ncljs.core.rem \x3d (function cljs$core$rem(n,d){\nvar q \x3d cljs.core.quot(n,d);\nreturn (n - (d * q));\n});\n/**\n * Bitwise exclusive or\n */\ncljs.core.bit_xor \x3d (function cljs$core$bit_xor(var_args){\nvar G__17753 \x3d arguments.length;\nswitch (G__17753) {\ncase 2:\nreturn cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22382 \x3d arguments.length;\nvar i__5727__auto___22383 \x3d (0);\nwhile(true){\nif((i__5727__auto___22383 \x3c len__5726__auto___22382)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22383]));\n\nvar G__22384 \x3d (i__5727__auto___22383 + (1));\ni__5727__auto___22383 \x3d G__22384;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x ^ y);\n}));\n\n(cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_xor,(x ^ y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.bit_xor.cljs$lang$applyTo \x3d (function (seq17750){\nvar G__17751 \x3d cljs.core.first(seq17750);\nvar seq17750__$1 \x3d cljs.core.next(seq17750);\nvar G__17752 \x3d cljs.core.first(seq17750__$1);\nvar seq17750__$2 \x3d cljs.core.next(seq17750__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17751,G__17752,seq17750__$2);\n}));\n\n(cljs.core.bit_xor.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Bitwise and\n */\ncljs.core.bit_and \x3d (function cljs$core$bit_and(var_args){\nvar G__17758 \x3d arguments.length;\nswitch (G__17758) {\ncase 2:\nreturn cljs.core.bit_and.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22386 \x3d arguments.length;\nvar i__5727__auto___22387 \x3d (0);\nwhile(true){\nif((i__5727__auto___22387 \x3c len__5726__auto___22386)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22387]));\n\nvar G__22388 \x3d (i__5727__auto___22387 + (1));\ni__5727__auto___22387 \x3d G__22388;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.bit_and.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.bit_and.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x \x26 y);\n}));\n\n(cljs.core.bit_and.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_and,(x \x26 y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.bit_and.cljs$lang$applyTo \x3d (function (seq17755){\nvar G__17756 \x3d cljs.core.first(seq17755);\nvar seq17755__$1 \x3d cljs.core.next(seq17755);\nvar G__17757 \x3d cljs.core.first(seq17755__$1);\nvar seq17755__$2 \x3d cljs.core.next(seq17755__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17756,G__17757,seq17755__$2);\n}));\n\n(cljs.core.bit_and.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Bitwise or\n */\ncljs.core.bit_or \x3d (function cljs$core$bit_or(var_args){\nvar G__17763 \x3d arguments.length;\nswitch (G__17763) {\ncase 2:\nreturn cljs.core.bit_or.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22394 \x3d arguments.length;\nvar i__5727__auto___22395 \x3d (0);\nwhile(true){\nif((i__5727__auto___22395 \x3c len__5726__auto___22394)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22395]));\n\nvar G__22396 \x3d (i__5727__auto___22395 + (1));\ni__5727__auto___22395 \x3d G__22396;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.bit_or.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.bit_or.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x | y);\n}));\n\n(cljs.core.bit_or.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_or,(x | y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.bit_or.cljs$lang$applyTo \x3d (function (seq17760){\nvar G__17761 \x3d cljs.core.first(seq17760);\nvar seq17760__$1 \x3d cljs.core.next(seq17760);\nvar G__17762 \x3d cljs.core.first(seq17760__$1);\nvar seq17760__$2 \x3d cljs.core.next(seq17760__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17761,G__17762,seq17760__$2);\n}));\n\n(cljs.core.bit_or.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Bitwise and with complement\n */\ncljs.core.bit_and_not \x3d (function cljs$core$bit_and_not(var_args){\nvar G__17768 \x3d arguments.length;\nswitch (G__17768) {\ncase 2:\nreturn cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22400 \x3d arguments.length;\nvar i__5727__auto___22401 \x3d (0);\nwhile(true){\nif((i__5727__auto___22401 \x3c len__5726__auto___22400)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22401]));\n\nvar G__22403 \x3d (i__5727__auto___22401 + (1));\ni__5727__auto___22401 \x3d G__22403;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (x \x26 ~y);\n}));\n\n(cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_and_not,(x \x26 ~y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.bit_and_not.cljs$lang$applyTo \x3d (function (seq17765){\nvar G__17766 \x3d cljs.core.first(seq17765);\nvar seq17765__$1 \x3d cljs.core.next(seq17765);\nvar G__17767 \x3d cljs.core.first(seq17765__$1);\nvar seq17765__$2 \x3d cljs.core.next(seq17765__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17766,G__17767,seq17765__$2);\n}));\n\n(cljs.core.bit_and_not.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Clear bit at index n\n */\ncljs.core.bit_clear \x3d (function cljs$core$bit_clear(x,n){\nreturn (x \x26 ~(1 \x3c\x3c n));\n});\n/**\n * Flip bit at index n\n */\ncljs.core.bit_flip \x3d (function cljs$core$bit_flip(x,n){\nreturn (x ^ (1 \x3c\x3c n));\n});\n/**\n * Bitwise complement\n */\ncljs.core.bit_not \x3d (function cljs$core$bit_not(x){\nreturn (~ x);\n});\n/**\n * Set bit at index n\n */\ncljs.core.bit_set \x3d (function cljs$core$bit_set(x,n){\nreturn (x | (1 \x3c\x3c n));\n});\n/**\n * Test bit at index n\n */\ncljs.core.bit_test \x3d (function cljs$core$bit_test(x,n){\nreturn ((x \x26 (1 \x3c\x3c n)) !\x3d 0);\n});\n/**\n * Bitwise shift left\n */\ncljs.core.bit_shift_left \x3d (function cljs$core$bit_shift_left(x,n){\nreturn (x \x3c\x3c n);\n});\n/**\n * Bitwise shift right\n */\ncljs.core.bit_shift_right \x3d (function cljs$core$bit_shift_right(x,n){\nreturn (x \x3e\x3e n);\n});\n/**\n * DEPRECATED: Bitwise shift right with zero fill\n */\ncljs.core.bit_shift_right_zero_fill \x3d (function cljs$core$bit_shift_right_zero_fill(x,n){\nreturn (x \x3e\x3e\x3e n);\n});\n/**\n * Bitwise shift right with zero fill\n */\ncljs.core.unsigned_bit_shift_right \x3d (function cljs$core$unsigned_bit_shift_right(x,n){\nreturn (x \x3e\x3e\x3e n);\n});\n/**\n * Counts the number of bits set in n\n */\ncljs.core.bit_count \x3d (function cljs$core$bit_count(v){\nvar v__$1 \x3d (v - ((v \x3e\x3e (1)) \x26 (1431655765)));\nvar v__$2 \x3d ((v__$1 \x26 (858993459)) + ((v__$1 \x3e\x3e (2)) \x26 (858993459)));\nreturn ((((v__$2 + (v__$2 \x3e\x3e (4))) \x26 (252645135)) * (16843009)) \x3e\x3e (24));\n});\n/**\n * Returns non-nil if nums all have the equivalent\n *   value, otherwise false. Behavior on non nums is\n *   undefined.\n */\ncljs.core._EQ__EQ_ \x3d (function cljs$core$_EQ__EQ_(var_args){\nvar G__17773 \x3d arguments.length;\nswitch (G__17773) {\ncase 1:\nreturn cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22407 \x3d arguments.length;\nvar i__5727__auto___22408 \x3d (0);\nwhile(true){\nif((i__5727__auto___22408 \x3c len__5726__auto___22407)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22408]));\n\nvar G__22409 \x3d (i__5727__auto___22408 + (1));\ni__5727__auto___22408 \x3d G__22409;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn true;\n}));\n\n(cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn cljs.core._equiv(x,y);\n}));\n\n(cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nwhile(true){\nif((x \x3d\x3d\x3d y)){\nif(cljs.core.next(more)){\nvar G__22414 \x3d y;\nvar G__22415 \x3d cljs.core.first(more);\nvar G__22416 \x3d cljs.core.next(more);\nx \x3d G__22414;\ny \x3d G__22415;\nmore \x3d G__22416;\ncontinue;\n} else {\nreturn (y \x3d\x3d\x3d cljs.core.first(more));\n}\n} else {\nreturn false;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core._EQ__EQ_.cljs$lang$applyTo \x3d (function (seq17770){\nvar G__17771 \x3d cljs.core.first(seq17770);\nvar seq17770__$1 \x3d cljs.core.next(seq17770);\nvar G__17772 \x3d cljs.core.first(seq17770__$1);\nvar seq17770__$2 \x3d cljs.core.next(seq17770__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17771,G__17772,seq17770__$2);\n}));\n\n(cljs.core._EQ__EQ_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns true if num is greater than zero, else false\n */\ncljs.core.pos_QMARK_ \x3d (function cljs$core$pos_QMARK_(x){\nreturn (x \x3e (0));\n});\n/**\n * Returns true if num is zero, else false\n */\ncljs.core.zero_QMARK_ \x3d (function cljs$core$zero_QMARK_(x){\nreturn (x \x3d\x3d\x3d (0));\n});\n/**\n * Returns true if num is less than zero, else false\n */\ncljs.core.neg_QMARK_ \x3d (function cljs$core$neg_QMARK_(x){\nreturn (x \x3c (0));\n});\n/**\n * Returns the nth next of coll, (seq coll) when n is 0.\n */\ncljs.core.nthnext \x3d (function cljs$core$nthnext(coll,n){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition1$ \x26 (262144))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IDrop$))))?true:false):false)){\nif((n \x3e (0))){\nreturn coll.cljs$core$IDrop$_drop$arity$2(null, Math.ceil(n));\n} else {\nreturn cljs.core.seq(coll);\n}\n} else {\nvar n__$1 \x3d n;\nvar xs \x3d cljs.core.seq(coll);\nwhile(true){\nif(((xs) \x26\x26 ((n__$1 \x3e (0))))){\nvar G__22420 \x3d (n__$1 - (1));\nvar G__22421 \x3d cljs.core.next(xs);\nn__$1 \x3d G__22420;\nxs \x3d G__22421;\ncontinue;\n} else {\nreturn xs;\n}\nbreak;\n}\n}\n});\n/**\n * With no args, returns the empty string. With one arg x, returns\n *   x.toString().  (str nil) returns the empty string. With more than\n *   one arg, returns the concatenation of the str values of the args.\n */\ncljs.core.str \x3d (function cljs$core$str(var_args){\nvar G__17778 \x3d arguments.length;\nswitch (G__17778) {\ncase 0:\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22423 \x3d arguments.length;\nvar i__5727__auto___22424 \x3d (0);\nwhile(true){\nif((i__5727__auto___22424 \x3c len__5726__auto___22423)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22424]));\n\nvar G__22426 \x3d (i__5727__auto___22424 + (1));\ni__5727__auto___22424 \x3d G__22426;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((1) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.str.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn \x22\x22;\n}));\n\n(cljs.core.str.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nif((x \x3d\x3d null)){\nreturn \x22\x22;\n} else {\nreturn [x].join(\x22\x22);\n}\n}));\n\n(cljs.core.str.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,ys){\nvar sb \x3d (new goog.string.StringBuffer(cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)));\nvar more \x3d ys;\nwhile(true){\nif(cljs.core.truth_(more)){\nvar G__22430 \x3d sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(more)));\nvar G__22431 \x3d cljs.core.next(more);\nsb \x3d G__22430;\nmore \x3d G__22431;\ncontinue;\n} else {\nreturn sb.toString();\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.str.cljs$lang$applyTo \x3d (function (seq17776){\nvar G__17777 \x3d cljs.core.first(seq17776);\nvar seq17776__$1 \x3d cljs.core.next(seq17776);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17777,seq17776__$1);\n}));\n\n(cljs.core.str.cljs$lang$maxFixedArity \x3d (1));\n\n/**\n * Returns the substring of s beginning at start inclusive, and ending\n *   at end (defaults to length of string), exclusive.\n */\ncljs.core.subs \x3d (function cljs$core$subs(var_args){\nvar G__17780 \x3d arguments.length;\nswitch (G__17780) {\ncase 2:\nreturn cljs.core.subs.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.subs.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.subs.cljs$core$IFn$_invoke$arity$2 \x3d (function (s,start){\nreturn s.substring(start);\n}));\n\n(cljs.core.subs.cljs$core$IFn$_invoke$arity$3 \x3d (function (s,start,end){\nreturn s.substring(start,end);\n}));\n\n(cljs.core.subs.cljs$lang$maxFixedArity \x3d 3);\n\n\n/**\n * Assumes x is sequential. Returns true if x equals y, otherwise\n *   returns false.\n */\ncljs.core.equiv_sequential \x3d (function cljs$core$equiv_sequential(x,y){\nreturn cljs.core.boolean$(((cljs.core.sequential_QMARK_(y))?((((cljs.core.counted_QMARK_(x)) \x26\x26 (((cljs.core.counted_QMARK_(y)) \x26\x26 ((!((cljs.core.count(x) \x3d\x3d\x3d cljs.core.count(y)))))))))?false:(function (){var xs \x3d cljs.core.seq(x);\nvar ys \x3d cljs.core.seq(y);\nwhile(true){\nif((xs \x3d\x3d null)){\nreturn (ys \x3d\x3d null);\n} else {\nif((ys \x3d\x3d null)){\nreturn false;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.first(xs),cljs.core.first(ys))){\nvar G__22479 \x3d cljs.core.next(xs);\nvar G__22480 \x3d cljs.core.next(ys);\nxs \x3d G__22479;\nys \x3d G__22480;\ncontinue;\n} else {\nreturn false;\n\n}\n}\n}\nbreak;\n}\n})()):null));\n});\ncljs.core.hash_coll \x3d (function cljs$core$hash_coll(coll){\nif(cljs.core.seq(coll)){\nvar res \x3d cljs.core.hash(cljs.core.first(coll));\nvar s \x3d cljs.core.next(coll);\nwhile(true){\nif((s \x3d\x3d null)){\nreturn res;\n} else {\nvar G__22484 \x3d cljs.core.hash_combine(res,cljs.core.hash(cljs.core.first(s)));\nvar G__22485 \x3d cljs.core.next(s);\nres \x3d G__22484;\ns \x3d G__22485;\ncontinue;\n}\nbreak;\n}\n} else {\nreturn (0);\n}\n});\n\ncljs.core.hash_imap \x3d (function cljs$core$hash_imap(m){\nvar h \x3d (0);\nvar s \x3d cljs.core.seq(m);\nwhile(true){\nif(s){\nvar e \x3d cljs.core.first(s);\nvar G__22488 \x3d ((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));\nvar G__22489 \x3d cljs.core.next(s);\nh \x3d G__22488;\ns \x3d G__22489;\ncontinue;\n} else {\nreturn h;\n}\nbreak;\n}\n});\ncljs.core.hash_iset \x3d (function cljs$core$hash_iset(s){\nvar h \x3d (0);\nvar s__$1 \x3d cljs.core.seq(s);\nwhile(true){\nif(s__$1){\nvar e \x3d cljs.core.first(s__$1);\nvar G__22492 \x3d ((h + cljs.core.hash(e)) % (4503599627370496));\nvar G__22493 \x3d cljs.core.next(s__$1);\nh \x3d G__22492;\ns__$1 \x3d G__22493;\ncontinue;\n} else {\nreturn h;\n}\nbreak;\n}\n});\n\n\n/**\n * Takes a JavaScript object and a map of names to functions and\n *   attaches said functions as methods on the object.  Any references to\n *   JavaScript\x27s implicit this (via the this-as macro) will resolve to the\n *   object that the function is attached.\n */\ncljs.core.extend_object_BANG_ \x3d (function cljs$core$extend_object_BANG_(obj,fn_map){\nvar seq__17781_22494 \x3d cljs.core.seq(fn_map);\nvar chunk__17782_22495 \x3d null;\nvar count__17783_22496 \x3d (0);\nvar i__17784_22497 \x3d (0);\nwhile(true){\nif((i__17784_22497 \x3c count__17783_22496)){\nvar vec__17791_22499 \x3d chunk__17782_22495.cljs$core$IIndexed$_nth$arity$2(null, i__17784_22497);\nvar key_name_22500 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17791_22499,(0),null);\nvar f_22501 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17791_22499,(1),null);\nvar str_name_22506 \x3d (cljs.core.name.cljs$core$IFn$_invoke$arity$1 ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(key_name_22500) : cljs.core.name.call(null, key_name_22500));\ncljs.core.goog$module$goog$object.set(obj,str_name_22506,f_22501);\n\n\nvar G__22507 \x3d seq__17781_22494;\nvar G__22508 \x3d chunk__17782_22495;\nvar G__22509 \x3d count__17783_22496;\nvar G__22510 \x3d (i__17784_22497 + (1));\nseq__17781_22494 \x3d G__22507;\nchunk__17782_22495 \x3d G__22508;\ncount__17783_22496 \x3d G__22509;\ni__17784_22497 \x3d G__22510;\ncontinue;\n} else {\nvar temp__5804__auto___22511 \x3d cljs.core.seq(seq__17781_22494);\nif(temp__5804__auto___22511){\nvar seq__17781_22512__$1 \x3d temp__5804__auto___22511;\nif(cljs.core.chunked_seq_QMARK_(seq__17781_22512__$1)){\nvar c__5525__auto___22514 \x3d (cljs.core.chunk_first.cljs$core$IFn$_invoke$arity$1 ? cljs.core.chunk_first.cljs$core$IFn$_invoke$arity$1(seq__17781_22512__$1) : cljs.core.chunk_first.call(null, seq__17781_22512__$1));\nvar G__22517 \x3d (cljs.core.chunk_rest.cljs$core$IFn$_invoke$arity$1 ? cljs.core.chunk_rest.cljs$core$IFn$_invoke$arity$1(seq__17781_22512__$1) : cljs.core.chunk_rest.call(null, seq__17781_22512__$1));\nvar G__22518 \x3d c__5525__auto___22514;\nvar G__22519 \x3d cljs.core.count(c__5525__auto___22514);\nvar G__22520 \x3d (0);\nseq__17781_22494 \x3d G__22517;\nchunk__17782_22495 \x3d G__22518;\ncount__17783_22496 \x3d G__22519;\ni__17784_22497 \x3d G__22520;\ncontinue;\n} else {\nvar vec__17794_22523 \x3d cljs.core.first(seq__17781_22512__$1);\nvar key_name_22524 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17794_22523,(0),null);\nvar f_22525 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17794_22523,(1),null);\nvar str_name_22527 \x3d (cljs.core.name.cljs$core$IFn$_invoke$arity$1 ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(key_name_22524) : cljs.core.name.call(null, key_name_22524));\ncljs.core.goog$module$goog$object.set(obj,str_name_22527,f_22525);\n\n\nvar G__22528 \x3d cljs.core.next(seq__17781_22512__$1);\nvar G__22529 \x3d null;\nvar G__22530 \x3d (0);\nvar G__22531 \x3d (0);\nseq__17781_22494 \x3d G__22528;\nchunk__17782_22495 \x3d G__22529;\ncount__17783_22496 \x3d G__22530;\ni__17784_22497 \x3d G__22531;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn obj;\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IList}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ASeq}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.List \x3d (function (meta,first,rest,count,__hash){\nthis.meta \x3d meta;\nthis.first \x3d first;\nthis.rest \x3d rest;\nthis.count \x3d count;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 65937646;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 8192;\n});\n(cljs.core.List.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.List.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.List.prototype.indexOf \x3d (function() {\nvar G__22532 \x3d null;\nvar G__22532__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__22532__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22532 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22532__1.call(this,x);\ncase 2:\nreturn G__22532__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22532.cljs$core$IFn$_invoke$arity$1 \x3d G__22532__1;\nG__22532.cljs$core$IFn$_invoke$arity$2 \x3d G__22532__2;\nreturn G__22532;\n})()\n);\n\n(cljs.core.List.prototype.lastIndexOf \x3d (function() {\nvar G__22541 \x3d null;\nvar G__22541__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,self__.count);\n});\nvar G__22541__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22541 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22541__1.call(this,x);\ncase 2:\nreturn G__22541__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22541.cljs$core$IFn$_invoke$arity$1 \x3d G__22541__1;\nG__22541.cljs$core$IFn$_invoke$arity$2 \x3d G__22541__2;\nreturn G__22541;\n})()\n);\n\n(cljs.core.List.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.List.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.List(self__.meta,self__.first,self__.rest,self__.count,self__.__hash));\n}));\n\n(cljs.core.List.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.count \x3d\x3d\x3d (1))){\nreturn null;\n} else {\nreturn self__.rest;\n}\n}));\n\n(cljs.core.List.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.count;\n}));\n\n(cljs.core.List.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.first;\n}));\n\n(cljs.core.List.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ISeq$_rest$arity$1(null, );\n}));\n\n(cljs.core.List.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.List.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.List.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta);\n}));\n\n(cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.List.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.first;\n}));\n\n(cljs.core.List.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.count \x3d\x3d\x3d (1))){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn self__.rest;\n}\n}));\n\n(cljs.core.List.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.List.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.List(new_meta,self__.first,self__.rest,self__.count,self__.__hash));\n}\n}));\n\n(cljs.core.List.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.List(self__.meta,o,coll__$1,(self__.count + (1)),null));\n}));\n\n(cljs.core.List.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22first\x22,\x22first\x22,996428481,null),new cljs.core.Symbol(null,\x22rest\x22,\x22rest\x22,398835108,null),new cljs.core.Symbol(null,\x22count\x22,\x22count\x22,-514511684,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.List.cljs$lang$type \x3d true);\n\n(cljs.core.List.cljs$lang$ctorStr \x3d \x22cljs.core/List\x22);\n\n(cljs.core.List.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/List\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/List.\n */\ncljs.core.__GT_List \x3d (function cljs$core$__GT_List(meta,first,rest,count,__hash){\nreturn (new cljs.core.List(meta,first,rest,count,__hash));\n});\n\n/**\n * Returns true if x implements IList\n */\ncljs.core.list_QMARK_ \x3d (function cljs$core$list_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (33554432))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IList$)))){\nreturn true;\n} else {\nif((!x.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IList,x);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IList,x);\n}\n});\n(cljs.core.List.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.IList}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.EmptyList \x3d (function (meta){\nthis.meta \x3d meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 65937614;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 8192;\n});\n(cljs.core.EmptyList.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.EmptyList.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.EmptyList.prototype.indexOf \x3d (function() {\nvar G__22629 \x3d null;\nvar G__22629__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__22629__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22629 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22629__1.call(this,x);\ncase 2:\nreturn G__22629__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22629.cljs$core$IFn$_invoke$arity$1 \x3d G__22629__1;\nG__22629.cljs$core$IFn$_invoke$arity$2 \x3d G__22629__2;\nreturn G__22629;\n})()\n);\n\n(cljs.core.EmptyList.prototype.lastIndexOf \x3d (function() {\nvar G__22637 \x3d null;\nvar G__22637__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__22637__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22637 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22637__1.call(this,x);\ncase 2:\nreturn G__22637__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22637.cljs$core$IFn$_invoke$arity$1 \x3d G__22637__1;\nG__22637.cljs$core$IFn$_invoke$arity$2 \x3d G__22637__2;\nreturn G__22637;\n})()\n);\n\n(cljs.core.EmptyList.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.EmptyList(self__.meta));\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (0);\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nthrow (new Error(\x22Can\x27t pop empty list\x22));\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.empty_ordered_hash;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((cljs.core.list_QMARK_(other)) || (cljs.core.sequential_QMARK_(other)))){\nreturn (cljs.core.seq(other) \x3d\x3d null);\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.EmptyList(new_meta));\n}\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.List(self__.meta,o,null,(1),null));\n}));\n\n(cljs.core.EmptyList.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null)], null);\n}));\n\n(cljs.core.EmptyList.cljs$lang$type \x3d true);\n\n(cljs.core.EmptyList.cljs$lang$ctorStr \x3d \x22cljs.core/EmptyList\x22);\n\n(cljs.core.EmptyList.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/EmptyList\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/EmptyList.\n */\ncljs.core.__GT_EmptyList \x3d (function cljs$core$__GT_EmptyList(meta){\nreturn (new cljs.core.EmptyList(meta));\n});\n\n(cljs.core.List.EMPTY \x3d (new cljs.core.EmptyList(null)));\n(cljs.core.EmptyList.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Returns true if coll satisfies? IReversible.\n */\ncljs.core.reversible_QMARK_ \x3d (function cljs$core$reversible_QMARK_(coll){\nif((!((coll \x3d\x3d null)))){\nif((((coll.cljs$lang$protocol_mask$partition0$ \x26 (134217728))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IReversible$)))){\nreturn true;\n} else {\nif((!coll.cljs$lang$protocol_mask$partition0$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IReversible,coll);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.IReversible,coll);\n}\n});\n/**\n * Returns, in constant time, a seq of the items in rev (which\n *   can be a vector or sorted-map), in reverse order. If rev is empty returns nil\n */\ncljs.core.rseq \x3d (function cljs$core$rseq(rev){\nreturn cljs.core._rseq(rev);\n});\n/**\n * Returns a seq of the items in coll in reverse order. Not lazy.\n */\ncljs.core.reverse \x3d (function cljs$core$reverse(coll){\nif(cljs.core.reversible_QMARK_(coll)){\nvar or__5002__auto__ \x3d cljs.core.rseq(coll);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,cljs.core.List.EMPTY,coll);\n}\n});\n/**\n * Creates a new list containing the items.\n */\ncljs.core.list \x3d (function cljs$core$list(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22681 \x3d arguments.length;\nvar i__5727__auto___22682 \x3d (0);\nwhile(true){\nif((i__5727__auto___22682 \x3c len__5726__auto___22681)){\nargs__5732__auto__.push((arguments[i__5727__auto___22682]));\n\nvar G__22686 \x3d (i__5727__auto___22682 + (1));\ni__5727__auto___22682 \x3d G__22686;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.list.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.list.cljs$core$IFn$_invoke$arity$variadic \x3d (function (xs){\nvar arr \x3d (((((xs instanceof cljs.core.IndexedSeq)) \x26\x26 ((xs.i \x3d\x3d\x3d (0)))))?xs.arr:(function (){var arr \x3d [];\nvar xs__$1 \x3d xs;\nwhile(true){\nif((!((xs__$1 \x3d\x3d null)))){\narr.push(cljs.core._first(xs__$1));\n\nvar G__22694 \x3d cljs.core._next(xs__$1);\nxs__$1 \x3d G__22694;\ncontinue;\n} else {\nreturn arr;\n}\nbreak;\n}\n})());\nvar i \x3d arr.length;\nvar r \x3d cljs.core.List.EMPTY;\nwhile(true){\nif((i \x3e (0))){\nvar G__22697 \x3d (i - (1));\nvar G__22698 \x3d cljs.core._conj(r,(arr[(i - (1))]));\ni \x3d G__22697;\nr \x3d G__22698;\ncontinue;\n} else {\nreturn r;\n}\nbreak;\n}\n}));\n\n(cljs.core.list.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.list.cljs$lang$applyTo \x3d (function (seq17799){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq17799));\n}));\n\n\n/**\n* @constructor\n * @implements {cljs.core.IList}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ASeq}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.Cons \x3d (function (meta,first,rest,__hash){\nthis.meta \x3d meta;\nthis.first \x3d first;\nthis.rest \x3d rest;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 65929452;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 8192;\n});\n(cljs.core.Cons.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.Cons.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.Cons.prototype.indexOf \x3d (function() {\nvar G__22712 \x3d null;\nvar G__22712__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__22712__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22712 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22712__1.call(this,x);\ncase 2:\nreturn G__22712__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22712.cljs$core$IFn$_invoke$arity$1 \x3d G__22712__1;\nG__22712.cljs$core$IFn$_invoke$arity$2 \x3d G__22712__2;\nreturn G__22712;\n})()\n);\n\n(cljs.core.Cons.prototype.lastIndexOf \x3d (function() {\nvar G__22714 \x3d null;\nvar G__22714__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__22714__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22714 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22714__1.call(this,x);\ncase 2:\nreturn G__22714__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22714.cljs$core$IFn$_invoke$arity$1 \x3d G__22714__1;\nG__22714.cljs$core$IFn$_invoke$arity$2 \x3d G__22714__2;\nreturn G__22714;\n})()\n);\n\n(cljs.core.Cons.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.Cons.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.Cons(self__.meta,self__.first,self__.rest,self__.__hash));\n}));\n\n(cljs.core.Cons.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.rest \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core.seq(self__.rest);\n}\n}));\n\n(cljs.core.Cons.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.Cons.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.Cons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.Cons.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.first;\n}));\n\n(cljs.core.Cons.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.rest \x3d\x3d null)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn self__.rest;\n}\n}));\n\n(cljs.core.Cons.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.Cons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.Cons(new_meta,self__.first,self__.rest,self__.__hash));\n}\n}));\n\n(cljs.core.Cons.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.Cons(null,o,coll__$1,null));\n}));\n\n(cljs.core.Cons.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22first\x22,\x22first\x22,996428481,null),new cljs.core.Symbol(null,\x22rest\x22,\x22rest\x22,398835108,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Cons.cljs$lang$type \x3d true);\n\n(cljs.core.Cons.cljs$lang$ctorStr \x3d \x22cljs.core/Cons\x22);\n\n(cljs.core.Cons.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Cons\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Cons.\n */\ncljs.core.__GT_Cons \x3d (function cljs$core$__GT_Cons(meta,first,rest,__hash){\nreturn (new cljs.core.Cons(meta,first,rest,__hash));\n});\n\n(cljs.core.Cons.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Returns a new seq where x is the first element and coll is the rest.\n */\ncljs.core.cons \x3d (function cljs$core$cons(x,coll){\nif((coll \x3d\x3d null)){\nreturn (new cljs.core.List(null,x,null,(1),null));\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (64))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISeq$))))?true:false):false)){\nreturn (new cljs.core.Cons(null,x,coll,null));\n} else {\nreturn (new cljs.core.Cons(null,x,cljs.core.seq(coll),null));\n\n}\n}\n});\ncljs.core.hash_keyword \x3d (function cljs$core$hash_keyword(k){\nreturn ((cljs.core.hash_symbol(k) + (2654435769)) | (0));\n});\ncljs.core.compare_keywords \x3d (function cljs$core$compare_keywords(a,b){\nif((a.fqn \x3d\x3d\x3d b.fqn)){\nreturn (0);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(a.ns);\nif(and__5000__auto__){\nreturn b.ns;\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn (-1);\n} else {\nif(cljs.core.truth_(a.ns)){\nif(cljs.core.not(b.ns)){\nreturn (1);\n} else {\nvar nsc \x3d cljs.core.goog$module$goog$array.defaultCompare(a.ns,b.ns);\nif(((0) \x3d\x3d\x3d nsc)){\nreturn cljs.core.goog$module$goog$array.defaultCompare(a.name,b.name);\n} else {\nreturn nsc;\n}\n}\n} else {\nreturn cljs.core.goog$module$goog$array.defaultCompare(a.name,b.name);\n\n}\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.INamed}\n * @implements {cljs.core.IPrintWithWriter}\n*/\ncljs.core.Keyword \x3d (function (ns,name,fqn,_hash){\nthis.ns \x3d ns;\nthis.name \x3d name;\nthis.fqn \x3d fqn;\nthis._hash \x3d _hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2153775105;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 4096;\n});\n(cljs.core.Keyword.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn [\x22:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.fqn)].join(\x27\x27);\n}));\n\n(cljs.core.Keyword.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (_,other){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((other instanceof cljs.core.Keyword)){\nreturn (self__.fqn \x3d\x3d\x3d other.fqn);\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.Keyword.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__17802 \x3d (arguments.length - (1));\nswitch (G__17802) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.Keyword.prototype.apply \x3d (function (self__,args17801){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args17801)));\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar kw \x3d this;\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll,kw);\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (coll,not_found){\nvar self__ \x3d this;\nvar kw \x3d this;\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll,kw,not_found);\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar h__5111__auto__ \x3d self__._hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_keyword(this$__$1);\n(self__._hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$INamed$_name$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.name;\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$INamed$_namespace$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.ns;\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (o,writer,_){\nvar self__ \x3d this;\nvar o__$1 \x3d this;\nreturn cljs.core._write(writer,[\x22:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.fqn)].join(\x27\x27));\n}));\n\n(cljs.core.Keyword.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22ns\x22,\x22ns\x22,2082130287,null),new cljs.core.Symbol(null,\x22name\x22,\x22name\x22,-810760592,null),new cljs.core.Symbol(null,\x22fqn\x22,\x22fqn\x22,-1749334463,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22_hash\x22,\x22_hash\x22,-2130838312,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Keyword.cljs$lang$type \x3d true);\n\n(cljs.core.Keyword.cljs$lang$ctorStr \x3d \x22cljs.core/Keyword\x22);\n\n(cljs.core.Keyword.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Keyword\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Keyword.\n */\ncljs.core.__GT_Keyword \x3d (function cljs$core$__GT_Keyword(ns,name,fqn,_hash){\nreturn (new cljs.core.Keyword(ns,name,fqn,_hash));\n});\n\n/**\n * Return true if x is a Keyword\n */\ncljs.core.keyword_QMARK_ \x3d (function cljs$core$keyword_QMARK_(x){\nreturn (x instanceof cljs.core.Keyword);\n});\n/**\n * Efficient test to determine that two keywords are identical.\n */\ncljs.core.keyword_identical_QMARK_ \x3d (function cljs$core$keyword_identical_QMARK_(x,y){\nif((x \x3d\x3d\x3d y)){\nreturn true;\n} else {\nif((((x instanceof cljs.core.Keyword)) \x26\x26 ((y instanceof cljs.core.Keyword)))){\nreturn (x.fqn \x3d\x3d\x3d y.fqn);\n} else {\nreturn false;\n}\n}\n});\n/**\n * Efficient test to determine that two symbols are identical.\n */\ncljs.core.symbol_identical_QMARK_ \x3d (function cljs$core$symbol_identical_QMARK_(x,y){\nif((x \x3d\x3d\x3d y)){\nreturn true;\n} else {\nif((((x instanceof cljs.core.Symbol)) \x26\x26 ((y instanceof cljs.core.Symbol)))){\nreturn (x.str \x3d\x3d\x3d y.str);\n} else {\nreturn false;\n}\n}\n});\n/**\n * Returns the namespace String of a symbol or keyword, or nil if not present.\n */\ncljs.core.namespace \x3d (function cljs$core$namespace(x){\nif((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition1$ \x26 (4096))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$INamed$))))?true:false):false)){\nreturn x.cljs$core$INamed$_namespace$arity$1(null, );\n} else {\nthrow (new Error([\x22Doesn\x27t support namespace: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)].join(\x27\x27)));\n}\n});\n/**\n * Return true if x is a symbol or keyword\n */\ncljs.core.ident_QMARK_ \x3d (function cljs$core$ident_QMARK_(x){\nreturn (((x instanceof cljs.core.Keyword)) || ((x instanceof cljs.core.Symbol)));\n});\n/**\n * Return true if x is a symbol or keyword without a namespace\n */\ncljs.core.simple_ident_QMARK_ \x3d (function cljs$core$simple_ident_QMARK_(x){\nreturn ((cljs.core.ident_QMARK_(x)) \x26\x26 ((cljs.core.namespace(x) \x3d\x3d null)));\n});\n/**\n * Return true if x is a symbol or keyword with a namespace\n */\ncljs.core.qualified_ident_QMARK_ \x3d (function cljs$core$qualified_ident_QMARK_(x){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d cljs.core.ident_QMARK_(x);\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d cljs.core.namespace(x);\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn true;\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\n/**\n * Return true if x is a symbol without a namespace\n */\ncljs.core.simple_symbol_QMARK_ \x3d (function cljs$core$simple_symbol_QMARK_(x){\nreturn (((x instanceof cljs.core.Symbol)) \x26\x26 ((cljs.core.namespace(x) \x3d\x3d null)));\n});\n/**\n * Return true if x is a symbol with a namespace\n */\ncljs.core.qualified_symbol_QMARK_ \x3d (function cljs$core$qualified_symbol_QMARK_(x){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (x instanceof cljs.core.Symbol);\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d cljs.core.namespace(x);\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn true;\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\n/**\n * Return true if x is a keyword without a namespace\n */\ncljs.core.simple_keyword_QMARK_ \x3d (function cljs$core$simple_keyword_QMARK_(x){\nreturn (((x instanceof cljs.core.Keyword)) \x26\x26 ((cljs.core.namespace(x) \x3d\x3d null)));\n});\n/**\n * Return true if x is a keyword with a namespace\n */\ncljs.core.qualified_keyword_QMARK_ \x3d (function cljs$core$qualified_keyword_QMARK_(x){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (x instanceof cljs.core.Keyword);\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d cljs.core.namespace(x);\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn true;\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\n/**\n * Returns a Keyword with the given namespace and name.  Do not use :\n *   in the keyword strings, it will be added automatically.\n */\ncljs.core.keyword \x3d (function cljs$core$keyword(var_args){\nvar G__17805 \x3d arguments.length;\nswitch (G__17805) {\ncase 1:\nreturn cljs.core.keyword.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.keyword.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.keyword.cljs$core$IFn$_invoke$arity$1 \x3d (function (name){\nif((name instanceof cljs.core.Keyword)){\nreturn name;\n} else {\nif((name instanceof cljs.core.Symbol)){\nreturn (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));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22/\x22,name)){\nreturn (new cljs.core.Keyword(null,name,name,null));\n} else {\nif(typeof name \x3d\x3d\x3d \x27string\x27){\nvar parts \x3d name.split(\x22/\x22);\nif((parts.length \x3d\x3d\x3d (2))){\nreturn (new cljs.core.Keyword((parts[(0)]),(parts[(1)]),name,null));\n} else {\nreturn (new cljs.core.Keyword(null,(parts[(0)]),name,null));\n}\n} else {\nreturn null;\n}\n}\n}\n}\n}));\n\n(cljs.core.keyword.cljs$core$IFn$_invoke$arity$2 \x3d (function (ns,name){\nvar ns__$1 \x3d (((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\n));\nvar name__$1 \x3d (((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\n));\nreturn (new cljs.core.Keyword(ns__$1,name__$1,[(cljs.core.truth_(ns__$1)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns__$1),\x22/\x22].join(\x27\x27):null),cljs.core.str.cljs$core$IFn$_invoke$arity$1(name__$1)].join(\x27\x27),null));\n}));\n\n(cljs.core.keyword.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IPending}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.LazySeq \x3d (function (meta,fn,s,__hash){\nthis.meta \x3d meta;\nthis.fn \x3d fn;\nthis.s \x3d s;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374988;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 1;\n});\n(cljs.core.LazySeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.LazySeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.LazySeq.prototype.sval \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nif((self__.fn \x3d\x3d null)){\nreturn self__.s;\n} else {\n(self__.s \x3d (self__.fn.cljs$core$IFn$_invoke$arity$0 ? self__.fn.cljs$core$IFn$_invoke$arity$0() : self__.fn.call(null, )));\n\n(self__.fn \x3d null);\n\nreturn self__.s;\n}\n}));\n\n(cljs.core.LazySeq.prototype.indexOf \x3d (function() {\nvar G__22756 \x3d null;\nvar G__22756__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__22756__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22756 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22756__1.call(this,x);\ncase 2:\nreturn G__22756__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22756.cljs$core$IFn$_invoke$arity$1 \x3d G__22756__1;\nG__22756.cljs$core$IFn$_invoke$arity$2 \x3d G__22756__2;\nreturn G__22756;\n})()\n);\n\n(cljs.core.LazySeq.prototype.lastIndexOf \x3d (function() {\nvar G__22757 \x3d null;\nvar G__22757__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__22757__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22757 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22757__1.call(this,x);\ncase 2:\nreturn G__22757__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22757.cljs$core$IFn$_invoke$arity$1 \x3d G__22757__1;\nG__22757.cljs$core$IFn$_invoke$arity$2 \x3d G__22757__2;\nreturn G__22757;\n})()\n);\n\n(cljs.core.LazySeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\ncoll__$1.cljs$core$ISeqable$_seq$arity$1(null, );\n\nif((self__.s \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core.next(self__.s);\n}\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta);\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.not(self__.fn);\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\ncoll__$1.cljs$core$ISeqable$_seq$arity$1(null, );\n\nif((self__.s \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core.first(self__.s);\n}\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\ncoll__$1.cljs$core$ISeqable$_seq$arity$1(null, );\n\nif((!((self__.s \x3d\x3d null)))){\nreturn cljs.core.rest(self__.s);\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\ncoll__$1.sval();\n\nif((self__.s \x3d\x3d null)){\nreturn null;\n} else {\nvar ls \x3d self__.s;\nwhile(true){\nif((ls instanceof cljs.core.LazySeq)){\nvar G__22765 \x3d ls.sval();\nls \x3d G__22765;\ncontinue;\n} else {\n(self__.s \x3d ls);\n\nreturn cljs.core.seq(self__.s);\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.LazySeq(new_meta,(function (){\nreturn coll__$1.cljs$core$ISeqable$_seq$arity$1(null, );\n}),null,self__.__hash));\n}\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.LazySeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22fn\x22,\x22fn\x22,465265323,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22s\x22,\x22s\x22,-948495851,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.LazySeq.cljs$lang$type \x3d true);\n\n(cljs.core.LazySeq.cljs$lang$ctorStr \x3d \x22cljs.core/LazySeq\x22);\n\n(cljs.core.LazySeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/LazySeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/LazySeq.\n */\ncljs.core.__GT_LazySeq \x3d (function cljs$core$__GT_LazySeq(meta,fn,s,__hash){\nreturn (new cljs.core.LazySeq(meta,fn,s,__hash));\n});\n\n(cljs.core.LazySeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.ICounted}\n*/\ncljs.core.ChunkBuffer \x3d (function (buf,end){\nthis.buf \x3d buf;\nthis.end \x3d end;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.ChunkBuffer.prototype.add \x3d (function (o){\nvar self__ \x3d this;\nvar _ \x3d this;\n(self__.buf[self__.end] \x3d o);\n\nreturn (self__.end \x3d (self__.end + (1)));\n}));\n\n(cljs.core.ChunkBuffer.prototype.chunk \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d (new cljs.core.ArrayChunk(self__.buf,(0),self__.end));\n(self__.buf \x3d null);\n\nreturn ret;\n}));\n\n(cljs.core.ChunkBuffer.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.end;\n}));\n\n(cljs.core.ChunkBuffer.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22buf\x22,\x22buf\x22,1426618187,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22end\x22,\x22end\x22,1372345569,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ChunkBuffer.cljs$lang$type \x3d true);\n\n(cljs.core.ChunkBuffer.cljs$lang$ctorStr \x3d \x22cljs.core/ChunkBuffer\x22);\n\n(cljs.core.ChunkBuffer.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ChunkBuffer\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ChunkBuffer.\n */\ncljs.core.__GT_ChunkBuffer \x3d (function cljs$core$__GT_ChunkBuffer(buf,end){\nreturn (new cljs.core.ChunkBuffer(buf,end));\n});\n\ncljs.core.chunk_buffer \x3d (function cljs$core$chunk_buffer(capacity){\nreturn (new cljs.core.ChunkBuffer((new Array(capacity)),(0)));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.IChunk}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.ArrayChunk \x3d (function (arr,off,end){\nthis.arr \x3d arr;\nthis.off \x3d off;\nthis.end \x3d end;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 524306;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.ArrayChunk.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (self__.end - self__.off);\n}));\n\n(cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (coll,i){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (self__.arr[(self__.off + i)]);\n}));\n\n(cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (coll,i,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((((i \x3e\x3d (0))) \x26\x26 ((i \x3c (self__.end - self__.off))))){\nreturn (self__.arr[(self__.off + i)]);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.ArrayChunk.prototype.cljs$core$IChunk$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ArrayChunk.prototype.cljs$core$IChunk$_drop_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.off \x3d\x3d\x3d self__.end)){\nthrow (new Error(\x22-drop-first of empty chunk\x22));\n} else {\nreturn (new cljs.core.ArrayChunk(self__.arr,(self__.off + (1)),self__.end));\n}\n}));\n\n(cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,(self__.arr[self__.off]),(self__.off + (1)));\n}));\n\n(cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,start,self__.off);\n}));\n\n(cljs.core.ArrayChunk.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.Symbol(null,\x22off\x22,\x22off\x22,-2047994980,null),new cljs.core.Symbol(null,\x22end\x22,\x22end\x22,1372345569,null)], null);\n}));\n\n(cljs.core.ArrayChunk.cljs$lang$type \x3d true);\n\n(cljs.core.ArrayChunk.cljs$lang$ctorStr \x3d \x22cljs.core/ArrayChunk\x22);\n\n(cljs.core.ArrayChunk.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ArrayChunk\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ArrayChunk.\n */\ncljs.core.__GT_ArrayChunk \x3d (function cljs$core$__GT_ArrayChunk(arr,off,end){\nreturn (new cljs.core.ArrayChunk(arr,off,end));\n});\n\ncljs.core.array_chunk \x3d (function cljs$core$array_chunk(var_args){\nvar G__17807 \x3d arguments.length;\nswitch (G__17807) {\ncase 1:\nreturn cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$1 \x3d (function (arr){\nreturn (new cljs.core.ArrayChunk(arr,(0),arr.length));\n}));\n\n(cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2 \x3d (function (arr,off){\nreturn (new cljs.core.ArrayChunk(arr,off,arr.length));\n}));\n\n(cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3 \x3d (function (arr,off,end){\nreturn (new cljs.core.ArrayChunk(arr,off,end));\n}));\n\n(cljs.core.array_chunk.cljs$lang$maxFixedArity \x3d 3);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ASeq}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IChunkedNext}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IChunkedSeq}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.ChunkedCons \x3d (function (chunk,more,meta,__hash){\nthis.chunk \x3d chunk;\nthis.more \x3d more;\nthis.meta \x3d meta;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 31850732;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 1536;\n});\n(cljs.core.ChunkedCons.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.ChunkedCons.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.ChunkedCons.prototype.indexOf \x3d (function() {\nvar G__22778 \x3d null;\nvar G__22778__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__22778__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22778 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22778__1.call(this,x);\ncase 2:\nreturn G__22778__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22778.cljs$core$IFn$_invoke$arity$1 \x3d G__22778__1;\nG__22778.cljs$core$IFn$_invoke$arity$2 \x3d G__22778__2;\nreturn G__22778;\n})()\n);\n\n(cljs.core.ChunkedCons.prototype.lastIndexOf \x3d (function() {\nvar G__22779 \x3d null;\nvar G__22779__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__22779__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__22779 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__22779__1.call(this,x);\ncase 2:\nreturn G__22779__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22779.cljs$core$IFn$_invoke$arity$1 \x3d G__22779__1;\nG__22779.cljs$core$IFn$_invoke$arity$2 \x3d G__22779__2;\nreturn G__22779;\n})()\n);\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((cljs.core._count(self__.chunk) \x3e (1))){\nreturn (new cljs.core.ChunkedCons(cljs.core._drop_first(self__.chunk),self__.more,null,null));\n} else {\nif((self__.more \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core._seq(self__.more);\n}\n}\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._nth(self__.chunk,(0));\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((cljs.core._count(self__.chunk) \x3e (1))){\nreturn (new cljs.core.ChunkedCons(cljs.core._drop_first(self__.chunk),self__.more,null,null));\n} else {\nif((self__.more \x3d\x3d null)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn self__.more;\n}\n}\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.chunk;\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.more \x3d\x3d null)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn self__.more;\n}\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.ChunkedCons(self__.chunk,self__.more,new_meta,self__.__hash));\n}\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this$,o){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core.cons(o,this$__$1);\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.more \x3d\x3d null)){\nreturn null;\n} else {\nreturn self__.more;\n}\n}));\n\n(cljs.core.ChunkedCons.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22chunk\x22,\x22chunk\x22,449371907,null),new cljs.core.Symbol(null,\x22more\x22,\x22more\x22,-418290273,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ChunkedCons.cljs$lang$type \x3d true);\n\n(cljs.core.ChunkedCons.cljs$lang$ctorStr \x3d \x22cljs.core/ChunkedCons\x22);\n\n(cljs.core.ChunkedCons.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ChunkedCons\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ChunkedCons.\n */\ncljs.core.__GT_ChunkedCons \x3d (function cljs$core$__GT_ChunkedCons(chunk,more,meta,__hash){\nreturn (new cljs.core.ChunkedCons(chunk,more,meta,__hash));\n});\n\n(cljs.core.ChunkedCons.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.chunk_cons \x3d (function cljs$core$chunk_cons(chunk,rest){\nif((cljs.core._count(chunk) \x3d\x3d\x3d (0))){\nreturn rest;\n} else {\nreturn (new cljs.core.ChunkedCons(chunk,rest,null,null));\n}\n});\ncljs.core.chunk_append \x3d (function cljs$core$chunk_append(b,x){\nreturn b.add(x);\n});\ncljs.core.chunk \x3d (function cljs$core$chunk(b){\nreturn b.chunk();\n});\ncljs.core.chunk_first \x3d (function cljs$core$chunk_first(s){\nreturn cljs.core._chunked_first(s);\n});\ncljs.core.chunk_rest \x3d (function cljs$core$chunk_rest(s){\nreturn cljs.core._chunked_rest(s);\n});\ncljs.core.chunk_next \x3d (function cljs$core$chunk_next(s){\nif((((!((s \x3d\x3d null))))?(((((s.cljs$lang$protocol_mask$partition1$ \x26 (1024))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d s.cljs$core$IChunkedNext$))))?true:false):false)){\nreturn s.cljs$core$IChunkedNext$_chunked_next$arity$1(null, );\n} else {\nreturn cljs.core.seq(cljs.core._chunked_rest(s));\n}\n});\n/**\n * Returns an array containing the contents of coll.\n */\ncljs.core.to_array \x3d (function cljs$core$to_array(coll){\nvar ary \x3d [];\nvar s \x3d cljs.core.seq(coll);\nwhile(true){\nif((!((s \x3d\x3d null)))){\nary.push(cljs.core.first(s));\n\nvar G__22796 \x3d cljs.core.next(s);\ns \x3d G__22796;\ncontinue;\n} else {\nreturn ary;\n}\nbreak;\n}\n});\n/**\n * Returns a (potentially-ragged) 2-dimensional array\n *   containing the contents of coll.\n */\ncljs.core.to_array_2d \x3d (function cljs$core$to_array_2d(coll){\nvar ret \x3d (new Array(cljs.core.count(coll)));\nvar i_22800 \x3d (0);\nvar xs_22801 \x3d cljs.core.seq(coll);\nwhile(true){\nif((xs_22801 \x3d\x3d null)){\n} else {\n(ret[i_22800] \x3d cljs.core.to_array(cljs.core.first(xs_22801)));\n\nvar G__22802 \x3d (i_22800 + (1));\nvar G__22803 \x3d cljs.core.next(xs_22801);\ni_22800 \x3d G__22802;\nxs_22801 \x3d G__22803;\ncontinue;\n}\nbreak;\n}\n\nreturn ret;\n});\n/**\n * Creates an array of ints. Does not coerce array, provided for compatibility\n *   with Clojure.\n */\ncljs.core.int_array \x3d (function cljs$core$int_array(var_args){\nvar G__17810 \x3d arguments.length;\nswitch (G__17810) {\ncase 1:\nreturn cljs.core.int_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.int_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.int_array.cljs$core$IFn$_invoke$arity$1 \x3d (function (size_or_seq){\nif(typeof size_or_seq \x3d\x3d\x3d \x27number\x27){\nreturn cljs.core.int_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null);\n} else {\nreturn cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);\n}\n}));\n\n(cljs.core.int_array.cljs$core$IFn$_invoke$arity$2 \x3d (function (size,init_val_or_seq){\nvar a \x3d (new Array(size));\nif(cljs.core.seq_QMARK_(init_val_or_seq)){\nvar s \x3d cljs.core.seq(init_val_or_seq);\nvar i \x3d (0);\nvar s__$1 \x3d s;\nwhile(true){\nif(((s__$1) \x26\x26 ((i \x3c size)))){\n(a[i] \x3d cljs.core.first(s__$1));\n\nvar G__22805 \x3d (i + (1));\nvar G__22806 \x3d cljs.core.next(s__$1);\ni \x3d G__22805;\ns__$1 \x3d G__22806;\ncontinue;\n} else {\nreturn a;\n}\nbreak;\n}\n} else {\nvar n__5593__auto___22808 \x3d size;\nvar i_22809 \x3d (0);\nwhile(true){\nif((i_22809 \x3c n__5593__auto___22808)){\n(a[i_22809] \x3d init_val_or_seq);\n\nvar G__22810 \x3d (i_22809 + (1));\ni_22809 \x3d G__22810;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn a;\n}\n}));\n\n(cljs.core.int_array.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Creates an array of longs. Does not coerce array, provided for compatibility\n *   with Clojure.\n */\ncljs.core.long_array \x3d (function cljs$core$long_array(var_args){\nvar G__17812 \x3d arguments.length;\nswitch (G__17812) {\ncase 1:\nreturn cljs.core.long_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.long_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.long_array.cljs$core$IFn$_invoke$arity$1 \x3d (function (size_or_seq){\nif(typeof size_or_seq \x3d\x3d\x3d \x27number\x27){\nreturn cljs.core.long_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null);\n} else {\nreturn cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);\n}\n}));\n\n(cljs.core.long_array.cljs$core$IFn$_invoke$arity$2 \x3d (function (size,init_val_or_seq){\nvar a \x3d (new Array(size));\nif(cljs.core.seq_QMARK_(init_val_or_seq)){\nvar s \x3d cljs.core.seq(init_val_or_seq);\nvar i \x3d (0);\nvar s__$1 \x3d s;\nwhile(true){\nif(((s__$1) \x26\x26 ((i \x3c size)))){\n(a[i] \x3d cljs.core.first(s__$1));\n\nvar G__22814 \x3d (i + (1));\nvar G__22815 \x3d cljs.core.next(s__$1);\ni \x3d G__22814;\ns__$1 \x3d G__22815;\ncontinue;\n} else {\nreturn a;\n}\nbreak;\n}\n} else {\nvar n__5593__auto___22816 \x3d size;\nvar i_22817 \x3d (0);\nwhile(true){\nif((i_22817 \x3c n__5593__auto___22816)){\n(a[i_22817] \x3d init_val_or_seq);\n\nvar G__22818 \x3d (i_22817 + (1));\ni_22817 \x3d G__22818;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn a;\n}\n}));\n\n(cljs.core.long_array.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Creates an array of doubles. Does not coerce array, provided for compatibility\n *   with Clojure.\n */\ncljs.core.double_array \x3d (function cljs$core$double_array(var_args){\nvar G__17814 \x3d arguments.length;\nswitch (G__17814) {\ncase 1:\nreturn cljs.core.double_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.double_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.double_array.cljs$core$IFn$_invoke$arity$1 \x3d (function (size_or_seq){\nif(typeof size_or_seq \x3d\x3d\x3d \x27number\x27){\nreturn cljs.core.double_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null);\n} else {\nreturn cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);\n}\n}));\n\n(cljs.core.double_array.cljs$core$IFn$_invoke$arity$2 \x3d (function (size,init_val_or_seq){\nvar a \x3d (new Array(size));\nif(cljs.core.seq_QMARK_(init_val_or_seq)){\nvar s \x3d cljs.core.seq(init_val_or_seq);\nvar i \x3d (0);\nvar s__$1 \x3d s;\nwhile(true){\nif(((s__$1) \x26\x26 ((i \x3c size)))){\n(a[i] \x3d cljs.core.first(s__$1));\n\nvar G__22826 \x3d (i + (1));\nvar G__22827 \x3d cljs.core.next(s__$1);\ni \x3d G__22826;\ns__$1 \x3d G__22827;\ncontinue;\n} else {\nreturn a;\n}\nbreak;\n}\n} else {\nvar n__5593__auto___22828 \x3d size;\nvar i_22829 \x3d (0);\nwhile(true){\nif((i_22829 \x3c n__5593__auto___22828)){\n(a[i_22829] \x3d init_val_or_seq);\n\nvar G__22830 \x3d (i_22829 + (1));\ni_22829 \x3d G__22830;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn a;\n}\n}));\n\n(cljs.core.double_array.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Creates an array of objects. Does not coerce array, provided for compatibility\n *   with Clojure.\n */\ncljs.core.object_array \x3d (function cljs$core$object_array(var_args){\nvar G__17816 \x3d arguments.length;\nswitch (G__17816) {\ncase 1:\nreturn cljs.core.object_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.object_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.object_array.cljs$core$IFn$_invoke$arity$1 \x3d (function (size_or_seq){\nif(typeof size_or_seq \x3d\x3d\x3d \x27number\x27){\nreturn cljs.core.object_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null);\n} else {\nreturn cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);\n}\n}));\n\n(cljs.core.object_array.cljs$core$IFn$_invoke$arity$2 \x3d (function (size,init_val_or_seq){\nvar a \x3d (new Array(size));\nif(cljs.core.seq_QMARK_(init_val_or_seq)){\nvar s \x3d cljs.core.seq(init_val_or_seq);\nvar i \x3d (0);\nvar s__$1 \x3d s;\nwhile(true){\nif(((s__$1) \x26\x26 ((i \x3c size)))){\n(a[i] \x3d cljs.core.first(s__$1));\n\nvar G__22832 \x3d (i + (1));\nvar G__22833 \x3d cljs.core.next(s__$1);\ni \x3d G__22832;\ns__$1 \x3d G__22833;\ncontinue;\n} else {\nreturn a;\n}\nbreak;\n}\n} else {\nvar n__5593__auto___22834 \x3d size;\nvar i_22835 \x3d (0);\nwhile(true){\nif((i_22835 \x3c n__5593__auto___22834)){\n(a[i_22835] \x3d init_val_or_seq);\n\nvar G__22836 \x3d (i_22835 + (1));\ni_22835 \x3d G__22836;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn a;\n}\n}));\n\n(cljs.core.object_array.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * If coll is counted? returns its count, else will count at most the first n\n * elements of coll using its seq\n */\ncljs.core.bounded_count \x3d (function cljs$core$bounded_count(n,coll){\nif(cljs.core.counted_QMARK_(coll)){\nreturn cljs.core.count(coll);\n} else {\nvar i \x3d (0);\nvar s \x3d cljs.core.seq(coll);\nwhile(true){\nif((((!((s \x3d\x3d null)))) \x26\x26 ((i \x3c n)))){\nvar G__22837 \x3d (i + (1));\nvar G__22838 \x3d cljs.core.next(s);\ni \x3d G__22837;\ns \x3d G__22838;\ncontinue;\n} else {\nreturn i;\n}\nbreak;\n}\n}\n});\ncljs.core.spread \x3d (function cljs$core$spread(arglist){\nif((arglist \x3d\x3d null)){\nreturn null;\n} else {\nvar n \x3d cljs.core.next(arglist);\nif((n \x3d\x3d null)){\nreturn cljs.core.seq(cljs.core.first(arglist));\n} else {\nreturn cljs.core.cons(cljs.core.first(arglist),(cljs.core.spread.cljs$core$IFn$_invoke$arity$1 ? cljs.core.spread.cljs$core$IFn$_invoke$arity$1(n) : cljs.core.spread.call(null, n)));\n}\n}\n});\n/**\n * Returns a lazy seq representing the concatenation of the elements in the supplied colls.\n */\ncljs.core.concat \x3d (function cljs$core$concat(var_args){\nvar G__17821 \x3d arguments.length;\nswitch (G__17821) {\ncase 0:\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22840 \x3d arguments.length;\nvar i__5727__auto___22841 \x3d (0);\nwhile(true){\nif((i__5727__auto___22841 \x3c len__5726__auto___22840)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22841]));\n\nvar G__22842 \x3d (i__5727__auto___22841 + (1));\ni__5727__auto___22841 \x3d G__22842;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.concat.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn null;\n}),null,null));\n}));\n\n(cljs.core.concat.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn x;\n}),null,null));\n}));\n\n(cljs.core.concat.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s \x3d cljs.core.seq(x);\nif(s){\nif(cljs.core.chunked_seq_QMARK_(s)){\nreturn cljs.core.chunk_cons(cljs.core.chunk_first(s),cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.chunk_rest(s),y));\n} else {\nreturn cljs.core.cons(cljs.core.first(s),cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.rest(s),y));\n}\n} else {\nreturn y;\n}\n}),null,null));\n}));\n\n(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,zs){\nvar cat \x3d (function cljs$core$cat(xys,zs__$1){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar xys__$1 \x3d cljs.core.seq(xys);\nif(xys__$1){\nif(cljs.core.chunked_seq_QMARK_(xys__$1)){\nreturn cljs.core.chunk_cons(cljs.core.chunk_first(xys__$1),cljs$core$cat(cljs.core.chunk_rest(xys__$1),zs__$1));\n} else {\nreturn cljs.core.cons(cljs.core.first(xys__$1),cljs$core$cat(cljs.core.rest(xys__$1),zs__$1));\n}\n} else {\nif(cljs.core.truth_(zs__$1)){\nreturn cljs$core$cat(cljs.core.first(zs__$1),cljs.core.next(zs__$1));\n} else {\nreturn null;\n}\n}\n}),null,null));\n});\nreturn cat(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(x,y),zs);\n}));\n\n/** @this {Function} */\n(cljs.core.concat.cljs$lang$applyTo \x3d (function (seq17818){\nvar G__17819 \x3d cljs.core.first(seq17818);\nvar seq17818__$1 \x3d cljs.core.next(seq17818);\nvar G__17820 \x3d cljs.core.first(seq17818__$1);\nvar seq17818__$2 \x3d cljs.core.next(seq17818__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17819,G__17820,seq17818__$2);\n}));\n\n(cljs.core.concat.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Creates a new list containing the items prepended to the rest, the\n *   last of which will be treated as a sequence.\n */\ncljs.core.list_STAR_ \x3d (function cljs$core$list_STAR_(var_args){\nvar G__17828 \x3d arguments.length;\nswitch (G__17828) {\ncase 1:\nreturn cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22847 \x3d arguments.length;\nvar i__5727__auto___22848 \x3d (0);\nwhile(true){\nif((i__5727__auto___22848 \x3c len__5726__auto___22847)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22848]));\n\nvar G__22849 \x3d (i__5727__auto___22848 + (1));\ni__5727__auto___22848 \x3d G__22849;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((4) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((4)),(0),null)):null);\nreturn cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$1 \x3d (function (args){\nreturn cljs.core.seq(args);\n}));\n\n(cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2 \x3d (function (a,args){\nreturn cljs.core.cons(a,args);\n}));\n\n(cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3 \x3d (function (a,b,args){\nreturn cljs.core.cons(a,cljs.core.cons(b,args));\n}));\n\n(cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4 \x3d (function (a,b,c,args){\nreturn cljs.core.cons(a,cljs.core.cons(b,cljs.core.cons(c,args)));\n}));\n\n(cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (a,b,c,d,more){\nreturn cljs.core.cons(a,cljs.core.cons(b,cljs.core.cons(c,cljs.core.cons(d,cljs.core.spread(more)))));\n}));\n\n/** @this {Function} */\n(cljs.core.list_STAR_.cljs$lang$applyTo \x3d (function (seq17823){\nvar G__17824 \x3d cljs.core.first(seq17823);\nvar seq17823__$1 \x3d cljs.core.next(seq17823);\nvar G__17825 \x3d cljs.core.first(seq17823__$1);\nvar seq17823__$2 \x3d cljs.core.next(seq17823__$1);\nvar G__17826 \x3d cljs.core.first(seq17823__$2);\nvar seq17823__$3 \x3d cljs.core.next(seq17823__$2);\nvar G__17827 \x3d cljs.core.first(seq17823__$3);\nvar seq17823__$4 \x3d cljs.core.next(seq17823__$3);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17824,G__17825,G__17826,G__17827,seq17823__$4);\n}));\n\n(cljs.core.list_STAR_.cljs$lang$maxFixedArity \x3d (4));\n\n/**\n * Returns a new, transient version of the collection, in constant time.\n */\ncljs.core.transient$ \x3d (function cljs$core$transient(coll){\nreturn cljs.core._as_transient(coll);\n});\n/**\n * Returns a new, persistent version of the transient collection, in\n *   constant time. The transient collection cannot be used after this\n *   call, any such use will throw an exception.\n */\ncljs.core.persistent_BANG_ \x3d (function cljs$core$persistent_BANG_(tcoll){\nreturn cljs.core._persistent_BANG_(tcoll);\n});\n/**\n * Adds val to the transient collection, and return tcoll. The \x27addition\x27\n *   may happen at different \x27places\x27 depending on the concrete type.\n */\ncljs.core.conj_BANG_ \x3d (function cljs$core$conj_BANG_(var_args){\nvar G__17833 \x3d arguments.length;\nswitch (G__17833) {\ncase 0:\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22865 \x3d arguments.length;\nvar i__5727__auto___22866 \x3d (0);\nwhile(true){\nif((i__5727__auto___22866 \x3c len__5726__auto___22865)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22866]));\n\nvar G__22870 \x3d (i__5727__auto___22866 + (1));\ni__5727__auto___22866 \x3d G__22870;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.transient$(cljs.core.PersistentVector.EMPTY);\n}));\n\n(cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$1 \x3d (function (tcoll){\nreturn tcoll;\n}));\n\n(cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (tcoll,val){\nreturn cljs.core._conj_BANG_(tcoll,val);\n}));\n\n(cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (tcoll,val,vals){\nwhile(true){\nvar ntcoll \x3d cljs.core._conj_BANG_(tcoll,val);\nif(cljs.core.truth_(vals)){\nvar G__22874 \x3d ntcoll;\nvar G__22875 \x3d cljs.core.first(vals);\nvar G__22876 \x3d cljs.core.next(vals);\ntcoll \x3d G__22874;\nval \x3d G__22875;\nvals \x3d G__22876;\ncontinue;\n} else {\nreturn ntcoll;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.conj_BANG_.cljs$lang$applyTo \x3d (function (seq17830){\nvar G__17831 \x3d cljs.core.first(seq17830);\nvar seq17830__$1 \x3d cljs.core.next(seq17830);\nvar G__17832 \x3d cljs.core.first(seq17830__$1);\nvar seq17830__$2 \x3d cljs.core.next(seq17830__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17831,G__17832,seq17830__$2);\n}));\n\n(cljs.core.conj_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * When applied to a transient map, adds mapping of key(s) to\n *   val(s). When applied to a transient vector, sets the val at index.\n *   Note - index must be \x3c\x3d (count vector). Returns coll.\n */\ncljs.core.assoc_BANG_ \x3d (function cljs$core$assoc_BANG_(var_args){\nvar G__17839 \x3d arguments.length;\nswitch (G__17839) {\ncase 3:\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22879 \x3d arguments.length;\nvar i__5727__auto___22880 \x3d (0);\nwhile(true){\nif((i__5727__auto___22880 \x3c len__5726__auto___22879)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22880]));\n\nvar G__22881 \x3d (i__5727__auto___22880 + (1));\ni__5727__auto___22880 \x3d G__22881;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (tcoll,key,val){\nreturn cljs.core._assoc_BANG_(tcoll,key,val);\n}));\n\n(cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (tcoll,key,val,kvs){\nwhile(true){\nvar ntcoll \x3d cljs.core._assoc_BANG_(tcoll,key,val);\nif(cljs.core.truth_(kvs)){\nvar G__22888 \x3d ntcoll;\nvar G__22889 \x3d cljs.core.first(kvs);\nvar G__22890 \x3d cljs.core.second(kvs);\nvar G__22891 \x3d cljs.core.nnext(kvs);\ntcoll \x3d G__22888;\nkey \x3d G__22889;\nval \x3d G__22890;\nkvs \x3d G__22891;\ncontinue;\n} else {\nreturn ntcoll;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.assoc_BANG_.cljs$lang$applyTo \x3d (function (seq17835){\nvar G__17836 \x3d cljs.core.first(seq17835);\nvar seq17835__$1 \x3d cljs.core.next(seq17835);\nvar G__17837 \x3d cljs.core.first(seq17835__$1);\nvar seq17835__$2 \x3d cljs.core.next(seq17835__$1);\nvar G__17838 \x3d cljs.core.first(seq17835__$2);\nvar seq17835__$3 \x3d cljs.core.next(seq17835__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17836,G__17837,G__17838,seq17835__$3);\n}));\n\n(cljs.core.assoc_BANG_.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * Returns a transient map that doesn\x27t contain a mapping for key(s).\n */\ncljs.core.dissoc_BANG_ \x3d (function cljs$core$dissoc_BANG_(var_args){\nvar G__17844 \x3d arguments.length;\nswitch (G__17844) {\ncase 2:\nreturn cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22898 \x3d arguments.length;\nvar i__5727__auto___22899 \x3d (0);\nwhile(true){\nif((i__5727__auto___22899 \x3c len__5726__auto___22898)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22899]));\n\nvar G__22900 \x3d (i__5727__auto___22899 + (1));\ni__5727__auto___22899 \x3d G__22900;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (tcoll,key){\nreturn cljs.core._dissoc_BANG_(tcoll,key);\n}));\n\n(cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (tcoll,key,ks){\nwhile(true){\nvar ntcoll \x3d cljs.core._dissoc_BANG_(tcoll,key);\nif(cljs.core.truth_(ks)){\nvar G__22908 \x3d ntcoll;\nvar G__22909 \x3d cljs.core.first(ks);\nvar G__22910 \x3d cljs.core.next(ks);\ntcoll \x3d G__22908;\nkey \x3d G__22909;\nks \x3d G__22910;\ncontinue;\n} else {\nreturn ntcoll;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.dissoc_BANG_.cljs$lang$applyTo \x3d (function (seq17841){\nvar G__17842 \x3d cljs.core.first(seq17841);\nvar seq17841__$1 \x3d cljs.core.next(seq17841);\nvar G__17843 \x3d cljs.core.first(seq17841__$1);\nvar seq17841__$2 \x3d cljs.core.next(seq17841__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17842,G__17843,seq17841__$2);\n}));\n\n(cljs.core.dissoc_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Removes the last item from a transient vector. If\n *   the collection is empty, throws an exception. Returns tcoll\n */\ncljs.core.pop_BANG_ \x3d (function cljs$core$pop_BANG_(tcoll){\nreturn cljs.core._pop_BANG_(tcoll);\n});\n/**\n * disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n *   does not contain key(s).\n */\ncljs.core.disj_BANG_ \x3d (function cljs$core$disj_BANG_(var_args){\nvar G__17849 \x3d arguments.length;\nswitch (G__17849) {\ncase 2:\nreturn cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___22919 \x3d arguments.length;\nvar i__5727__auto___22921 \x3d (0);\nwhile(true){\nif((i__5727__auto___22921 \x3c len__5726__auto___22919)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___22921]));\n\nvar G__22922 \x3d (i__5727__auto___22921 + (1));\ni__5727__auto___22921 \x3d G__22922;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (tcoll,val){\nreturn cljs.core._disjoin_BANG_(tcoll,val);\n}));\n\n(cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (tcoll,val,vals){\nwhile(true){\nvar ntcoll \x3d cljs.core._disjoin_BANG_(tcoll,val);\nif(cljs.core.truth_(vals)){\nvar G__22929 \x3d ntcoll;\nvar G__22930 \x3d cljs.core.first(vals);\nvar G__22931 \x3d cljs.core.next(vals);\ntcoll \x3d G__22929;\nval \x3d G__22930;\nvals \x3d G__22931;\ncontinue;\n} else {\nreturn ntcoll;\n}\nbreak;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.disj_BANG_.cljs$lang$applyTo \x3d (function (seq17846){\nvar G__17847 \x3d cljs.core.first(seq17846);\nvar seq17846__$1 \x3d cljs.core.next(seq17846);\nvar G__17848 \x3d cljs.core.first(seq17846__$1);\nvar seq17846__$2 \x3d cljs.core.next(seq17846__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17847,G__17848,seq17846__$2);\n}));\n\n(cljs.core.disj_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n\ncljs.core.apply_to \x3d (function cljs$core$apply_to(f,argc,args){\nvar args__$1 \x3d cljs.core.seq(args);\nif((argc \x3d\x3d\x3d (0))){\nreturn (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n} else {\nvar a1 \x3d cljs.core._first(args__$1);\nvar args__$2 \x3d cljs.core._rest(args__$1);\nif((argc \x3d\x3d\x3d (1))){\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(a1) : f.call(null, a1));\n} else {\nvar b2 \x3d cljs.core._first(args__$2);\nvar args__$3 \x3d cljs.core._rest(args__$2);\nif((argc \x3d\x3d\x3d (2))){\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(a1,b2) : f.call(null, a1,b2));\n} else {\nvar c3 \x3d cljs.core._first(args__$3);\nvar args__$4 \x3d cljs.core._rest(args__$3);\nif((argc \x3d\x3d\x3d (3))){\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(a1,b2,c3) : f.call(null, a1,b2,c3));\n} else {\nvar d4 \x3d cljs.core._first(args__$4);\nvar args__$5 \x3d cljs.core._rest(args__$4);\nif((argc \x3d\x3d\x3d (4))){\nreturn (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(a1,b2,c3,d4) : f.call(null, a1,b2,c3,d4));\n} else {\nvar e5 \x3d cljs.core._first(args__$5);\nvar args__$6 \x3d cljs.core._rest(args__$5);\nif((argc \x3d\x3d\x3d (5))){\nreturn (f.cljs$core$IFn$_invoke$arity$5 ? f.cljs$core$IFn$_invoke$arity$5(a1,b2,c3,d4,e5) : f.call(null, a1,b2,c3,d4,e5));\n} else {\nvar f6 \x3d cljs.core._first(args__$6);\nvar args__$7 \x3d cljs.core._rest(args__$6);\nif((argc \x3d\x3d\x3d (6))){\nreturn (f.cljs$core$IFn$_invoke$arity$6 ? f.cljs$core$IFn$_invoke$arity$6(a1,b2,c3,d4,e5,f6) : f.call(null, a1,b2,c3,d4,e5,f6));\n} else {\nvar g7 \x3d cljs.core._first(args__$7);\nvar args__$8 \x3d cljs.core._rest(args__$7);\nif((argc \x3d\x3d\x3d (7))){\nreturn (f.cljs$core$IFn$_invoke$arity$7 ? f.cljs$core$IFn$_invoke$arity$7(a1,b2,c3,d4,e5,f6,g7) : f.call(null, a1,b2,c3,d4,e5,f6,g7));\n} else {\nvar h8 \x3d cljs.core._first(args__$8);\nvar args__$9 \x3d cljs.core._rest(args__$8);\nif((argc \x3d\x3d\x3d (8))){\nreturn (f.cljs$core$IFn$_invoke$arity$8 ? f.cljs$core$IFn$_invoke$arity$8(a1,b2,c3,d4,e5,f6,g7,h8) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8));\n} else {\nvar i9 \x3d cljs.core._first(args__$9);\nvar args__$10 \x3d cljs.core._rest(args__$9);\nif((argc \x3d\x3d\x3d (9))){\nreturn (f.cljs$core$IFn$_invoke$arity$9 ? f.cljs$core$IFn$_invoke$arity$9(a1,b2,c3,d4,e5,f6,g7,h8,i9) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9));\n} else {\nvar j10 \x3d cljs.core._first(args__$10);\nvar args__$11 \x3d cljs.core._rest(args__$10);\nif((argc \x3d\x3d\x3d (10))){\nreturn (f.cljs$core$IFn$_invoke$arity$10 ? f.cljs$core$IFn$_invoke$arity$10(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10));\n} else {\nvar k11 \x3d cljs.core._first(args__$11);\nvar args__$12 \x3d cljs.core._rest(args__$11);\nif((argc \x3d\x3d\x3d (11))){\nreturn (f.cljs$core$IFn$_invoke$arity$11 ? f.cljs$core$IFn$_invoke$arity$11(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11));\n} else {\nvar l12 \x3d cljs.core._first(args__$12);\nvar args__$13 \x3d cljs.core._rest(args__$12);\nif((argc \x3d\x3d\x3d (12))){\nreturn (f.cljs$core$IFn$_invoke$arity$12 ? f.cljs$core$IFn$_invoke$arity$12(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12));\n} else {\nvar m13 \x3d cljs.core._first(args__$13);\nvar args__$14 \x3d cljs.core._rest(args__$13);\nif((argc \x3d\x3d\x3d (13))){\nreturn (f.cljs$core$IFn$_invoke$arity$13 ? f.cljs$core$IFn$_invoke$arity$13(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13));\n} else {\nvar n14 \x3d cljs.core._first(args__$14);\nvar args__$15 \x3d cljs.core._rest(args__$14);\nif((argc \x3d\x3d\x3d (14))){\nreturn (f.cljs$core$IFn$_invoke$arity$14 ? f.cljs$core$IFn$_invoke$arity$14(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14));\n} else {\nvar o15 \x3d cljs.core._first(args__$15);\nvar args__$16 \x3d cljs.core._rest(args__$15);\nif((argc \x3d\x3d\x3d (15))){\nreturn (f.cljs$core$IFn$_invoke$arity$15 ? f.cljs$core$IFn$_invoke$arity$15(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15));\n} else {\nvar p16 \x3d cljs.core._first(args__$16);\nvar args__$17 \x3d cljs.core._rest(args__$16);\nif((argc \x3d\x3d\x3d (16))){\nreturn (f.cljs$core$IFn$_invoke$arity$16 ? f.cljs$core$IFn$_invoke$arity$16(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16));\n} else {\nvar q17 \x3d cljs.core._first(args__$17);\nvar args__$18 \x3d cljs.core._rest(args__$17);\nif((argc \x3d\x3d\x3d (17))){\nreturn (f.cljs$core$IFn$_invoke$arity$17 ? f.cljs$core$IFn$_invoke$arity$17(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17));\n} else {\nvar r18 \x3d cljs.core._first(args__$18);\nvar args__$19 \x3d cljs.core._rest(args__$18);\nif((argc \x3d\x3d\x3d (18))){\nreturn (f.cljs$core$IFn$_invoke$arity$18 ? f.cljs$core$IFn$_invoke$arity$18(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17,r18) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17,r18));\n} else {\nvar s19 \x3d cljs.core._first(args__$19);\nvar args__$20 \x3d cljs.core._rest(args__$19);\nif((argc \x3d\x3d\x3d (19))){\nreturn (f.cljs$core$IFn$_invoke$arity$19 ? f.cljs$core$IFn$_invoke$arity$19(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17,r18,s19) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17,r18,s19));\n} else {\nvar t20 \x3d cljs.core._first(args__$20);\nvar args__$21 \x3d cljs.core._rest(args__$20);\nif((argc \x3d\x3d\x3d (20))){\nreturn (f.cljs$core$IFn$_invoke$arity$20 ? f.cljs$core$IFn$_invoke$arity$20(a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17,r18,s19,t20) : f.call(null, a1,b2,c3,d4,e5,f6,g7,h8,i9,j10,k11,l12,m13,n14,o15,p16,q17,r18,s19,t20));\n} else {\nthrow (new Error(\x22Only up to 20 arguments supported on functions\x22));\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\n\n/**\n * Internal. DO NOT USE! Next without the nil? check.\n */\ncljs.core.next_STAR_ \x3d (function cljs$core$next_STAR_(coll){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (128))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$INext$))))?true:false):false)){\nreturn coll.cljs$core$INext$_next$arity$1(null, );\n} else {\nreturn cljs.core.seq(cljs.core.rest(coll));\n}\n});\n/**\n * Internal. DO NOT USE!\n *   Assumes args was already called with seq beforehand!\n */\ncljs.core.apply_to_simple \x3d (function cljs$core$apply_to_simple(var_args){\nvar G__17852 \x3d arguments.length;\nswitch (G__17852) {\ncase 2:\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,args){\nif((args \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$0){\nreturn f.cljs$core$IFn$_invoke$arity$0();\n} else {\nreturn f.call(f);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3(f,cljs.core._first(args),cljs.core.next_STAR_(args));\n}\n}));\n\n(cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,a0,args){\nif((args \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$1){\nreturn f.cljs$core$IFn$_invoke$arity$1(a0);\n} else {\nreturn f.call(f,a0);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4(f,a0,cljs.core._first(args),cljs.core.next_STAR_(args));\n}\n}));\n\n(cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4 \x3d (function (f,a0,a1,args){\nif((args \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$2){\nreturn f.cljs$core$IFn$_invoke$arity$2(a0,a1);\n} else {\nreturn f.call(f,a0,a1);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5(f,a0,a1,cljs.core._first(args),cljs.core.next_STAR_(args));\n}\n}));\n\n(cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5 \x3d (function (f,a0,a1,a2,args){\nif((args \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$3){\nreturn f.cljs$core$IFn$_invoke$arity$3(a0,a1,a2);\n} else {\nreturn f.call(f,a0,a1,a2);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6(f,a0,a1,a2,cljs.core._first(args),cljs.core.next_STAR_(args));\n}\n}));\n\n(cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6 \x3d (function (f,a0,a1,a2,a3,args){\nif((args \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$4){\nreturn f.cljs$core$IFn$_invoke$arity$4(a0,a1,a2,a3);\n} else {\nreturn f.call(f,a0,a1,a2,a3);\n}\n} else {\nvar a4 \x3d cljs.core._first(args);\nvar next_4 \x3d cljs.core.next(args);\nif((next_4 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$5){\nreturn f.cljs$core$IFn$_invoke$arity$5(a0,a1,a2,a3,a4);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4);\n}\n} else {\nvar a5 \x3d cljs.core._first(next_4);\nvar next_5 \x3d cljs.core.next(next_4);\nif((next_5 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$6){\nreturn f.cljs$core$IFn$_invoke$arity$6(a0,a1,a2,a3,a4,a5);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5);\n}\n} else {\nvar a6 \x3d cljs.core._first(next_5);\nvar next_6 \x3d cljs.core.next(next_5);\nif((next_6 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$7){\nreturn f.cljs$core$IFn$_invoke$arity$7(a0,a1,a2,a3,a4,a5,a6);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6);\n}\n} else {\nvar a7 \x3d cljs.core._first(next_6);\nvar next_7 \x3d cljs.core.next(next_6);\nif((next_7 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$8){\nreturn f.cljs$core$IFn$_invoke$arity$8(a0,a1,a2,a3,a4,a5,a6,a7);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7);\n}\n} else {\nvar a8 \x3d cljs.core._first(next_7);\nvar next_8 \x3d cljs.core.next(next_7);\nif((next_8 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$9){\nreturn f.cljs$core$IFn$_invoke$arity$9(a0,a1,a2,a3,a4,a5,a6,a7,a8);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8);\n}\n} else {\nvar a9 \x3d cljs.core._first(next_8);\nvar next_9 \x3d cljs.core.next(next_8);\nif((next_9 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$10){\nreturn f.cljs$core$IFn$_invoke$arity$10(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);\n}\n} else {\nvar a10 \x3d cljs.core._first(next_9);\nvar next_10 \x3d cljs.core.next(next_9);\nif((next_10 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$11){\nreturn f.cljs$core$IFn$_invoke$arity$11(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);\n}\n} else {\nvar a11 \x3d cljs.core._first(next_10);\nvar next_11 \x3d cljs.core.next(next_10);\nif((next_11 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$12){\nreturn f.cljs$core$IFn$_invoke$arity$12(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11);\n}\n} else {\nvar a12 \x3d cljs.core._first(next_11);\nvar next_12 \x3d cljs.core.next(next_11);\nif((next_12 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$13){\nreturn f.cljs$core$IFn$_invoke$arity$13(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);\n}\n} else {\nvar a13 \x3d cljs.core._first(next_12);\nvar next_13 \x3d cljs.core.next(next_12);\nif((next_13 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$14){\nreturn f.cljs$core$IFn$_invoke$arity$14(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13);\n}\n} else {\nvar a14 \x3d cljs.core._first(next_13);\nvar next_14 \x3d cljs.core.next(next_13);\nif((next_14 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$15){\nreturn f.cljs$core$IFn$_invoke$arity$15(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14);\n}\n} else {\nvar a15 \x3d cljs.core._first(next_14);\nvar next_15 \x3d cljs.core.next(next_14);\nif((next_15 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$16){\nreturn f.cljs$core$IFn$_invoke$arity$16(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);\n}\n} else {\nvar a16 \x3d cljs.core._first(next_15);\nvar next_16 \x3d cljs.core.next(next_15);\nif((next_16 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$17){\nreturn f.cljs$core$IFn$_invoke$arity$17(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16);\n}\n} else {\nvar a17 \x3d cljs.core._first(next_16);\nvar next_17 \x3d cljs.core.next(next_16);\nif((next_17 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$18){\nreturn f.cljs$core$IFn$_invoke$arity$18(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17);\n}\n} else {\nvar a18 \x3d cljs.core._first(next_17);\nvar next_18 \x3d cljs.core.next(next_17);\nif((next_18 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$19){\nreturn f.cljs$core$IFn$_invoke$arity$19(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18);\n}\n} else {\nvar a19 \x3d cljs.core._first(next_18);\nvar next_19 \x3d cljs.core.next(next_18);\nif((next_19 \x3d\x3d null)){\nif(f.cljs$core$IFn$_invoke$arity$20){\nreturn f.cljs$core$IFn$_invoke$arity$20(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19);\n} else {\nreturn f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19);\n}\n} else {\nvar arr__5641__auto__ \x3d [a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19];\nvar s__5642__auto___23095 \x3d next_19;\nwhile(true){\nif(s__5642__auto___23095){\narr__5641__auto__.push(cljs.core._first(s__5642__auto___23095));\n\nvar G__23101 \x3d cljs.core.next(s__5642__auto___23095);\ns__5642__auto___23095 \x3d G__23101;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn f.apply(f,arr__5641__auto__);\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}));\n\n(cljs.core.apply_to_simple.cljs$lang$maxFixedArity \x3d 6);\n\n/**\n * Applies fn f to the argument list formed by prepending intervening arguments to args.\n */\ncljs.core.apply \x3d (function cljs$core$apply(var_args){\nvar G__17860 \x3d arguments.length;\nswitch (G__17860) {\ncase 2:\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23115 \x3d arguments.length;\nvar i__5727__auto___23120 \x3d (0);\nwhile(true){\nif((i__5727__auto___23120 \x3c len__5726__auto___23115)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23120]));\n\nvar G__23124 \x3d (i__5727__auto___23120 + (1));\ni__5727__auto___23120 \x3d G__23124;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((5) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((5)),(0),null)):null);\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.apply.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,args){\nif(f.cljs$lang$applyTo){\nvar fixed_arity \x3d f.cljs$lang$maxFixedArity;\nvar bc \x3d cljs.core.bounded_count((fixed_arity + (1)),args);\nif((bc \x3c\x3d fixed_arity)){\nreturn cljs.core.apply_to(f,bc,args);\n} else {\nreturn f.cljs$lang$applyTo(args);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$2(f,cljs.core.seq(args));\n}\n}));\n\n(cljs.core.apply.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,x,args){\nif(f.cljs$lang$applyTo){\nvar arglist \x3d cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2(x,args);\nvar fixed_arity \x3d f.cljs$lang$maxFixedArity;\nvar bc \x3d (cljs.core.bounded_count(fixed_arity,args) + (1));\nif((bc \x3c\x3d fixed_arity)){\nreturn cljs.core.apply_to(f,bc,arglist);\n} else {\nreturn f.cljs$lang$applyTo(arglist);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3(f,x,cljs.core.seq(args));\n}\n}));\n\n(cljs.core.apply.cljs$core$IFn$_invoke$arity$4 \x3d (function (f,x,y,args){\nif(f.cljs$lang$applyTo){\nvar arglist \x3d cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3(x,y,args);\nvar fixed_arity \x3d f.cljs$lang$maxFixedArity;\nvar bc \x3d ((2) + cljs.core.bounded_count((fixed_arity - (1)),args));\nif((bc \x3c\x3d fixed_arity)){\nreturn cljs.core.apply_to(f,bc,arglist);\n} else {\nreturn f.cljs$lang$applyTo(arglist);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4(f,x,y,cljs.core.seq(args));\n}\n}));\n\n(cljs.core.apply.cljs$core$IFn$_invoke$arity$5 \x3d (function (f,x,y,z,args){\nif(f.cljs$lang$applyTo){\nvar arglist \x3d cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(x,y,z,args);\nvar fixed_arity \x3d f.cljs$lang$maxFixedArity;\nvar bc \x3d ((3) + cljs.core.bounded_count((fixed_arity - (2)),args));\nif((bc \x3c\x3d fixed_arity)){\nreturn cljs.core.apply_to(f,bc,arglist);\n} else {\nreturn f.cljs$lang$applyTo(arglist);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5(f,x,y,z,cljs.core.seq(args));\n}\n}));\n\n(cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,a,b,c,d,args){\nif(f.cljs$lang$applyTo){\nvar spread_args \x3d cljs.core.spread(args);\nvar arglist \x3d cljs.core.cons(a,cljs.core.cons(b,cljs.core.cons(c,cljs.core.cons(d,spread_args))));\nvar fixed_arity \x3d f.cljs$lang$maxFixedArity;\nvar bc \x3d ((4) + cljs.core.bounded_count((fixed_arity - (3)),spread_args));\nif((bc \x3c\x3d fixed_arity)){\nreturn cljs.core.apply_to(f,bc,arglist);\n} else {\nreturn f.cljs$lang$applyTo(arglist);\n}\n} else {\nreturn cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6(f,a,b,c,d,cljs.core.spread(args));\n}\n}));\n\n/** @this {Function} */\n(cljs.core.apply.cljs$lang$applyTo \x3d (function (seq17854){\nvar G__17855 \x3d cljs.core.first(seq17854);\nvar seq17854__$1 \x3d cljs.core.next(seq17854);\nvar G__17856 \x3d cljs.core.first(seq17854__$1);\nvar seq17854__$2 \x3d cljs.core.next(seq17854__$1);\nvar G__17857 \x3d cljs.core.first(seq17854__$2);\nvar seq17854__$3 \x3d cljs.core.next(seq17854__$2);\nvar G__17858 \x3d cljs.core.first(seq17854__$3);\nvar seq17854__$4 \x3d cljs.core.next(seq17854__$3);\nvar G__17859 \x3d cljs.core.first(seq17854__$4);\nvar seq17854__$5 \x3d cljs.core.next(seq17854__$4);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17855,G__17856,G__17857,G__17858,G__17859,seq17854__$5);\n}));\n\n(cljs.core.apply.cljs$lang$maxFixedArity \x3d (5));\n\ncljs.core.__destructure_map \x3d (function cljs$core$__destructure_map(gmap){\nif((((!((gmap \x3d\x3d null))))?(((((gmap.cljs$lang$protocol_mask$partition0$ \x26 (64))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d gmap.cljs$core$ISeq$))))?true:false):false)){\nif(cljs.core.next(gmap)){\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc(cljs.core.to_array(gmap));\n} else {\nif(cljs.core.seq(gmap)){\nreturn cljs.core.first(gmap);\n} else {\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}\n}\n} else {\nreturn gmap;\n}\n});\n/**\n * Returns an object of the same type and value as obj, with\n *   (apply f (meta obj) args) as its metadata.\n */\ncljs.core.vary_meta \x3d (function cljs$core$vary_meta(var_args){\nvar G__17870 \x3d arguments.length;\nswitch (G__17870) {\ncase 2:\nreturn cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23193 \x3d arguments.length;\nvar i__5727__auto___23194 \x3d (0);\nwhile(true){\nif((i__5727__auto___23194 \x3c len__5726__auto___23193)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23194]));\n\nvar G__23195 \x3d (i__5727__auto___23194 + (1));\ni__5727__auto___23194 \x3d G__23195;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((6) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((6)),(0),null)):null);\nreturn cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$2 \x3d (function (obj,f){\nreturn cljs.core.with_meta(obj,(function (){var G__17871 \x3d cljs.core.meta(obj);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17871) : f.call(null, G__17871));\n})());\n}));\n\n(cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$3 \x3d (function (obj,f,a){\nreturn cljs.core.with_meta(obj,(function (){var G__17872 \x3d cljs.core.meta(obj);\nvar G__17873 \x3d a;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17872,G__17873) : f.call(null, G__17872,G__17873));\n})());\n}));\n\n(cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$4 \x3d (function (obj,f,a,b){\nreturn cljs.core.with_meta(obj,(function (){var G__17874 \x3d cljs.core.meta(obj);\nvar G__17875 \x3d a;\nvar G__17876 \x3d b;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__17874,G__17875,G__17876) : f.call(null, G__17874,G__17875,G__17876));\n})());\n}));\n\n(cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$5 \x3d (function (obj,f,a,b,c){\nreturn cljs.core.with_meta(obj,(function (){var G__17877 \x3d cljs.core.meta(obj);\nvar G__17878 \x3d a;\nvar G__17879 \x3d b;\nvar G__17880 \x3d c;\nreturn (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(G__17877,G__17878,G__17879,G__17880) : f.call(null, G__17877,G__17878,G__17879,G__17880));\n})());\n}));\n\n(cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$6 \x3d (function (obj,f,a,b,c,d){\nreturn cljs.core.with_meta(obj,(function (){var G__17881 \x3d cljs.core.meta(obj);\nvar G__17882 \x3d a;\nvar G__17883 \x3d b;\nvar G__17884 \x3d c;\nvar G__17885 \x3d d;\nreturn (f.cljs$core$IFn$_invoke$arity$5 ? f.cljs$core$IFn$_invoke$arity$5(G__17881,G__17882,G__17883,G__17884,G__17885) : f.call(null, G__17881,G__17882,G__17883,G__17884,G__17885));\n})());\n}));\n\n(cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$variadic \x3d (function (obj,f,a,b,c,d,args){\nreturn cljs.core.with_meta(obj,cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,cljs.core.meta(obj),a,b,c,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([d,args], 0)));\n}));\n\n/** @this {Function} */\n(cljs.core.vary_meta.cljs$lang$applyTo \x3d (function (seq17863){\nvar G__17864 \x3d cljs.core.first(seq17863);\nvar seq17863__$1 \x3d cljs.core.next(seq17863);\nvar G__17865 \x3d cljs.core.first(seq17863__$1);\nvar seq17863__$2 \x3d cljs.core.next(seq17863__$1);\nvar G__17866 \x3d cljs.core.first(seq17863__$2);\nvar seq17863__$3 \x3d cljs.core.next(seq17863__$2);\nvar G__17867 \x3d cljs.core.first(seq17863__$3);\nvar seq17863__$4 \x3d cljs.core.next(seq17863__$3);\nvar G__17868 \x3d cljs.core.first(seq17863__$4);\nvar seq17863__$5 \x3d cljs.core.next(seq17863__$4);\nvar G__17869 \x3d cljs.core.first(seq17863__$5);\nvar seq17863__$6 \x3d cljs.core.next(seq17863__$5);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17864,G__17865,G__17866,G__17867,G__17868,G__17869,seq17863__$6);\n}));\n\n(cljs.core.vary_meta.cljs$lang$maxFixedArity \x3d (6));\n\n/**\n * Same as (not (\x3d obj1 obj2))\n */\ncljs.core.not_EQ_ \x3d (function cljs$core$not_EQ_(var_args){\nvar G__17890 \x3d arguments.length;\nswitch (G__17890) {\ncase 1:\nreturn cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23238 \x3d arguments.length;\nvar i__5727__auto___23242 \x3d (0);\nwhile(true){\nif((i__5727__auto___23242 \x3c len__5726__auto___23238)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23242]));\n\nvar G__23244 \x3d (i__5727__auto___23242 + (1));\ni__5727__auto___23242 \x3d G__23244;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn false;\n}));\n\n(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,y){\nreturn (!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)));\n}));\n\n(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,y,more){\nreturn cljs.core.not(cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core._EQ_,x,y,more));\n}));\n\n/** @this {Function} */\n(cljs.core.not_EQ_.cljs$lang$applyTo \x3d (function (seq17887){\nvar G__17888 \x3d cljs.core.first(seq17887);\nvar seq17887__$1 \x3d cljs.core.next(seq17887);\nvar G__17889 \x3d cljs.core.first(seq17887__$1);\nvar seq17887__$2 \x3d cljs.core.next(seq17887__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17888,G__17889,seq17887__$2);\n}));\n\n(cljs.core.not_EQ_.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * If coll is empty, returns nil, else coll\n */\ncljs.core.not_empty \x3d (function cljs$core$not_empty(coll){\nif(cljs.core.seq(coll)){\nreturn coll;\n} else {\nreturn null;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.t_cljs$core17891 \x3d (function (meta17892){\nthis.meta17892 \x3d meta17892;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.t_cljs$core17891.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_17893,meta17892__$1){\nvar self__ \x3d this;\nvar _17893__$1 \x3d this;\nreturn (new cljs.core.t_cljs$core17891(meta17892__$1));\n}));\n\n(cljs.core.t_cljs$core17891.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_17893){\nvar self__ \x3d this;\nvar _17893__$1 \x3d this;\nreturn self__.meta17892;\n}));\n\n(cljs.core.t_cljs$core17891.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn false;\n}));\n\n(cljs.core.t_cljs$core17891.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22No such element\x22));\n}));\n\n(cljs.core.t_cljs$core17891.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.t_cljs$core17891.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta17892\x22,\x22meta17892\x22,1965797379,null)], null);\n}));\n\n(cljs.core.t_cljs$core17891.cljs$lang$type \x3d true);\n\n(cljs.core.t_cljs$core17891.cljs$lang$ctorStr \x3d \x22cljs.core/t_cljs$core17891\x22);\n\n(cljs.core.t_cljs$core17891.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/t_cljs$core17891\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/t_cljs$core17891.\n */\ncljs.core.__GT_t_cljs$core17891 \x3d (function cljs$core$__GT_t_cljs$core17891(meta17892){\nreturn (new cljs.core.t_cljs$core17891(meta17892));\n});\n\n\ncljs.core.nil_iter \x3d (function cljs$core$nil_iter(){\nreturn (new cljs.core.t_cljs$core17891(cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n*/\ncljs.core.StringIter \x3d (function (s,i){\nthis.s \x3d s;\nthis.i \x3d i;\n});\n(cljs.core.StringIter.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.i \x3c self__.s.length);\n}));\n\n(cljs.core.StringIter.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d self__.s.charAt(self__.i);\n(self__.i \x3d (self__.i + (1)));\n\nreturn ret;\n}));\n\n(cljs.core.StringIter.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.StringIter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22s\x22,\x22s\x22,-948495851,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.StringIter.cljs$lang$type \x3d true);\n\n(cljs.core.StringIter.cljs$lang$ctorStr \x3d \x22cljs.core/StringIter\x22);\n\n(cljs.core.StringIter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/StringIter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/StringIter.\n */\ncljs.core.__GT_StringIter \x3d (function cljs$core$__GT_StringIter(s,i){\nreturn (new cljs.core.StringIter(s,i));\n});\n\ncljs.core.string_iter \x3d (function cljs$core$string_iter(x){\nreturn (new cljs.core.StringIter(x,(0)));\n});\n\n/**\n* @constructor\n*/\ncljs.core.ArrayIter \x3d (function (arr,i){\nthis.arr \x3d arr;\nthis.i \x3d i;\n});\n(cljs.core.ArrayIter.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.i \x3c self__.arr.length);\n}));\n\n(cljs.core.ArrayIter.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d (self__.arr[self__.i]);\n(self__.i \x3d (self__.i + (1)));\n\nreturn ret;\n}));\n\n(cljs.core.ArrayIter.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.ArrayIter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ArrayIter.cljs$lang$type \x3d true);\n\n(cljs.core.ArrayIter.cljs$lang$ctorStr \x3d \x22cljs.core/ArrayIter\x22);\n\n(cljs.core.ArrayIter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ArrayIter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ArrayIter.\n */\ncljs.core.__GT_ArrayIter \x3d (function cljs$core$__GT_ArrayIter(arr,i){\nreturn (new cljs.core.ArrayIter(arr,i));\n});\n\ncljs.core.array_iter \x3d (function cljs$core$array_iter(x){\nreturn (new cljs.core.ArrayIter(x,(0)));\n});\ncljs.core.INIT \x3d ({});\ncljs.core.START \x3d ({});\n\n/**\n* @constructor\n*/\ncljs.core.SeqIter \x3d (function (_seq,_next){\nthis._seq \x3d _seq;\nthis._next \x3d _next;\n});\n(cljs.core.SeqIter.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((self__._seq \x3d\x3d\x3d cljs.core.INIT)){\n(self__._seq \x3d cljs.core.START);\n\n(self__._next \x3d cljs.core.seq(self__._next));\n} else {\nif((self__._seq \x3d\x3d\x3d self__._next)){\n(self__._next \x3d cljs.core.next(self__._seq));\n} else {\n}\n}\n\nreturn (!((self__._next \x3d\x3d null)));\n}));\n\n(cljs.core.SeqIter.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((!(this$.hasNext()))){\nthrow (new Error(\x22No such element\x22));\n} else {\n(self__._seq \x3d self__._next);\n\nreturn cljs.core.first(self__._next);\n}\n}));\n\n(cljs.core.SeqIter.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.SeqIter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22_seq\x22,\x22_seq\x22,-449557847,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22_next\x22,\x22_next\x22,101877036,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.SeqIter.cljs$lang$type \x3d true);\n\n(cljs.core.SeqIter.cljs$lang$ctorStr \x3d \x22cljs.core/SeqIter\x22);\n\n(cljs.core.SeqIter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/SeqIter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/SeqIter.\n */\ncljs.core.__GT_SeqIter \x3d (function cljs$core$__GT_SeqIter(_seq,_next){\nreturn (new cljs.core.SeqIter(_seq,_next));\n});\n\ncljs.core.seq_iter \x3d (function cljs$core$seq_iter(coll){\nreturn (new cljs.core.SeqIter(cljs.core.INIT,coll));\n});\ncljs.core.iter \x3d (function cljs$core$iter(coll){\nif(cljs.core.iterable_QMARK_(coll)){\nreturn cljs.core._iterator(coll);\n} else {\nif((coll \x3d\x3d null)){\nreturn cljs.core.nil_iter();\n} else {\nif(typeof coll \x3d\x3d\x3d \x27string\x27){\nreturn cljs.core.string_iter(coll);\n} else {\nif(cljs.core.array_QMARK_(coll)){\nreturn cljs.core.array_iter(coll);\n} else {\nif(cljs.core.seqable_QMARK_(coll)){\nreturn cljs.core.seq_iter(coll);\n} else {\nthrow (new Error([\x22Cannot create iterator from \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n});\n\n/**\n* @constructor\n*/\ncljs.core.Many \x3d (function (vals){\nthis.vals \x3d vals;\n});\n(cljs.core.Many.prototype.add \x3d (function (o){\nvar self__ \x3d this;\nvar this$ \x3d this;\nself__.vals.push(o);\n\nreturn this$;\n}));\n\n(cljs.core.Many.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn self__.vals.shift();\n}));\n\n(cljs.core.Many.prototype.isEmpty \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn (self__.vals.length \x3d\x3d\x3d (0));\n}));\n\n(cljs.core.Many.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn [\x22Many: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.vals)].join(\x27\x27);\n}));\n\n(cljs.core.Many.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22vals\x22,\x22vals\x22,-1886377036,null)], null);\n}));\n\n(cljs.core.Many.cljs$lang$type \x3d true);\n\n(cljs.core.Many.cljs$lang$ctorStr \x3d \x22cljs.core/Many\x22);\n\n(cljs.core.Many.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Many\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Many.\n */\ncljs.core.__GT_Many \x3d (function cljs$core$__GT_Many(vals){\nreturn (new cljs.core.Many(vals));\n});\n\ncljs.core.NONE \x3d ({});\n\n/**\n* @constructor\n*/\ncljs.core.Single \x3d (function (val){\nthis.val \x3d val;\n});\n(cljs.core.Single.prototype.add \x3d (function (o){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((self__.val \x3d\x3d\x3d cljs.core.NONE)){\n(self__.val \x3d o);\n\nreturn this$;\n} else {\nreturn (new cljs.core.Many([self__.val,o]));\n}\n}));\n\n(cljs.core.Single.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((self__.val \x3d\x3d\x3d cljs.core.NONE)){\nthrow (new Error(\x22Removing object from empty buffer\x22));\n} else {\nvar ret \x3d self__.val;\n(self__.val \x3d cljs.core.NONE);\n\nreturn ret;\n}\n}));\n\n(cljs.core.Single.prototype.isEmpty \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn (self__.val \x3d\x3d\x3d cljs.core.NONE);\n}));\n\n(cljs.core.Single.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn [\x22Single: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.val)].join(\x27\x27);\n}));\n\n(cljs.core.Single.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Single.cljs$lang$type \x3d true);\n\n(cljs.core.Single.cljs$lang$ctorStr \x3d \x22cljs.core/Single\x22);\n\n(cljs.core.Single.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Single\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Single.\n */\ncljs.core.__GT_Single \x3d (function cljs$core$__GT_Single(val){\nreturn (new cljs.core.Single(val));\n});\n\n\n/**\n* @constructor\n*/\ncljs.core.Empty \x3d (function (){\n});\n(cljs.core.Empty.prototype.add \x3d (function (o){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn (new cljs.core.Single(o));\n}));\n\n(cljs.core.Empty.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nthrow (new Error(\x22Removing object from empty buffer\x22));\n}));\n\n(cljs.core.Empty.prototype.isEmpty \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn true;\n}));\n\n(cljs.core.Empty.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn \x22Empty\x22;\n}));\n\n(cljs.core.Empty.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cljs.core.Empty.cljs$lang$type \x3d true);\n\n(cljs.core.Empty.cljs$lang$ctorStr \x3d \x22cljs.core/Empty\x22);\n\n(cljs.core.Empty.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Empty\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Empty.\n */\ncljs.core.__GT_Empty \x3d (function cljs$core$__GT_Empty(){\nreturn (new cljs.core.Empty());\n});\n\ncljs.core.EMPTY \x3d (new cljs.core.Empty());\n\n/**\n* @constructor\n*/\ncljs.core.MultiIterator \x3d (function (iters){\nthis.iters \x3d iters;\n});\n(cljs.core.MultiIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar iters__$1 \x3d cljs.core.seq(self__.iters);\nwhile(true){\nif((!((iters__$1 \x3d\x3d null)))){\nvar iter \x3d cljs.core.first(iters__$1);\nif((!(iter.hasNext()))){\nreturn false;\n} else {\nvar G__23350 \x3d cljs.core.next(iters__$1);\niters__$1 \x3d G__23350;\ncontinue;\n}\n} else {\nreturn true;\n}\nbreak;\n}\n}));\n\n(cljs.core.MultiIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar nexts \x3d [];\nvar n__5593__auto___23353 \x3d self__.iters.length;\nvar i_23355 \x3d (0);\nwhile(true){\nif((i_23355 \x3c n__5593__auto___23353)){\n(nexts[i_23355] \x3d (self__.iters[i_23355]).next());\n\nvar G__23356 \x3d (i_23355 + (1));\ni_23355 \x3d G__23356;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(nexts,(0));\n}));\n\n(cljs.core.MultiIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22iters\x22,\x22iters\x22,719353031,null)], null);\n}));\n\n(cljs.core.MultiIterator.cljs$lang$type \x3d true);\n\n(cljs.core.MultiIterator.cljs$lang$ctorStr \x3d \x22cljs.core/MultiIterator\x22);\n\n(cljs.core.MultiIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/MultiIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/MultiIterator.\n */\ncljs.core.__GT_MultiIterator \x3d (function cljs$core$__GT_MultiIterator(iters){\nreturn (new cljs.core.MultiIterator(iters));\n});\n\ncljs.core.chunkIteratorSeq \x3d (function cljs$core$chunkIteratorSeq(iter){\nreturn (new cljs.core.LazySeq(null,(function (){\nif(iter.hasNext()){\nvar arr \x3d [];\nvar n \x3d (0);\nwhile(true){\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d iter.hasNext();\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (n \x3c (32));\n} else {\nreturn and__5000__auto__;\n}\n})())){\n(arr[n] \x3d iter.next());\n\nvar G__23372 \x3d (n + (1));\nn \x3d G__23372;\ncontinue;\n} else {\nreturn cljs.core.chunk_cons(cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3(arr,(0),n),(cljs.core.chunkIteratorSeq.cljs$core$IFn$_invoke$arity$1 ? cljs.core.chunkIteratorSeq.cljs$core$IFn$_invoke$arity$1(iter) : cljs.core.chunkIteratorSeq.call(null, iter)));\n}\nbreak;\n}\n} else {\nreturn null;\n}\n}),null,null));\n});\n\n/**\n* @constructor\n*/\ncljs.core.TransformerIterator \x3d (function (buffer,_next,completed,xf,sourceIter,multi){\nthis.buffer \x3d buffer;\nthis._next \x3d _next;\nthis.completed \x3d completed;\nthis.xf \x3d xf;\nthis.sourceIter \x3d sourceIter;\nthis.multi \x3d multi;\n});\n(cljs.core.TransformerIterator.prototype.step \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((!((self__._next \x3d\x3d\x3d cljs.core.NONE)))){\nreturn true;\n} else {\nwhile(true){\nif((self__._next \x3d\x3d\x3d cljs.core.NONE)){\nif(self__.buffer.isEmpty()){\nif(self__.completed){\nreturn false;\n} else {\nif(self__.sourceIter.hasNext()){\nvar iter \x3d ((self__.multi)?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(self__.xf,cljs.core.cons(null,self__.sourceIter.next())):(function (){var G__17894 \x3d null;\nvar G__17895 \x3d self__.sourceIter.next();\nreturn (self__.xf.cljs$core$IFn$_invoke$arity$2 ? self__.xf.cljs$core$IFn$_invoke$arity$2(G__17894,G__17895) : self__.xf.call(null, G__17894,G__17895));\n})());\nif(cljs.core.reduced_QMARK_(iter)){\n(self__.xf.cljs$core$IFn$_invoke$arity$1 ? self__.xf.cljs$core$IFn$_invoke$arity$1(null) : self__.xf.call(null, null));\n\n(self__.completed \x3d true);\n} else {\n}\n\ncontinue;\n} else {\n(self__.xf.cljs$core$IFn$_invoke$arity$1 ? self__.xf.cljs$core$IFn$_invoke$arity$1(null) : self__.xf.call(null, null));\n\n(self__.completed \x3d true);\n\ncontinue;\n}\n}\n} else {\n(self__._next \x3d self__.buffer.remove());\n\ncontinue;\n}\n} else {\nreturn true;\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.TransformerIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.step();\n}));\n\n(cljs.core.TransformerIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif(this$.hasNext()){\nvar ret \x3d self__._next;\n(self__._next \x3d cljs.core.NONE);\n\nreturn ret;\n} else {\nthrow (new Error(\x22No such element\x22));\n}\n}));\n\n(cljs.core.TransformerIterator.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.TransformerIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22buffer\x22,\x22buffer\x22,-2037140571,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22_next\x22,\x22_next\x22,101877036,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22completed\x22,\x22completed\x22,1154475024,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22xf\x22,\x22xf\x22,2042434515,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22sourceIter\x22,\x22sourceIter\x22,1068220306,null),new cljs.core.Symbol(null,\x22multi\x22,\x22multi\x22,1450238522,null)], null);\n}));\n\n(cljs.core.TransformerIterator.cljs$lang$type \x3d true);\n\n(cljs.core.TransformerIterator.cljs$lang$ctorStr \x3d \x22cljs.core/TransformerIterator\x22);\n\n(cljs.core.TransformerIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/TransformerIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/TransformerIterator.\n */\ncljs.core.__GT_TransformerIterator \x3d (function cljs$core$__GT_TransformerIterator(buffer,_next,completed,xf,sourceIter,multi){\nreturn (new cljs.core.TransformerIterator(buffer,_next,completed,xf,sourceIter,multi));\n});\n\n(cljs.core.TransformerIterator.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.transformer_iterator \x3d (function cljs$core$transformer_iterator(xform,sourceIter,multi){\nvar iterator \x3d (new cljs.core.TransformerIterator(cljs.core.EMPTY,cljs.core.NONE,false,null,sourceIter,multi));\n(iterator.xf \x3d (function (){var G__17896 \x3d (function() {\nvar G__23406 \x3d null;\nvar G__23406__0 \x3d (function (){\nreturn null;\n});\nvar G__23406__1 \x3d (function (acc){\nreturn acc;\n});\nvar G__23406__2 \x3d (function (acc,o){\n(iterator.buffer \x3d iterator.buffer.add(o));\n\nreturn acc;\n});\nG__23406 \x3d function(acc,o){\nswitch(arguments.length){\ncase 0:\nreturn G__23406__0.call(this);\ncase 1:\nreturn G__23406__1.call(this,acc);\ncase 2:\nreturn G__23406__2.call(this,acc,o);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23406.cljs$core$IFn$_invoke$arity$0 \x3d G__23406__0;\nG__23406.cljs$core$IFn$_invoke$arity$1 \x3d G__23406__1;\nG__23406.cljs$core$IFn$_invoke$arity$2 \x3d G__23406__2;\nreturn G__23406;\n})()\n;\nreturn (xform.cljs$core$IFn$_invoke$arity$1 ? xform.cljs$core$IFn$_invoke$arity$1(G__17896) : xform.call(null, G__17896));\n})());\n\nreturn iterator;\n});\n(cljs.core.TransformerIterator.create \x3d (function (xform,source){\nreturn cljs.core.transformer_iterator(xform,source,false);\n}));\n(cljs.core.TransformerIterator.createMulti \x3d (function (xform,sources){\nreturn cljs.core.transformer_iterator(xform,(new cljs.core.MultiIterator(cljs.core.to_array(sources))),true);\n}));\n/**\n * Coerces coll to a (possibly empty) sequence, if it is not already\n *   one. Will not force a lazy seq. (sequence nil) yields (), When a\n *   transducer is supplied, returns a lazy sequence of applications of\n *   the transform to the items in coll(s), i.e. to the set of first\n *   items of each coll, followed by the set of second\n *   items in each coll, until any one of the colls is exhausted.  Any\n *   remaining items in other colls are ignored. The transform should accept\n *   number-of-colls arguments\n */\ncljs.core.sequence \x3d (function cljs$core$sequence(var_args){\nvar G__17901 \x3d arguments.length;\nswitch (G__17901) {\ncase 1:\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23415 \x3d arguments.length;\nvar i__5727__auto___23416 \x3d (0);\nwhile(true){\nif((i__5727__auto___23416 \x3c len__5726__auto___23415)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23416]));\n\nvar G__23418 \x3d (i__5727__auto___23416 + (1));\ni__5727__auto___23416 \x3d G__23418;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.sequence.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nif(cljs.core.seq_QMARK_(coll)){\nreturn coll;\n} else {\nvar or__5002__auto__ \x3d cljs.core.seq(coll);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}\n}));\n\n(cljs.core.sequence.cljs$core$IFn$_invoke$arity$2 \x3d (function (xform,coll){\nvar or__5002__auto__ \x3d cljs.core.chunkIteratorSeq(cljs.core.TransformerIterator.create(xform,cljs.core.iter(coll)));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.sequence.cljs$core$IFn$_invoke$arity$variadic \x3d (function (xform,coll,colls){\nvar or__5002__auto__ \x3d cljs.core.chunkIteratorSeq(cljs.core.TransformerIterator.createMulti(xform,(function (){var G__17902 \x3d cljs.core.iter;\nvar G__17903 \x3d cljs.core.cons(coll,colls);\nreturn (cljs.core.map.cljs$core$IFn$_invoke$arity$2 ? cljs.core.map.cljs$core$IFn$_invoke$arity$2(G__17902,G__17903) : cljs.core.map.call(null, G__17902,G__17903));\n})()));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n/** @this {Function} */\n(cljs.core.sequence.cljs$lang$applyTo \x3d (function (seq17898){\nvar G__17899 \x3d cljs.core.first(seq17898);\nvar seq17898__$1 \x3d cljs.core.next(seq17898);\nvar G__17900 \x3d cljs.core.first(seq17898__$1);\nvar seq17898__$2 \x3d cljs.core.next(seq17898__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17899,G__17900,seq17898__$2);\n}));\n\n(cljs.core.sequence.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns true if (pred x) is logical true for every x in coll, else\n *   false.\n */\ncljs.core.every_QMARK_ \x3d (function cljs$core$every_QMARK_(pred,coll){\nwhile(true){\nif((cljs.core.seq(coll) \x3d\x3d null)){\nreturn true;\n} else {\nif(cljs.core.truth_((function (){var G__17904 \x3d cljs.core.first(coll);\nreturn (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__17904) : pred.call(null, G__17904));\n})())){\nvar G__23423 \x3d pred;\nvar G__23424 \x3d cljs.core.next(coll);\npred \x3d G__23423;\ncoll \x3d G__23424;\ncontinue;\n} else {\nreturn false;\n\n}\n}\nbreak;\n}\n});\n/**\n * Returns false if (pred x) is logical true for every x in\n *   coll, else true.\n */\ncljs.core.not_every_QMARK_ \x3d (function cljs$core$not_every_QMARK_(pred,coll){\nreturn (!(cljs.core.every_QMARK_(pred,coll)));\n});\n/**\n * Returns the first logical true value of (pred x) for any x in coll,\n *   else nil.  One common idiom is to use a set as pred, for example\n *   this will return :fred if :fred is in the sequence, otherwise nil:\n *   (some #{:fred} coll)\n */\ncljs.core.some \x3d (function cljs$core$some(pred,coll){\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar or__5002__auto__ \x3d (function (){var G__17905 \x3d cljs.core.first(s);\nreturn (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__17905) : pred.call(null, G__17905));\n})();\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar G__23427 \x3d pred;\nvar G__23428 \x3d cljs.core.next(s);\npred \x3d G__23427;\ncoll \x3d G__23428;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});\n/**\n * Returns false if (pred x) is logical true for any x in coll,\n *   else true.\n */\ncljs.core.not_any_QMARK_ \x3d (function cljs$core$not_any_QMARK_(pred,coll){\nreturn cljs.core.not(cljs.core.some(pred,coll));\n});\n/**\n * Returns true if n is even, throws an exception if n is not an integer\n */\ncljs.core.even_QMARK_ \x3d (function cljs$core$even_QMARK_(n){\nif(cljs.core.integer_QMARK_(n)){\nreturn ((n \x26 (1)) \x3d\x3d\x3d (0));\n} else {\nthrow (new Error([\x22Argument must be an integer: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)].join(\x27\x27)));\n}\n});\n/**\n * Returns true if n is odd, throws an exception if n is not an integer\n */\ncljs.core.odd_QMARK_ \x3d (function cljs$core$odd_QMARK_(n){\nreturn (!(cljs.core.even_QMARK_(n)));\n});\n/**\n * Takes a fn f and returns a fn that takes the same arguments as f,\n *   has the same effects, if any, and returns the opposite truth value.\n */\ncljs.core.complement \x3d (function cljs$core$complement(f){\nreturn (function() {\nvar G__23432 \x3d null;\nvar G__23432__0 \x3d (function (){\nreturn cljs.core.not((f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, )));\n});\nvar G__23432__1 \x3d (function (x){\nreturn cljs.core.not((f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x)));\n});\nvar G__23432__2 \x3d (function (x,y){\nreturn cljs.core.not((f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null, x,y)));\n});\nvar G__23432__3 \x3d (function() { \nvar G__23438__delegate \x3d function (x,y,zs){\nreturn cljs.core.not(cljs.core.apply.cljs$core$IFn$_invoke$arity$4(f,x,y,zs));\n};\nvar G__23438 \x3d function (x,y,var_args){\nvar zs \x3d null;\nif (arguments.length \x3e 2) {\nvar G__23441__i \x3d 0, G__23441__a \x3d new Array(arguments.length -  2);\nwhile (G__23441__i \x3c G__23441__a.length) {G__23441__a[G__23441__i] \x3d arguments[G__23441__i + 2]; ++G__23441__i;}\n  zs \x3d new cljs.core.IndexedSeq(G__23441__a,0,null);\n} \nreturn G__23438__delegate.call(this,x,y,zs);};\nG__23438.cljs$lang$maxFixedArity \x3d 2;\nG__23438.cljs$lang$applyTo \x3d (function (arglist__23446){\nvar x \x3d cljs.core.first(arglist__23446);\narglist__23446 \x3d cljs.core.next(arglist__23446);\nvar y \x3d cljs.core.first(arglist__23446);\nvar zs \x3d cljs.core.rest(arglist__23446);\nreturn G__23438__delegate(x,y,zs);\n});\nG__23438.cljs$core$IFn$_invoke$arity$variadic \x3d G__23438__delegate;\nreturn G__23438;\n})()\n;\nG__23432 \x3d function(x,y,var_args){\nvar zs \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__23432__0.call(this);\ncase 1:\nreturn G__23432__1.call(this,x);\ncase 2:\nreturn G__23432__2.call(this,x,y);\ndefault:\nvar G__23448 \x3d null;\nif (arguments.length \x3e 2) {\nvar G__23450__i \x3d 0, G__23450__a \x3d new Array(arguments.length -  2);\nwhile (G__23450__i \x3c G__23450__a.length) {G__23450__a[G__23450__i] \x3d arguments[G__23450__i + 2]; ++G__23450__i;}\nG__23448 \x3d new cljs.core.IndexedSeq(G__23450__a,0,null);\n}\nreturn G__23432__3.cljs$core$IFn$_invoke$arity$variadic(x,y, G__23448);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23432.cljs$lang$maxFixedArity \x3d 2;\nG__23432.cljs$lang$applyTo \x3d G__23432__3.cljs$lang$applyTo;\nG__23432.cljs$core$IFn$_invoke$arity$0 \x3d G__23432__0;\nG__23432.cljs$core$IFn$_invoke$arity$1 \x3d G__23432__1;\nG__23432.cljs$core$IFn$_invoke$arity$2 \x3d G__23432__2;\nG__23432.cljs$core$IFn$_invoke$arity$variadic \x3d G__23432__3.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23432;\n})()\n});\n/**\n * Returns a function that takes any number of arguments and returns x.\n */\ncljs.core.constantly \x3d (function cljs$core$constantly(x){\nreturn (function() { \nvar G__23454__delegate \x3d function (args){\nreturn x;\n};\nvar G__23454 \x3d function (var_args){\nvar args \x3d null;\nif (arguments.length \x3e 0) {\nvar G__23455__i \x3d 0, G__23455__a \x3d new Array(arguments.length -  0);\nwhile (G__23455__i \x3c G__23455__a.length) {G__23455__a[G__23455__i] \x3d arguments[G__23455__i + 0]; ++G__23455__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23455__a,0,null);\n} \nreturn G__23454__delegate.call(this,args);};\nG__23454.cljs$lang$maxFixedArity \x3d 0;\nG__23454.cljs$lang$applyTo \x3d (function (arglist__23457){\nvar args \x3d cljs.core.seq(arglist__23457);\nreturn G__23454__delegate(args);\n});\nG__23454.cljs$core$IFn$_invoke$arity$variadic \x3d G__23454__delegate;\nreturn G__23454;\n})()\n;\n});\n/**\n * Takes a set of functions and returns a fn that is the composition\n *   of those fns.  The returned fn takes a variable number of args,\n *   applies the rightmost of fns to the args, the next\n *   fn (right-to-left) to the result, etc.\n */\ncljs.core.comp \x3d (function cljs$core$comp(var_args){\nvar G__17911 \x3d arguments.length;\nswitch (G__17911) {\ncase 0:\nreturn cljs.core.comp.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.comp.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.comp.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.comp.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23469 \x3d arguments.length;\nvar i__5727__auto___23471 \x3d (0);\nwhile(true){\nif((i__5727__auto___23471 \x3c len__5726__auto___23469)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23471]));\n\nvar G__23472 \x3d (i__5727__auto___23471 + (1));\ni__5727__auto___23471 \x3d G__23472;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.comp.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.comp.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.identity;\n}));\n\n(cljs.core.comp.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn f;\n}));\n\n(cljs.core.comp.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,g){\nreturn (function() {\nvar G__23475 \x3d null;\nvar G__23475__0 \x3d (function (){\nvar G__17912 \x3d (g.cljs$core$IFn$_invoke$arity$0 ? g.cljs$core$IFn$_invoke$arity$0() : g.call(null, ));\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17912) : f.call(null, G__17912));\n});\nvar G__23475__1 \x3d (function (x){\nvar G__17913 \x3d (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(x) : g.call(null, x));\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17913) : f.call(null, G__17913));\n});\nvar G__23475__2 \x3d (function (x,y){\nvar G__17914 \x3d (g.cljs$core$IFn$_invoke$arity$2 ? g.cljs$core$IFn$_invoke$arity$2(x,y) : g.call(null, x,y));\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17914) : f.call(null, G__17914));\n});\nvar G__23475__3 \x3d (function (x,y,z){\nvar G__17915 \x3d (g.cljs$core$IFn$_invoke$arity$3 ? g.cljs$core$IFn$_invoke$arity$3(x,y,z) : g.call(null, x,y,z));\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17915) : f.call(null, G__17915));\n});\nvar G__23475__4 \x3d (function() { \nvar G__23486__delegate \x3d function (x,y,z,args){\nvar G__17916 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$5(g,x,y,z,args);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17916) : f.call(null, G__17916));\n};\nvar G__23486 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23488__i \x3d 0, G__23488__a \x3d new Array(arguments.length -  3);\nwhile (G__23488__i \x3c G__23488__a.length) {G__23488__a[G__23488__i] \x3d arguments[G__23488__i + 3]; ++G__23488__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23488__a,0,null);\n} \nreturn G__23486__delegate.call(this,x,y,z,args);};\nG__23486.cljs$lang$maxFixedArity \x3d 3;\nG__23486.cljs$lang$applyTo \x3d (function (arglist__23490){\nvar x \x3d cljs.core.first(arglist__23490);\narglist__23490 \x3d cljs.core.next(arglist__23490);\nvar y \x3d cljs.core.first(arglist__23490);\narglist__23490 \x3d cljs.core.next(arglist__23490);\nvar z \x3d cljs.core.first(arglist__23490);\nvar args \x3d cljs.core.rest(arglist__23490);\nreturn G__23486__delegate(x,y,z,args);\n});\nG__23486.cljs$core$IFn$_invoke$arity$variadic \x3d G__23486__delegate;\nreturn G__23486;\n})()\n;\nG__23475 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__23475__0.call(this);\ncase 1:\nreturn G__23475__1.call(this,x);\ncase 2:\nreturn G__23475__2.call(this,x,y);\ncase 3:\nreturn G__23475__3.call(this,x,y,z);\ndefault:\nvar G__23491 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23492__i \x3d 0, G__23492__a \x3d new Array(arguments.length -  3);\nwhile (G__23492__i \x3c G__23492__a.length) {G__23492__a[G__23492__i] \x3d arguments[G__23492__i + 3]; ++G__23492__i;}\nG__23491 \x3d new cljs.core.IndexedSeq(G__23492__a,0,null);\n}\nreturn G__23475__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__23491);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23475.cljs$lang$maxFixedArity \x3d 3;\nG__23475.cljs$lang$applyTo \x3d G__23475__4.cljs$lang$applyTo;\nG__23475.cljs$core$IFn$_invoke$arity$0 \x3d G__23475__0;\nG__23475.cljs$core$IFn$_invoke$arity$1 \x3d G__23475__1;\nG__23475.cljs$core$IFn$_invoke$arity$2 \x3d G__23475__2;\nG__23475.cljs$core$IFn$_invoke$arity$3 \x3d G__23475__3;\nG__23475.cljs$core$IFn$_invoke$arity$variadic \x3d G__23475__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23475;\n})()\n}));\n\n(cljs.core.comp.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,g,h){\nreturn (function() {\nvar G__23493 \x3d null;\nvar G__23493__0 \x3d (function (){\nvar G__17917 \x3d (function (){var G__17918 \x3d (h.cljs$core$IFn$_invoke$arity$0 ? h.cljs$core$IFn$_invoke$arity$0() : h.call(null, ));\nreturn (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__17918) : g.call(null, G__17918));\n})();\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17917) : f.call(null, G__17917));\n});\nvar G__23493__1 \x3d (function (x){\nvar G__17919 \x3d (function (){var G__17920 \x3d (h.cljs$core$IFn$_invoke$arity$1 ? h.cljs$core$IFn$_invoke$arity$1(x) : h.call(null, x));\nreturn (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__17920) : g.call(null, G__17920));\n})();\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17919) : f.call(null, G__17919));\n});\nvar G__23493__2 \x3d (function (x,y){\nvar G__17921 \x3d (function (){var G__17922 \x3d (h.cljs$core$IFn$_invoke$arity$2 ? h.cljs$core$IFn$_invoke$arity$2(x,y) : h.call(null, x,y));\nreturn (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__17922) : g.call(null, G__17922));\n})();\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17921) : f.call(null, G__17921));\n});\nvar G__23493__3 \x3d (function (x,y,z){\nvar G__17923 \x3d (function (){var G__17924 \x3d (h.cljs$core$IFn$_invoke$arity$3 ? h.cljs$core$IFn$_invoke$arity$3(x,y,z) : h.call(null, x,y,z));\nreturn (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__17924) : g.call(null, G__17924));\n})();\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17923) : f.call(null, G__17923));\n});\nvar G__23493__4 \x3d (function() { \nvar G__23502__delegate \x3d function (x,y,z,args){\nvar G__17925 \x3d (function (){var G__17926 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$5(h,x,y,z,args);\nreturn (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__17926) : g.call(null, G__17926));\n})();\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17925) : f.call(null, G__17925));\n};\nvar G__23502 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23503__i \x3d 0, G__23503__a \x3d new Array(arguments.length -  3);\nwhile (G__23503__i \x3c G__23503__a.length) {G__23503__a[G__23503__i] \x3d arguments[G__23503__i + 3]; ++G__23503__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23503__a,0,null);\n} \nreturn G__23502__delegate.call(this,x,y,z,args);};\nG__23502.cljs$lang$maxFixedArity \x3d 3;\nG__23502.cljs$lang$applyTo \x3d (function (arglist__23505){\nvar x \x3d cljs.core.first(arglist__23505);\narglist__23505 \x3d cljs.core.next(arglist__23505);\nvar y \x3d cljs.core.first(arglist__23505);\narglist__23505 \x3d cljs.core.next(arglist__23505);\nvar z \x3d cljs.core.first(arglist__23505);\nvar args \x3d cljs.core.rest(arglist__23505);\nreturn G__23502__delegate(x,y,z,args);\n});\nG__23502.cljs$core$IFn$_invoke$arity$variadic \x3d G__23502__delegate;\nreturn G__23502;\n})()\n;\nG__23493 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__23493__0.call(this);\ncase 1:\nreturn G__23493__1.call(this,x);\ncase 2:\nreturn G__23493__2.call(this,x,y);\ncase 3:\nreturn G__23493__3.call(this,x,y,z);\ndefault:\nvar G__23506 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23507__i \x3d 0, G__23507__a \x3d new Array(arguments.length -  3);\nwhile (G__23507__i \x3c G__23507__a.length) {G__23507__a[G__23507__i] \x3d arguments[G__23507__i + 3]; ++G__23507__i;}\nG__23506 \x3d new cljs.core.IndexedSeq(G__23507__a,0,null);\n}\nreturn G__23493__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__23506);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23493.cljs$lang$maxFixedArity \x3d 3;\nG__23493.cljs$lang$applyTo \x3d G__23493__4.cljs$lang$applyTo;\nG__23493.cljs$core$IFn$_invoke$arity$0 \x3d G__23493__0;\nG__23493.cljs$core$IFn$_invoke$arity$1 \x3d G__23493__1;\nG__23493.cljs$core$IFn$_invoke$arity$2 \x3d G__23493__2;\nG__23493.cljs$core$IFn$_invoke$arity$3 \x3d G__23493__3;\nG__23493.cljs$core$IFn$_invoke$arity$variadic \x3d G__23493__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23493;\n})()\n}));\n\n(cljs.core.comp.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f1,f2,f3,fs){\nvar fs__$1 \x3d cljs.core.reverse(cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(f1,f2,f3,fs));\nreturn (function() { \nvar G__23508__delegate \x3d function (args){\nvar ret \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.first(fs__$1),args);\nvar fs__$2 \x3d cljs.core.next(fs__$1);\nwhile(true){\nif(fs__$2){\nvar G__23510 \x3d (function (){var fexpr__17927 \x3d cljs.core.first(fs__$2);\nreturn (fexpr__17927.cljs$core$IFn$_invoke$arity$1 ? fexpr__17927.cljs$core$IFn$_invoke$arity$1(ret) : fexpr__17927.call(null, ret));\n})();\nvar G__23511 \x3d cljs.core.next(fs__$2);\nret \x3d G__23510;\nfs__$2 \x3d G__23511;\ncontinue;\n} else {\nreturn ret;\n}\nbreak;\n}\n};\nvar G__23508 \x3d function (var_args){\nvar args \x3d null;\nif (arguments.length \x3e 0) {\nvar G__23516__i \x3d 0, G__23516__a \x3d new Array(arguments.length -  0);\nwhile (G__23516__i \x3c G__23516__a.length) {G__23516__a[G__23516__i] \x3d arguments[G__23516__i + 0]; ++G__23516__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23516__a,0,null);\n} \nreturn G__23508__delegate.call(this,args);};\nG__23508.cljs$lang$maxFixedArity \x3d 0;\nG__23508.cljs$lang$applyTo \x3d (function (arglist__23517){\nvar args \x3d cljs.core.seq(arglist__23517);\nreturn G__23508__delegate(args);\n});\nG__23508.cljs$core$IFn$_invoke$arity$variadic \x3d G__23508__delegate;\nreturn G__23508;\n})()\n;\n}));\n\n/** @this {Function} */\n(cljs.core.comp.cljs$lang$applyTo \x3d (function (seq17907){\nvar G__17908 \x3d cljs.core.first(seq17907);\nvar seq17907__$1 \x3d cljs.core.next(seq17907);\nvar G__17909 \x3d cljs.core.first(seq17907__$1);\nvar seq17907__$2 \x3d cljs.core.next(seq17907__$1);\nvar G__17910 \x3d cljs.core.first(seq17907__$2);\nvar seq17907__$3 \x3d cljs.core.next(seq17907__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17908,G__17909,G__17910,seq17907__$3);\n}));\n\n(cljs.core.comp.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * Takes a function f and fewer than the normal arguments to f, and\n *   returns a fn that takes a variable number of additional args. When\n *   called, the returned function calls f with args + additional args.\n */\ncljs.core.partial \x3d (function cljs$core$partial(var_args){\nvar G__17934 \x3d arguments.length;\nswitch (G__17934) {\ncase 1:\nreturn cljs.core.partial.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.partial.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.partial.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.partial.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23527 \x3d arguments.length;\nvar i__5727__auto___23531 \x3d (0);\nwhile(true){\nif((i__5727__auto___23531 \x3c len__5726__auto___23527)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23531]));\n\nvar G__23532 \x3d (i__5727__auto___23531 + (1));\ni__5727__auto___23531 \x3d G__23532;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((4) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((4)),(0),null)):null);\nreturn cljs.core.partial.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.partial.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn f;\n}));\n\n(cljs.core.partial.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,arg1){\nreturn (function() {\nvar G__23534 \x3d null;\nvar G__23534__0 \x3d (function (){\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(arg1) : f.call(null, arg1));\n});\nvar G__23534__1 \x3d (function (x){\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(arg1,x) : f.call(null, arg1,x));\n});\nvar G__23534__2 \x3d (function (x,y){\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(arg1,x,y) : f.call(null, arg1,x,y));\n});\nvar G__23534__3 \x3d (function (x,y,z){\nreturn (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));\n});\nvar G__23534__4 \x3d (function() { \nvar G__23541__delegate \x3d function (x,y,z,args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,arg1,x,y,z,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([args], 0));\n};\nvar G__23541 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23542__i \x3d 0, G__23542__a \x3d new Array(arguments.length -  3);\nwhile (G__23542__i \x3c G__23542__a.length) {G__23542__a[G__23542__i] \x3d arguments[G__23542__i + 3]; ++G__23542__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23542__a,0,null);\n} \nreturn G__23541__delegate.call(this,x,y,z,args);};\nG__23541.cljs$lang$maxFixedArity \x3d 3;\nG__23541.cljs$lang$applyTo \x3d (function (arglist__23543){\nvar x \x3d cljs.core.first(arglist__23543);\narglist__23543 \x3d cljs.core.next(arglist__23543);\nvar y \x3d cljs.core.first(arglist__23543);\narglist__23543 \x3d cljs.core.next(arglist__23543);\nvar z \x3d cljs.core.first(arglist__23543);\nvar args \x3d cljs.core.rest(arglist__23543);\nreturn G__23541__delegate(x,y,z,args);\n});\nG__23541.cljs$core$IFn$_invoke$arity$variadic \x3d G__23541__delegate;\nreturn G__23541;\n})()\n;\nG__23534 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__23534__0.call(this);\ncase 1:\nreturn G__23534__1.call(this,x);\ncase 2:\nreturn G__23534__2.call(this,x,y);\ncase 3:\nreturn G__23534__3.call(this,x,y,z);\ndefault:\nvar G__23548 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23549__i \x3d 0, G__23549__a \x3d new Array(arguments.length -  3);\nwhile (G__23549__i \x3c G__23549__a.length) {G__23549__a[G__23549__i] \x3d arguments[G__23549__i + 3]; ++G__23549__i;}\nG__23548 \x3d new cljs.core.IndexedSeq(G__23549__a,0,null);\n}\nreturn G__23534__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__23548);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23534.cljs$lang$maxFixedArity \x3d 3;\nG__23534.cljs$lang$applyTo \x3d G__23534__4.cljs$lang$applyTo;\nG__23534.cljs$core$IFn$_invoke$arity$0 \x3d G__23534__0;\nG__23534.cljs$core$IFn$_invoke$arity$1 \x3d G__23534__1;\nG__23534.cljs$core$IFn$_invoke$arity$2 \x3d G__23534__2;\nG__23534.cljs$core$IFn$_invoke$arity$3 \x3d G__23534__3;\nG__23534.cljs$core$IFn$_invoke$arity$variadic \x3d G__23534__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23534;\n})()\n}));\n\n(cljs.core.partial.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,arg1,arg2){\nreturn (function() {\nvar G__23551 \x3d null;\nvar G__23551__0 \x3d (function (){\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(arg1,arg2) : f.call(null, arg1,arg2));\n});\nvar G__23551__1 \x3d (function (x){\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(arg1,arg2,x) : f.call(null, arg1,arg2,x));\n});\nvar G__23551__2 \x3d (function (x,y){\nreturn (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));\n});\nvar G__23551__3 \x3d (function (x,y,z){\nreturn (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));\n});\nvar G__23551__4 \x3d (function() { \nvar G__23553__delegate \x3d function (x,y,z,args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,arg1,arg2,x,y,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([z,args], 0));\n};\nvar G__23553 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23556__i \x3d 0, G__23556__a \x3d new Array(arguments.length -  3);\nwhile (G__23556__i \x3c G__23556__a.length) {G__23556__a[G__23556__i] \x3d arguments[G__23556__i + 3]; ++G__23556__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23556__a,0,null);\n} \nreturn G__23553__delegate.call(this,x,y,z,args);};\nG__23553.cljs$lang$maxFixedArity \x3d 3;\nG__23553.cljs$lang$applyTo \x3d (function (arglist__23557){\nvar x \x3d cljs.core.first(arglist__23557);\narglist__23557 \x3d cljs.core.next(arglist__23557);\nvar y \x3d cljs.core.first(arglist__23557);\narglist__23557 \x3d cljs.core.next(arglist__23557);\nvar z \x3d cljs.core.first(arglist__23557);\nvar args \x3d cljs.core.rest(arglist__23557);\nreturn G__23553__delegate(x,y,z,args);\n});\nG__23553.cljs$core$IFn$_invoke$arity$variadic \x3d G__23553__delegate;\nreturn G__23553;\n})()\n;\nG__23551 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__23551__0.call(this);\ncase 1:\nreturn G__23551__1.call(this,x);\ncase 2:\nreturn G__23551__2.call(this,x,y);\ncase 3:\nreturn G__23551__3.call(this,x,y,z);\ndefault:\nvar G__23562 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23563__i \x3d 0, G__23563__a \x3d new Array(arguments.length -  3);\nwhile (G__23563__i \x3c G__23563__a.length) {G__23563__a[G__23563__i] \x3d arguments[G__23563__i + 3]; ++G__23563__i;}\nG__23562 \x3d new cljs.core.IndexedSeq(G__23563__a,0,null);\n}\nreturn G__23551__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__23562);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23551.cljs$lang$maxFixedArity \x3d 3;\nG__23551.cljs$lang$applyTo \x3d G__23551__4.cljs$lang$applyTo;\nG__23551.cljs$core$IFn$_invoke$arity$0 \x3d G__23551__0;\nG__23551.cljs$core$IFn$_invoke$arity$1 \x3d G__23551__1;\nG__23551.cljs$core$IFn$_invoke$arity$2 \x3d G__23551__2;\nG__23551.cljs$core$IFn$_invoke$arity$3 \x3d G__23551__3;\nG__23551.cljs$core$IFn$_invoke$arity$variadic \x3d G__23551__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23551;\n})()\n}));\n\n(cljs.core.partial.cljs$core$IFn$_invoke$arity$4 \x3d (function (f,arg1,arg2,arg3){\nreturn (function() {\nvar G__23564 \x3d null;\nvar G__23564__0 \x3d (function (){\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(arg1,arg2,arg3) : f.call(null, arg1,arg2,arg3));\n});\nvar G__23564__1 \x3d (function (x){\nreturn (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));\n});\nvar G__23564__2 \x3d (function (x,y){\nreturn (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));\n});\nvar G__23564__3 \x3d (function (x,y,z){\nreturn (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));\n});\nvar G__23564__4 \x3d (function() { \nvar G__23583__delegate \x3d function (x,y,z,args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,arg1,arg2,arg3,x,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([y,z,args], 0));\n};\nvar G__23583 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23588__i \x3d 0, G__23588__a \x3d new Array(arguments.length -  3);\nwhile (G__23588__i \x3c G__23588__a.length) {G__23588__a[G__23588__i] \x3d arguments[G__23588__i + 3]; ++G__23588__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23588__a,0,null);\n} \nreturn G__23583__delegate.call(this,x,y,z,args);};\nG__23583.cljs$lang$maxFixedArity \x3d 3;\nG__23583.cljs$lang$applyTo \x3d (function (arglist__23597){\nvar x \x3d cljs.core.first(arglist__23597);\narglist__23597 \x3d cljs.core.next(arglist__23597);\nvar y \x3d cljs.core.first(arglist__23597);\narglist__23597 \x3d cljs.core.next(arglist__23597);\nvar z \x3d cljs.core.first(arglist__23597);\nvar args \x3d cljs.core.rest(arglist__23597);\nreturn G__23583__delegate(x,y,z,args);\n});\nG__23583.cljs$core$IFn$_invoke$arity$variadic \x3d G__23583__delegate;\nreturn G__23583;\n})()\n;\nG__23564 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__23564__0.call(this);\ncase 1:\nreturn G__23564__1.call(this,x);\ncase 2:\nreturn G__23564__2.call(this,x,y);\ncase 3:\nreturn G__23564__3.call(this,x,y,z);\ndefault:\nvar G__23612 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23613__i \x3d 0, G__23613__a \x3d new Array(arguments.length -  3);\nwhile (G__23613__i \x3c G__23613__a.length) {G__23613__a[G__23613__i] \x3d arguments[G__23613__i + 3]; ++G__23613__i;}\nG__23612 \x3d new cljs.core.IndexedSeq(G__23613__a,0,null);\n}\nreturn G__23564__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__23612);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23564.cljs$lang$maxFixedArity \x3d 3;\nG__23564.cljs$lang$applyTo \x3d G__23564__4.cljs$lang$applyTo;\nG__23564.cljs$core$IFn$_invoke$arity$0 \x3d G__23564__0;\nG__23564.cljs$core$IFn$_invoke$arity$1 \x3d G__23564__1;\nG__23564.cljs$core$IFn$_invoke$arity$2 \x3d G__23564__2;\nG__23564.cljs$core$IFn$_invoke$arity$3 \x3d G__23564__3;\nG__23564.cljs$core$IFn$_invoke$arity$variadic \x3d G__23564__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23564;\n})()\n}));\n\n(cljs.core.partial.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,arg1,arg2,arg3,more){\nreturn (function() { \nvar G__23616__delegate \x3d function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,arg1,arg2,arg3,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(more,args));\n};\nvar G__23616 \x3d function (var_args){\nvar args \x3d null;\nif (arguments.length \x3e 0) {\nvar G__23617__i \x3d 0, G__23617__a \x3d new Array(arguments.length -  0);\nwhile (G__23617__i \x3c G__23617__a.length) {G__23617__a[G__23617__i] \x3d arguments[G__23617__i + 0]; ++G__23617__i;}\n  args \x3d new cljs.core.IndexedSeq(G__23617__a,0,null);\n} \nreturn G__23616__delegate.call(this,args);};\nG__23616.cljs$lang$maxFixedArity \x3d 0;\nG__23616.cljs$lang$applyTo \x3d (function (arglist__23618){\nvar args \x3d cljs.core.seq(arglist__23618);\nreturn G__23616__delegate(args);\n});\nG__23616.cljs$core$IFn$_invoke$arity$variadic \x3d G__23616__delegate;\nreturn G__23616;\n})()\n;\n}));\n\n/** @this {Function} */\n(cljs.core.partial.cljs$lang$applyTo \x3d (function (seq17929){\nvar G__17930 \x3d cljs.core.first(seq17929);\nvar seq17929__$1 \x3d cljs.core.next(seq17929);\nvar G__17931 \x3d cljs.core.first(seq17929__$1);\nvar seq17929__$2 \x3d cljs.core.next(seq17929__$1);\nvar G__17932 \x3d cljs.core.first(seq17929__$2);\nvar seq17929__$3 \x3d cljs.core.next(seq17929__$2);\nvar G__17933 \x3d cljs.core.first(seq17929__$3);\nvar seq17929__$4 \x3d cljs.core.next(seq17929__$3);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17930,G__17931,G__17932,G__17933,seq17929__$4);\n}));\n\n(cljs.core.partial.cljs$lang$maxFixedArity \x3d (4));\n\n/**\n * Takes a function f, and returns a function that calls f, replacing\n *   a nil first argument to f with the supplied value x. Higher arity\n *   versions can replace arguments in the second and third\n *   positions (y, z). Note that the function f can take any number of\n *   arguments, not just the one(s) being nil-patched.\n */\ncljs.core.fnil \x3d (function cljs$core$fnil(var_args){\nvar G__17936 \x3d arguments.length;\nswitch (G__17936) {\ncase 2:\nreturn cljs.core.fnil.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.fnil.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.fnil.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.fnil.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,x){\nreturn (function() {\nvar G__23630 \x3d null;\nvar G__23630__1 \x3d (function (a){\nvar G__17937 \x3d (((a \x3d\x3d null))?x:a);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17937) : f.call(null, G__17937));\n});\nvar G__23630__2 \x3d (function (a,b){\nvar G__17938 \x3d (((a \x3d\x3d null))?x:a);\nvar G__17939 \x3d b;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17938,G__17939) : f.call(null, G__17938,G__17939));\n});\nvar G__23630__3 \x3d (function (a,b,c){\nvar G__17940 \x3d (((a \x3d\x3d null))?x:a);\nvar G__17941 \x3d b;\nvar G__17942 \x3d c;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__17940,G__17941,G__17942) : f.call(null, G__17940,G__17941,G__17942));\n});\nvar G__23630__4 \x3d (function() { \nvar G__23645__delegate \x3d function (a,b,c,ds){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,(((a \x3d\x3d null))?x:a),b,c,ds);\n};\nvar G__23645 \x3d function (a,b,c,var_args){\nvar ds \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23648__i \x3d 0, G__23648__a \x3d new Array(arguments.length -  3);\nwhile (G__23648__i \x3c G__23648__a.length) {G__23648__a[G__23648__i] \x3d arguments[G__23648__i + 3]; ++G__23648__i;}\n  ds \x3d new cljs.core.IndexedSeq(G__23648__a,0,null);\n} \nreturn G__23645__delegate.call(this,a,b,c,ds);};\nG__23645.cljs$lang$maxFixedArity \x3d 3;\nG__23645.cljs$lang$applyTo \x3d (function (arglist__23649){\nvar a \x3d cljs.core.first(arglist__23649);\narglist__23649 \x3d cljs.core.next(arglist__23649);\nvar b \x3d cljs.core.first(arglist__23649);\narglist__23649 \x3d cljs.core.next(arglist__23649);\nvar c \x3d cljs.core.first(arglist__23649);\nvar ds \x3d cljs.core.rest(arglist__23649);\nreturn G__23645__delegate(a,b,c,ds);\n});\nG__23645.cljs$core$IFn$_invoke$arity$variadic \x3d G__23645__delegate;\nreturn G__23645;\n})()\n;\nG__23630 \x3d function(a,b,c,var_args){\nvar ds \x3d var_args;\nswitch(arguments.length){\ncase 1:\nreturn G__23630__1.call(this,a);\ncase 2:\nreturn G__23630__2.call(this,a,b);\ncase 3:\nreturn G__23630__3.call(this,a,b,c);\ndefault:\nvar G__23651 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23652__i \x3d 0, G__23652__a \x3d new Array(arguments.length -  3);\nwhile (G__23652__i \x3c G__23652__a.length) {G__23652__a[G__23652__i] \x3d arguments[G__23652__i + 3]; ++G__23652__i;}\nG__23651 \x3d new cljs.core.IndexedSeq(G__23652__a,0,null);\n}\nreturn G__23630__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, G__23651);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23630.cljs$lang$maxFixedArity \x3d 3;\nG__23630.cljs$lang$applyTo \x3d G__23630__4.cljs$lang$applyTo;\nG__23630.cljs$core$IFn$_invoke$arity$1 \x3d G__23630__1;\nG__23630.cljs$core$IFn$_invoke$arity$2 \x3d G__23630__2;\nG__23630.cljs$core$IFn$_invoke$arity$3 \x3d G__23630__3;\nG__23630.cljs$core$IFn$_invoke$arity$variadic \x3d G__23630__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23630;\n})()\n}));\n\n(cljs.core.fnil.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,x,y){\nreturn (function() {\nvar G__23660 \x3d null;\nvar G__23660__2 \x3d (function (a,b){\nvar G__17943 \x3d (((a \x3d\x3d null))?x:a);\nvar G__17944 \x3d (((b \x3d\x3d null))?y:b);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17943,G__17944) : f.call(null, G__17943,G__17944));\n});\nvar G__23660__3 \x3d (function (a,b,c){\nvar G__17945 \x3d (((a \x3d\x3d null))?x:a);\nvar G__17946 \x3d (((b \x3d\x3d null))?y:b);\nvar G__17947 \x3d c;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__17945,G__17946,G__17947) : f.call(null, G__17945,G__17946,G__17947));\n});\nvar G__23660__4 \x3d (function() { \nvar G__23672__delegate \x3d function (a,b,c,ds){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,(((a \x3d\x3d null))?x:a),(((b \x3d\x3d null))?y:b),c,ds);\n};\nvar G__23672 \x3d function (a,b,c,var_args){\nvar ds \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23677__i \x3d 0, G__23677__a \x3d new Array(arguments.length -  3);\nwhile (G__23677__i \x3c G__23677__a.length) {G__23677__a[G__23677__i] \x3d arguments[G__23677__i + 3]; ++G__23677__i;}\n  ds \x3d new cljs.core.IndexedSeq(G__23677__a,0,null);\n} \nreturn G__23672__delegate.call(this,a,b,c,ds);};\nG__23672.cljs$lang$maxFixedArity \x3d 3;\nG__23672.cljs$lang$applyTo \x3d (function (arglist__23679){\nvar a \x3d cljs.core.first(arglist__23679);\narglist__23679 \x3d cljs.core.next(arglist__23679);\nvar b \x3d cljs.core.first(arglist__23679);\narglist__23679 \x3d cljs.core.next(arglist__23679);\nvar c \x3d cljs.core.first(arglist__23679);\nvar ds \x3d cljs.core.rest(arglist__23679);\nreturn G__23672__delegate(a,b,c,ds);\n});\nG__23672.cljs$core$IFn$_invoke$arity$variadic \x3d G__23672__delegate;\nreturn G__23672;\n})()\n;\nG__23660 \x3d function(a,b,c,var_args){\nvar ds \x3d var_args;\nswitch(arguments.length){\ncase 2:\nreturn G__23660__2.call(this,a,b);\ncase 3:\nreturn G__23660__3.call(this,a,b,c);\ndefault:\nvar G__23680 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23681__i \x3d 0, G__23681__a \x3d new Array(arguments.length -  3);\nwhile (G__23681__i \x3c G__23681__a.length) {G__23681__a[G__23681__i] \x3d arguments[G__23681__i + 3]; ++G__23681__i;}\nG__23680 \x3d new cljs.core.IndexedSeq(G__23681__a,0,null);\n}\nreturn G__23660__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, G__23680);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23660.cljs$lang$maxFixedArity \x3d 3;\nG__23660.cljs$lang$applyTo \x3d G__23660__4.cljs$lang$applyTo;\nG__23660.cljs$core$IFn$_invoke$arity$2 \x3d G__23660__2;\nG__23660.cljs$core$IFn$_invoke$arity$3 \x3d G__23660__3;\nG__23660.cljs$core$IFn$_invoke$arity$variadic \x3d G__23660__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23660;\n})()\n}));\n\n(cljs.core.fnil.cljs$core$IFn$_invoke$arity$4 \x3d (function (f,x,y,z){\nreturn (function() {\nvar G__23682 \x3d null;\nvar G__23682__2 \x3d (function (a,b){\nvar G__17948 \x3d (((a \x3d\x3d null))?x:a);\nvar G__17949 \x3d (((b \x3d\x3d null))?y:b);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17948,G__17949) : f.call(null, G__17948,G__17949));\n});\nvar G__23682__3 \x3d (function (a,b,c){\nvar G__17950 \x3d (((a \x3d\x3d null))?x:a);\nvar G__17951 \x3d (((b \x3d\x3d null))?y:b);\nvar G__17952 \x3d (((c \x3d\x3d null))?z:c);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__17950,G__17951,G__17952) : f.call(null, G__17950,G__17951,G__17952));\n});\nvar G__23682__4 \x3d (function() { \nvar G__23685__delegate \x3d function (a,b,c,ds){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,(((a \x3d\x3d null))?x:a),(((b \x3d\x3d null))?y:b),(((c \x3d\x3d null))?z:c),ds);\n};\nvar G__23685 \x3d function (a,b,c,var_args){\nvar ds \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23691__i \x3d 0, G__23691__a \x3d new Array(arguments.length -  3);\nwhile (G__23691__i \x3c G__23691__a.length) {G__23691__a[G__23691__i] \x3d arguments[G__23691__i + 3]; ++G__23691__i;}\n  ds \x3d new cljs.core.IndexedSeq(G__23691__a,0,null);\n} \nreturn G__23685__delegate.call(this,a,b,c,ds);};\nG__23685.cljs$lang$maxFixedArity \x3d 3;\nG__23685.cljs$lang$applyTo \x3d (function (arglist__23693){\nvar a \x3d cljs.core.first(arglist__23693);\narglist__23693 \x3d cljs.core.next(arglist__23693);\nvar b \x3d cljs.core.first(arglist__23693);\narglist__23693 \x3d cljs.core.next(arglist__23693);\nvar c \x3d cljs.core.first(arglist__23693);\nvar ds \x3d cljs.core.rest(arglist__23693);\nreturn G__23685__delegate(a,b,c,ds);\n});\nG__23685.cljs$core$IFn$_invoke$arity$variadic \x3d G__23685__delegate;\nreturn G__23685;\n})()\n;\nG__23682 \x3d function(a,b,c,var_args){\nvar ds \x3d var_args;\nswitch(arguments.length){\ncase 2:\nreturn G__23682__2.call(this,a,b);\ncase 3:\nreturn G__23682__3.call(this,a,b,c);\ndefault:\nvar G__23697 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__23698__i \x3d 0, G__23698__a \x3d new Array(arguments.length -  3);\nwhile (G__23698__i \x3c G__23698__a.length) {G__23698__a[G__23698__i] \x3d arguments[G__23698__i + 3]; ++G__23698__i;}\nG__23697 \x3d new cljs.core.IndexedSeq(G__23698__a,0,null);\n}\nreturn G__23682__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, G__23697);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23682.cljs$lang$maxFixedArity \x3d 3;\nG__23682.cljs$lang$applyTo \x3d G__23682__4.cljs$lang$applyTo;\nG__23682.cljs$core$IFn$_invoke$arity$2 \x3d G__23682__2;\nG__23682.cljs$core$IFn$_invoke$arity$3 \x3d G__23682__3;\nG__23682.cljs$core$IFn$_invoke$arity$variadic \x3d G__23682__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__23682;\n})()\n}));\n\n(cljs.core.fnil.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Returns a lazy sequence consisting of the result of applying f to 0\n *   and the first item of coll, followed by applying f to 1 and the second\n *   item in coll, etc, until coll is exhausted. Thus function f should\n *   accept 2 arguments, index and item. Returns a stateful transducer when\n *   no collection is provided.\n */\ncljs.core.map_indexed \x3d (function cljs$core$map_indexed(var_args){\nvar G__17954 \x3d arguments.length;\nswitch (G__17954) {\ncase 1:\nreturn cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn (function (rf){\nvar i \x3d (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)));\nreturn (function() {\nvar G__23710 \x3d null;\nvar G__23710__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__23710__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__23710__2 \x3d (function (result,input){\nvar G__17955 \x3d result;\nvar G__17956 \x3d (function (){var G__17957 \x3d cljs.core._vreset_BANG_(i,(cljs.core._deref(i) + (1)));\nvar G__17958 \x3d input;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17957,G__17958) : f.call(null, G__17957,G__17958));\n})();\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__17955,G__17956) : rf.call(null, G__17955,G__17956));\n});\nG__23710 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__23710__0.call(this);\ncase 1:\nreturn G__23710__1.call(this,result);\ncase 2:\nreturn G__23710__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23710.cljs$core$IFn$_invoke$arity$0 \x3d G__23710__0;\nG__23710.cljs$core$IFn$_invoke$arity$1 \x3d G__23710__1;\nG__23710.cljs$core$IFn$_invoke$arity$2 \x3d G__23710__2;\nreturn G__23710;\n})()\n});\n}));\n\n(cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nvar mapi \x3d (function cljs$core$mapi(idx,coll__$1){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll__$1);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s)){\nvar c \x3d cljs.core.chunk_first(s);\nvar size \x3d cljs.core.count(c);\nvar b \x3d cljs.core.chunk_buffer(size);\nvar n__5593__auto___23719 \x3d size;\nvar i_23720 \x3d (0);\nwhile(true){\nif((i_23720 \x3c n__5593__auto___23719)){\ncljs.core.chunk_append(b,(function (){var G__17963 \x3d (idx + i_23720);\nvar G__17964 \x3d cljs.core._nth(c,i_23720);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17963,G__17964) : f.call(null, G__17963,G__17964));\n})());\n\nvar G__23725 \x3d (i_23720 + (1));\ni_23720 \x3d G__23725;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core.chunk_cons(cljs.core.chunk(b),cljs$core$mapi((idx + size),cljs.core.chunk_rest(s)));\n} else {\nreturn cljs.core.cons((function (){var G__17965 \x3d idx;\nvar G__17966 \x3d cljs.core.first(s);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__17965,G__17966) : f.call(null, G__17965,G__17966));\n})(),cljs$core$mapi((idx + (1)),cljs.core.rest(s)));\n}\n} else {\nreturn null;\n}\n}),null,null));\n});\nreturn mapi((0),coll);\n}));\n\n(cljs.core.map_indexed.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a lazy sequence of the non-nil results of (f item). Note,\n *   this means false return values will be included.  f must be free of\n *   side-effects.  Returns a transducer when no collection is provided.\n */\ncljs.core.keep \x3d (function cljs$core$keep(var_args){\nvar G__17968 \x3d arguments.length;\nswitch (G__17968) {\ncase 1:\nreturn cljs.core.keep.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.keep.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.keep.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn (function (rf){\nreturn (function() {\nvar G__23735 \x3d null;\nvar G__23735__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__23735__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__23735__2 \x3d (function (result,input){\nvar v \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(input) : f.call(null, input));\nif((v \x3d\x3d null)){\nreturn result;\n} else {\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null, result,v));\n}\n});\nG__23735 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__23735__0.call(this);\ncase 1:\nreturn G__23735__1.call(this,result);\ncase 2:\nreturn G__23735__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__23735.cljs$core$IFn$_invoke$arity$0 \x3d G__23735__0;\nG__23735.cljs$core$IFn$_invoke$arity$1 \x3d G__23735__1;\nG__23735.cljs$core$IFn$_invoke$arity$2 \x3d G__23735__2;\nreturn G__23735;\n})()\n});\n}));\n\n(cljs.core.keep.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s)){\nvar c \x3d cljs.core.chunk_first(s);\nvar size \x3d cljs.core.count(c);\nvar b \x3d cljs.core.chunk_buffer(size);\nvar n__5593__auto___23738 \x3d size;\nvar i_23740 \x3d (0);\nwhile(true){\nif((i_23740 \x3c n__5593__auto___23738)){\nvar x_23741 \x3d (function (){var G__17969 \x3d cljs.core._nth(c,i_23740);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17969) : f.call(null, G__17969));\n})();\nif((x_23741 \x3d\x3d null)){\n} else {\ncljs.core.chunk_append(b,x_23741);\n}\n\nvar G__23746 \x3d (i_23740 + (1));\ni_23740 \x3d G__23746;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core.chunk_cons(cljs.core.chunk(b),cljs.core.keep.cljs$core$IFn$_invoke$arity$2(f,cljs.core.chunk_rest(s)));\n} else {\nvar x \x3d (function (){var G__17970 \x3d cljs.core.first(s);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__17970) : f.call(null, G__17970));\n})();\nif((x \x3d\x3d null)){\nreturn cljs.core.keep.cljs$core$IFn$_invoke$arity$2(f,cljs.core.rest(s));\n} else {\nreturn cljs.core.cons(x,cljs.core.keep.cljs$core$IFn$_invoke$arity$2(f,cljs.core.rest(s)));\n}\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.keep.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IWatchable}\n * @implements {cljs.core.IAtom}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IDeref}\n*/\ncljs.core.Atom \x3d (function (state,meta,validator,watches){\nthis.state \x3d state;\nthis.meta \x3d meta;\nthis.validator \x3d validator;\nthis.watches \x3d watches;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 16386;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 6455296;\n});\n(cljs.core.Atom.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (o,other){\nvar self__ \x3d this;\nvar o__$1 \x3d this;\nreturn (o__$1 \x3d\x3d\x3d other);\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.state;\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IWatchable$_notify_watches$arity$3 \x3d (function (this$,oldval,newval){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar seq__17971 \x3d cljs.core.seq(self__.watches);\nvar chunk__17972 \x3d null;\nvar count__17973 \x3d (0);\nvar i__17974 \x3d (0);\nwhile(true){\nif((i__17974 \x3c count__17973)){\nvar vec__17981 \x3d chunk__17972.cljs$core$IIndexed$_nth$arity$2(null, i__17974);\nvar key \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17981,(0),null);\nvar f \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17981,(1),null);\n(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));\n\n\nvar G__23799 \x3d seq__17971;\nvar G__23800 \x3d chunk__17972;\nvar G__23801 \x3d count__17973;\nvar G__23802 \x3d (i__17974 + (1));\nseq__17971 \x3d G__23799;\nchunk__17972 \x3d G__23800;\ncount__17973 \x3d G__23801;\ni__17974 \x3d G__23802;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__17971);\nif(temp__5804__auto__){\nvar seq__17971__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__17971__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__17971__$1);\nvar G__23813 \x3d cljs.core.chunk_rest(seq__17971__$1);\nvar G__23814 \x3d c__5525__auto__;\nvar G__23815 \x3d cljs.core.count(c__5525__auto__);\nvar G__23816 \x3d (0);\nseq__17971 \x3d G__23813;\nchunk__17972 \x3d G__23814;\ncount__17973 \x3d G__23815;\ni__17974 \x3d G__23816;\ncontinue;\n} else {\nvar vec__17984 \x3d cljs.core.first(seq__17971__$1);\nvar key \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17984,(0),null);\nvar f \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__17984,(1),null);\n(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));\n\n\nvar G__23825 \x3d cljs.core.next(seq__17971__$1);\nvar G__23826 \x3d null;\nvar G__23827 \x3d (0);\nvar G__23828 \x3d (0);\nseq__17971 \x3d G__23825;\nchunk__17972 \x3d G__23826;\ncount__17973 \x3d G__23827;\ni__17974 \x3d G__23828;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IWatchable$_add_watch$arity$3 \x3d (function (this$,key,f){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\n(this$__$1.watches \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.watches,key,f));\n\nreturn this$__$1;\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IWatchable$_remove_watch$arity$2 \x3d (function (this$,key){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (this$__$1.watches \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.watches,key));\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn goog.getUid(this$__$1);\n}));\n\n(cljs.core.Atom.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22state\x22,\x22state\x22,-348086572,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22validator\x22,\x22validator\x22,-325659154,null),new cljs.core.Symbol(null,\x22watches\x22,\x22watches\x22,1367433992,null)], null);\n}));\n\n(cljs.core.Atom.cljs$lang$type \x3d true);\n\n(cljs.core.Atom.cljs$lang$ctorStr \x3d \x22cljs.core/Atom\x22);\n\n(cljs.core.Atom.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Atom\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Atom.\n */\ncljs.core.__GT_Atom \x3d (function cljs$core$__GT_Atom(state,meta,validator,watches){\nreturn (new cljs.core.Atom(state,meta,validator,watches));\n});\n\n/**\n * Creates and returns an Atom with an initial value of x and zero or\n *   more options (in any order):\n * \n *   :meta metadata-map\n * \n *   :validator validate-fn\n * \n *   If metadata-map is supplied, it will become the metadata on the\n *   atom. validate-fn must be nil or a side-effect-free fn of one\n *   argument, which will be passed the intended new state on any state\n *   change. If the new state is unacceptable, the validate-fn should\n *   return false or throw an Error.  If either of these error conditions\n *   occur, then the value of the atom will not change.\n */\ncljs.core.atom \x3d (function cljs$core$atom(var_args){\nvar G__17990 \x3d arguments.length;\nswitch (G__17990) {\ncase 1:\nreturn cljs.core.atom.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23864 \x3d arguments.length;\nvar i__5727__auto___23870 \x3d (0);\nwhile(true){\nif((i__5727__auto___23870 \x3c len__5726__auto___23864)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23870]));\n\nvar G__23875 \x3d (i__5727__auto___23870 + (1));\ni__5727__auto___23870 \x3d G__23875;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((1) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.atom.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.atom.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn (new cljs.core.Atom(x,null,null,null));\n}));\n\n(cljs.core.atom.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,p__17991){\nvar map__17992 \x3d p__17991;\nvar map__17992__$1 \x3d cljs.core.__destructure_map(map__17992);\nvar meta \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__17992__$1,new cljs.core.Keyword(null,\x22meta\x22,\x22meta\x22,1499536964));\nvar validator \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__17992__$1,new cljs.core.Keyword(null,\x22validator\x22,\x22validator\x22,-1966190681));\nreturn (new cljs.core.Atom(x,meta,validator,null));\n}));\n\n/** @this {Function} */\n(cljs.core.atom.cljs$lang$applyTo \x3d (function (seq17988){\nvar G__17989 \x3d cljs.core.first(seq17988);\nvar seq17988__$1 \x3d cljs.core.next(seq17988);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17989,seq17988__$1);\n}));\n\n(cljs.core.atom.cljs$lang$maxFixedArity \x3d (1));\n\n/**\n * Sets the value of atom to newval without regard for the\n *   current value. Returns new-value.\n */\ncljs.core.reset_BANG_ \x3d (function cljs$core$reset_BANG_(a,new_value){\nif((a instanceof cljs.core.Atom)){\nvar validate \x3d a.validator;\nif((validate \x3d\x3d null)){\n} else {\nif(cljs.core.truth_((validate.cljs$core$IFn$_invoke$arity$1 ? validate.cljs$core$IFn$_invoke$arity$1(new_value) : validate.call(null, new_value)))){\n} else {\nthrow (new Error(\x22Validator rejected reference state\x22));\n}\n}\n\nvar old_value \x3d a.state;\n(a.state \x3d new_value);\n\nif((a.watches \x3d\x3d null)){\n} else {\na.cljs$core$IWatchable$_notify_watches$arity$3(null, old_value,new_value);\n}\n\nreturn new_value;\n} else {\nreturn cljs.core._reset_BANG_(a,new_value);\n}\n});\n/**\n * Sets the value of atom to newval. Returns [old new], the value of the\n * atom before and after the reset.\n */\ncljs.core.reset_vals_BANG_ \x3d (function cljs$core$reset_vals_BANG_(a,new_value){\nif((a instanceof cljs.core.Atom)){\nvar validate \x3d a.validator;\nif((validate \x3d\x3d null)){\n} else {\nif(cljs.core.truth_((validate.cljs$core$IFn$_invoke$arity$1 ? validate.cljs$core$IFn$_invoke$arity$1(new_value) : validate.call(null, new_value)))){\n} else {\nthrow (new Error(\x22Validator rejected reference state\x22));\n}\n}\n\nvar old_value \x3d a.state;\n(a.state \x3d new_value);\n\nif((a.watches \x3d\x3d null)){\n} else {\na.cljs$core$IWatchable$_notify_watches$arity$3(null, old_value,new_value);\n}\n\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [old_value,new_value], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core._deref(a),cljs.core._reset_BANG_(a,new_value)], null);\n}\n});\n/**\n * Atomically swaps the value of atom to be:\n *   (apply f current-value-of-atom args). Note that f may be called\n *   multiple times, and thus should be free of side effects.  Returns\n *   the value that was swapped in.\n */\ncljs.core.swap_BANG_ \x3d (function cljs$core$swap_BANG_(var_args){\nvar G__17999 \x3d arguments.length;\nswitch (G__17999) {\ncase 2:\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23895 \x3d arguments.length;\nvar i__5727__auto___23896 \x3d (0);\nwhile(true){\nif((i__5727__auto___23896 \x3c len__5726__auto___23895)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23896]));\n\nvar G__23898 \x3d (i__5727__auto___23896 + (1));\ni__5727__auto___23896 \x3d G__23898;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((4) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((4)),(0),null)):null);\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (a,f){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_BANG_(a,(function (){var G__18000 \x3d a.state;\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__18000) : f.call(null, G__18000));\n})());\n} else {\nreturn cljs.core._swap_BANG_(a,f);\n}\n}));\n\n(cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (a,f,x){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_BANG_(a,(function (){var G__18001 \x3d a.state;\nvar G__18002 \x3d x;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18001,G__18002) : f.call(null, G__18001,G__18002));\n})());\n} else {\nreturn cljs.core._swap_BANG_(a,f,x);\n}\n}));\n\n(cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4 \x3d (function (a,f,x,y){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_BANG_(a,(function (){var G__18003 \x3d a.state;\nvar G__18004 \x3d x;\nvar G__18005 \x3d y;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18003,G__18004,G__18005) : f.call(null, G__18003,G__18004,G__18005));\n})());\n} else {\nreturn cljs.core._swap_BANG_(a,f,x,y);\n}\n}));\n\n(cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (a,f,x,y,more){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_BANG_(a,cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,a.state,x,y,more));\n} else {\nreturn cljs.core._swap_BANG_(a,f,x,y,more);\n}\n}));\n\n/** @this {Function} */\n(cljs.core.swap_BANG_.cljs$lang$applyTo \x3d (function (seq17994){\nvar G__17995 \x3d cljs.core.first(seq17994);\nvar seq17994__$1 \x3d cljs.core.next(seq17994);\nvar G__17996 \x3d cljs.core.first(seq17994__$1);\nvar seq17994__$2 \x3d cljs.core.next(seq17994__$1);\nvar G__17997 \x3d cljs.core.first(seq17994__$2);\nvar seq17994__$3 \x3d cljs.core.next(seq17994__$2);\nvar G__17998 \x3d cljs.core.first(seq17994__$3);\nvar seq17994__$4 \x3d cljs.core.next(seq17994__$3);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__17995,G__17996,G__17997,G__17998,seq17994__$4);\n}));\n\n(cljs.core.swap_BANG_.cljs$lang$maxFixedArity \x3d (4));\n\n/**\n * Atomically swaps the value of atom to be:\n *   (apply f current-value-of-atom args). Note that f may be called\n *   multiple times, and thus should be free of side effects.\n *   Returns [old new], the value of the atom before and after the swap.\n */\ncljs.core.swap_vals_BANG_ \x3d (function cljs$core$swap_vals_BANG_(var_args){\nvar G__18012 \x3d arguments.length;\nswitch (G__18012) {\ncase 2:\nreturn cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___23914 \x3d arguments.length;\nvar i__5727__auto___23916 \x3d (0);\nwhile(true){\nif((i__5727__auto___23916 \x3c len__5726__auto___23914)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___23916]));\n\nvar G__23919 \x3d (i__5727__auto___23916 + (1));\ni__5727__auto___23916 \x3d G__23919;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((4) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((4)),(0),null)):null);\nreturn cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (a,f){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_vals_BANG_(a,(function (){var G__18013 \x3d a.state;\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__18013) : f.call(null, G__18013));\n})());\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core._deref(a),cljs.core._swap_BANG_(a,f)], null);\n}\n}));\n\n(cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (a,f,x){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_vals_BANG_(a,(function (){var G__18014 \x3d a.state;\nvar G__18015 \x3d x;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18014,G__18015) : f.call(null, G__18014,G__18015));\n})());\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core._deref(a),cljs.core._swap_BANG_(a,f,x)], null);\n}\n}));\n\n(cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$4 \x3d (function (a,f,x,y){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_vals_BANG_(a,(function (){var G__18016 \x3d a.state;\nvar G__18017 \x3d x;\nvar G__18018 \x3d y;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18016,G__18017,G__18018) : f.call(null, G__18016,G__18017,G__18018));\n})());\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core._deref(a),cljs.core._swap_BANG_(a,f,x,y)], null);\n}\n}));\n\n(cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (a,f,x,y,more){\nif((a instanceof cljs.core.Atom)){\nreturn cljs.core.reset_vals_BANG_(a,cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,a.state,x,y,more));\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core._deref(a),cljs.core._swap_BANG_(a,f,x,y,more)], null);\n}\n}));\n\n/** @this {Function} */\n(cljs.core.swap_vals_BANG_.cljs$lang$applyTo \x3d (function (seq18007){\nvar G__18008 \x3d cljs.core.first(seq18007);\nvar seq18007__$1 \x3d cljs.core.next(seq18007);\nvar G__18009 \x3d cljs.core.first(seq18007__$1);\nvar seq18007__$2 \x3d cljs.core.next(seq18007__$1);\nvar G__18010 \x3d cljs.core.first(seq18007__$2);\nvar seq18007__$3 \x3d cljs.core.next(seq18007__$2);\nvar G__18011 \x3d cljs.core.first(seq18007__$3);\nvar seq18007__$4 \x3d cljs.core.next(seq18007__$3);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18008,G__18009,G__18010,G__18011,seq18007__$4);\n}));\n\n(cljs.core.swap_vals_BANG_.cljs$lang$maxFixedArity \x3d (4));\n\n/**\n * Atomically sets the value of atom to newval if and only if the\n *   current value of the atom is equal to oldval. Returns true if\n *   set happened, else false.\n */\ncljs.core.compare_and_set_BANG_ \x3d (function cljs$core$compare_and_set_BANG_(a,oldval,newval){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a.cljs$core$IDeref$_deref$arity$1(null, ),oldval)){\ncljs.core.reset_BANG_(a,newval);\n\nreturn true;\n} else {\nreturn false;\n}\n});\n/**\n * Sets the validator-fn for an atom. validator-fn must be nil or a\n *   side-effect-free fn of one argument, which will be passed the intended\n *   new state on any state change. If the new state is unacceptable, the\n *   validator-fn should return false or throw an Error. If the current state\n *   is not acceptable to the new validator, an Error will be thrown and the\n *   validator will not be changed.\n */\ncljs.core.set_validator_BANG_ \x3d (function cljs$core$set_validator_BANG_(iref,val){\nif((((!((val \x3d\x3d null)))) \x26\x26 (cljs.core.not((function (){var G__18019 \x3d cljs.core._deref(iref);\nreturn (val.cljs$core$IFn$_invoke$arity$1 ? val.cljs$core$IFn$_invoke$arity$1(G__18019) : val.call(null, G__18019));\n})())))){\nthrow (new Error(\x22Validator rejected reference state\x22));\n} else {\n}\n\nreturn (iref.validator \x3d val);\n});\n/**\n * Gets the validator-fn for a var/ref/agent/atom.\n */\ncljs.core.get_validator \x3d (function cljs$core$get_validator(iref){\nreturn iref.validator;\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IVolatile}\n * @implements {cljs.core.IDeref}\n*/\ncljs.core.Volatile \x3d (function (state){\nthis.state \x3d state;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32768;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.Volatile.prototype.cljs$core$IVolatile$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Volatile.prototype.cljs$core$IVolatile$_vreset_BANG_$arity$2 \x3d (function (_,new_state){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (self__.state \x3d new_state);\n}));\n\n(cljs.core.Volatile.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.state;\n}));\n\n(cljs.core.Volatile.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22state\x22,\x22state\x22,-348086572,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Volatile.cljs$lang$type \x3d true);\n\n(cljs.core.Volatile.cljs$lang$ctorStr \x3d \x22cljs.core/Volatile\x22);\n\n(cljs.core.Volatile.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Volatile\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Volatile.\n */\ncljs.core.__GT_Volatile \x3d (function cljs$core$__GT_Volatile(state){\nreturn (new cljs.core.Volatile(state));\n});\n\n/**\n * Creates and returns a Volatile with an initial value of val.\n */\ncljs.core.volatile_BANG_ \x3d (function cljs$core$volatile_BANG_(val){\nreturn (new cljs.core.Volatile(val));\n});\n/**\n * Returns true if x is a volatile.\n */\ncljs.core.volatile_QMARK_ \x3d (function cljs$core$volatile_QMARK_(x){\nreturn (x instanceof cljs.core.Volatile);\n});\n/**\n * Sets the value of volatile to newval without regard for the\n * current value. Returns newval.\n */\ncljs.core.vreset_BANG_ \x3d (function cljs$core$vreset_BANG_(vol,newval){\nreturn cljs.core._vreset_BANG_(vol,newval);\n});\n/**\n * Returns a lazy sequence of the non-nil results of (f index item). Note,\n *   this means false return values will be included.  f must be free of\n *   side-effects.  Returns a stateful transducer when no collection is\n *   provided.\n */\ncljs.core.keep_indexed \x3d (function cljs$core$keep_indexed(var_args){\nvar G__18021 \x3d arguments.length;\nswitch (G__18021) {\ncase 1:\nreturn cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn (function (rf){\nvar ia \x3d cljs.core.volatile_BANG_((-1));\nreturn (function() {\nvar G__24010 \x3d null;\nvar G__24010__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__24010__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__24010__2 \x3d (function (result,input){\nvar i \x3d ia.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (ia.cljs$core$IDeref$_deref$arity$1(null, ) + (1)));\nvar v \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(i,input) : f.call(null, i,input));\nif((v \x3d\x3d null)){\nreturn result;\n} else {\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null, result,v));\n}\n});\nG__24010 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__24010__0.call(this);\ncase 1:\nreturn G__24010__1.call(this,result);\ncase 2:\nreturn G__24010__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24010.cljs$core$IFn$_invoke$arity$0 \x3d G__24010__0;\nG__24010.cljs$core$IFn$_invoke$arity$1 \x3d G__24010__1;\nG__24010.cljs$core$IFn$_invoke$arity$2 \x3d G__24010__2;\nreturn G__24010;\n})()\n});\n}));\n\n(cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nvar keepi \x3d (function cljs$core$keepi(idx,coll__$1){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll__$1);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s)){\nvar c \x3d cljs.core.chunk_first(s);\nvar size \x3d cljs.core.count(c);\nvar b \x3d cljs.core.chunk_buffer(size);\nvar n__5593__auto___24027 \x3d size;\nvar i_24028 \x3d (0);\nwhile(true){\nif((i_24028 \x3c n__5593__auto___24027)){\nvar x_24029 \x3d (function (){var G__18026 \x3d (idx + i_24028);\nvar G__18027 \x3d cljs.core._nth(c,i_24028);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18026,G__18027) : f.call(null, G__18026,G__18027));\n})();\nif((x_24029 \x3d\x3d null)){\n} else {\ncljs.core.chunk_append(b,x_24029);\n}\n\nvar G__24031 \x3d (i_24028 + (1));\ni_24028 \x3d G__24031;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core.chunk_cons(cljs.core.chunk(b),cljs$core$keepi((idx + size),cljs.core.chunk_rest(s)));\n} else {\nvar x \x3d (function (){var G__18028 \x3d idx;\nvar G__18029 \x3d cljs.core.first(s);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18028,G__18029) : f.call(null, G__18028,G__18029));\n})();\nif((x \x3d\x3d null)){\nreturn cljs$core$keepi((idx + (1)),cljs.core.rest(s));\n} else {\nreturn cljs.core.cons(x,cljs$core$keepi((idx + (1)),cljs.core.rest(s)));\n}\n}\n} else {\nreturn null;\n}\n}),null,null));\n});\nreturn keepi((0),coll);\n}));\n\n(cljs.core.keep_indexed.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Takes a set of predicates and returns a function f that returns true if all of its\n *   composing predicates return a logical true value against all of its arguments, else it returns\n *   false. Note that f is short-circuiting in that it will stop execution on the first\n *   argument that triggers a logical false result against the original predicates.\n */\ncljs.core.every_pred \x3d (function cljs$core$every_pred(var_args){\nvar G__18041 \x3d arguments.length;\nswitch (G__18041) {\ncase 1:\nreturn cljs.core.every_pred.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.every_pred.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.every_pred.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24036 \x3d arguments.length;\nvar i__5727__auto___24037 \x3d (0);\nwhile(true){\nif((i__5727__auto___24037 \x3c len__5726__auto___24036)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24037]));\n\nvar G__24038 \x3d (i__5727__auto___24037 + (1));\ni__5727__auto___24037 \x3d G__24038;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.every_pred.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.every_pred.cljs$core$IFn$_invoke$arity$1 \x3d (function (p){\nreturn (function() {\nvar cljs$core$ep1 \x3d null;\nvar cljs$core$ep1__0 \x3d (function (){\nreturn true;\n});\nvar cljs$core$ep1__1 \x3d (function (x){\nreturn cljs.core.boolean$((p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null, x)));\n});\nvar cljs$core$ep1__2 \x3d (function (x,y){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null, y));\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep1__3 \x3d (function (x,y,z){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(z) : p.call(null, z));\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep1__4 \x3d (function() { \nvar G__24044__delegate \x3d function (x,y,z,args){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d cljs$core$ep1.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.every_QMARK_(p,args);\n} else {\nreturn and__5000__auto__;\n}\n})());\n};\nvar G__24044 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24046__i \x3d 0, G__24046__a \x3d new Array(arguments.length -  3);\nwhile (G__24046__i \x3c G__24046__a.length) {G__24046__a[G__24046__i] \x3d arguments[G__24046__i + 3]; ++G__24046__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24046__a,0,null);\n} \nreturn G__24044__delegate.call(this,x,y,z,args);};\nG__24044.cljs$lang$maxFixedArity \x3d 3;\nG__24044.cljs$lang$applyTo \x3d (function (arglist__24047){\nvar x \x3d cljs.core.first(arglist__24047);\narglist__24047 \x3d cljs.core.next(arglist__24047);\nvar y \x3d cljs.core.first(arglist__24047);\narglist__24047 \x3d cljs.core.next(arglist__24047);\nvar z \x3d cljs.core.first(arglist__24047);\nvar args \x3d cljs.core.rest(arglist__24047);\nreturn G__24044__delegate(x,y,z,args);\n});\nG__24044.cljs$core$IFn$_invoke$arity$variadic \x3d G__24044__delegate;\nreturn G__24044;\n})()\n;\ncljs$core$ep1 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$ep1__0.call(this);\ncase 1:\nreturn cljs$core$ep1__1.call(this,x);\ncase 2:\nreturn cljs$core$ep1__2.call(this,x,y);\ncase 3:\nreturn cljs$core$ep1__3.call(this,x,y,z);\ndefault:\nvar G__24048 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24049__i \x3d 0, G__24049__a \x3d new Array(arguments.length -  3);\nwhile (G__24049__i \x3c G__24049__a.length) {G__24049__a[G__24049__i] \x3d arguments[G__24049__i + 3]; ++G__24049__i;}\nG__24048 \x3d new cljs.core.IndexedSeq(G__24049__a,0,null);\n}\nreturn cljs$core$ep1__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24048);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$ep1.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$ep1.cljs$lang$applyTo \x3d cljs$core$ep1__4.cljs$lang$applyTo;\ncljs$core$ep1.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$ep1__0;\ncljs$core$ep1.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$ep1__1;\ncljs$core$ep1.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$ep1__2;\ncljs$core$ep1.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$ep1__3;\ncljs$core$ep1.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$ep1__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$ep1;\n})()\n}));\n\n(cljs.core.every_pred.cljs$core$IFn$_invoke$arity$2 \x3d (function (p1,p2){\nreturn (function() {\nvar cljs$core$ep2 \x3d null;\nvar cljs$core$ep2__0 \x3d (function (){\nreturn true;\n});\nvar cljs$core$ep2__1 \x3d (function (x){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep2__2 \x3d (function (x,y){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$1)){\nvar and__5000__auto____$2 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(and__5000__auto____$2)){\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep2__3 \x3d (function (x,y,z){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$1)){\nvar and__5000__auto____$2 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null, z));\nif(cljs.core.truth_(and__5000__auto____$2)){\nvar and__5000__auto____$3 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(and__5000__auto____$3)){\nvar and__5000__auto____$4 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$4)){\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null, z));\n} else {\nreturn and__5000__auto____$4;\n}\n} else {\nreturn and__5000__auto____$3;\n}\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep2__4 \x3d (function() { \nvar G__24057__delegate \x3d function (x,y,z,args){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d cljs$core$ep2.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.every_QMARK_((function (p1__18030_SHARP_){\nvar and__5000__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__18030_SHARP_) : p1.call(null, p1__18030_SHARP_));\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__18030_SHARP_) : p2.call(null, p1__18030_SHARP_));\n} else {\nreturn and__5000__auto____$1;\n}\n}),args);\n} else {\nreturn and__5000__auto__;\n}\n})());\n};\nvar G__24057 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24059__i \x3d 0, G__24059__a \x3d new Array(arguments.length -  3);\nwhile (G__24059__i \x3c G__24059__a.length) {G__24059__a[G__24059__i] \x3d arguments[G__24059__i + 3]; ++G__24059__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24059__a,0,null);\n} \nreturn G__24057__delegate.call(this,x,y,z,args);};\nG__24057.cljs$lang$maxFixedArity \x3d 3;\nG__24057.cljs$lang$applyTo \x3d (function (arglist__24060){\nvar x \x3d cljs.core.first(arglist__24060);\narglist__24060 \x3d cljs.core.next(arglist__24060);\nvar y \x3d cljs.core.first(arglist__24060);\narglist__24060 \x3d cljs.core.next(arglist__24060);\nvar z \x3d cljs.core.first(arglist__24060);\nvar args \x3d cljs.core.rest(arglist__24060);\nreturn G__24057__delegate(x,y,z,args);\n});\nG__24057.cljs$core$IFn$_invoke$arity$variadic \x3d G__24057__delegate;\nreturn G__24057;\n})()\n;\ncljs$core$ep2 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$ep2__0.call(this);\ncase 1:\nreturn cljs$core$ep2__1.call(this,x);\ncase 2:\nreturn cljs$core$ep2__2.call(this,x,y);\ncase 3:\nreturn cljs$core$ep2__3.call(this,x,y,z);\ndefault:\nvar G__24067 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24068__i \x3d 0, G__24068__a \x3d new Array(arguments.length -  3);\nwhile (G__24068__i \x3c G__24068__a.length) {G__24068__a[G__24068__i] \x3d arguments[G__24068__i + 3]; ++G__24068__i;}\nG__24067 \x3d new cljs.core.IndexedSeq(G__24068__a,0,null);\n}\nreturn cljs$core$ep2__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24067);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$ep2.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$ep2.cljs$lang$applyTo \x3d cljs$core$ep2__4.cljs$lang$applyTo;\ncljs$core$ep2.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$ep2__0;\ncljs$core$ep2.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$ep2__1;\ncljs$core$ep2.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$ep2__2;\ncljs$core$ep2.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$ep2__3;\ncljs$core$ep2.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$ep2__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$ep2;\n})()\n}));\n\n(cljs.core.every_pred.cljs$core$IFn$_invoke$arity$3 \x3d (function (p1,p2,p3){\nreturn (function() {\nvar cljs$core$ep3 \x3d null;\nvar cljs$core$ep3__0 \x3d (function (){\nreturn true;\n});\nvar cljs$core$ep3__1 \x3d (function (x){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null, x));\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep3__2 \x3d (function (x,y){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$1)){\nvar and__5000__auto____$2 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(and__5000__auto____$2)){\nvar and__5000__auto____$3 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$3)){\nvar and__5000__auto____$4 \x3d (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null, x));\nif(cljs.core.truth_(and__5000__auto____$4)){\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null, y));\n} else {\nreturn and__5000__auto____$4;\n}\n} else {\nreturn and__5000__auto____$3;\n}\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep3__3 \x3d (function (x,y,z){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$1)){\nvar and__5000__auto____$2 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null, z));\nif(cljs.core.truth_(and__5000__auto____$2)){\nvar and__5000__auto____$3 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(and__5000__auto____$3)){\nvar and__5000__auto____$4 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$4)){\nvar and__5000__auto____$5 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null, z));\nif(cljs.core.truth_(and__5000__auto____$5)){\nvar and__5000__auto____$6 \x3d (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null, x));\nif(cljs.core.truth_(and__5000__auto____$6)){\nvar and__5000__auto____$7 \x3d (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$7)){\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(z) : p3.call(null, z));\n} else {\nreturn and__5000__auto____$7;\n}\n} else {\nreturn and__5000__auto____$6;\n}\n} else {\nreturn and__5000__auto____$5;\n}\n} else {\nreturn and__5000__auto____$4;\n}\n} else {\nreturn and__5000__auto____$3;\n}\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})());\n});\nvar cljs$core$ep3__4 \x3d (function() { \nvar G__24076__delegate \x3d function (x,y,z,args){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d cljs$core$ep3.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.every_QMARK_((function (p1__18031_SHARP_){\nvar and__5000__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__18031_SHARP_) : p1.call(null, p1__18031_SHARP_));\nif(cljs.core.truth_(and__5000__auto____$1)){\nvar and__5000__auto____$2 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__18031_SHARP_) : p2.call(null, p1__18031_SHARP_));\nif(cljs.core.truth_(and__5000__auto____$2)){\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(p1__18031_SHARP_) : p3.call(null, p1__18031_SHARP_));\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n}),args);\n} else {\nreturn and__5000__auto__;\n}\n})());\n};\nvar G__24076 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24080__i \x3d 0, G__24080__a \x3d new Array(arguments.length -  3);\nwhile (G__24080__i \x3c G__24080__a.length) {G__24080__a[G__24080__i] \x3d arguments[G__24080__i + 3]; ++G__24080__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24080__a,0,null);\n} \nreturn G__24076__delegate.call(this,x,y,z,args);};\nG__24076.cljs$lang$maxFixedArity \x3d 3;\nG__24076.cljs$lang$applyTo \x3d (function (arglist__24082){\nvar x \x3d cljs.core.first(arglist__24082);\narglist__24082 \x3d cljs.core.next(arglist__24082);\nvar y \x3d cljs.core.first(arglist__24082);\narglist__24082 \x3d cljs.core.next(arglist__24082);\nvar z \x3d cljs.core.first(arglist__24082);\nvar args \x3d cljs.core.rest(arglist__24082);\nreturn G__24076__delegate(x,y,z,args);\n});\nG__24076.cljs$core$IFn$_invoke$arity$variadic \x3d G__24076__delegate;\nreturn G__24076;\n})()\n;\ncljs$core$ep3 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$ep3__0.call(this);\ncase 1:\nreturn cljs$core$ep3__1.call(this,x);\ncase 2:\nreturn cljs$core$ep3__2.call(this,x,y);\ncase 3:\nreturn cljs$core$ep3__3.call(this,x,y,z);\ndefault:\nvar G__24083 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24084__i \x3d 0, G__24084__a \x3d new Array(arguments.length -  3);\nwhile (G__24084__i \x3c G__24084__a.length) {G__24084__a[G__24084__i] \x3d arguments[G__24084__i + 3]; ++G__24084__i;}\nG__24083 \x3d new cljs.core.IndexedSeq(G__24084__a,0,null);\n}\nreturn cljs$core$ep3__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24083);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$ep3.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$ep3.cljs$lang$applyTo \x3d cljs$core$ep3__4.cljs$lang$applyTo;\ncljs$core$ep3.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$ep3__0;\ncljs$core$ep3.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$ep3__1;\ncljs$core$ep3.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$ep3__2;\ncljs$core$ep3.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$ep3__3;\ncljs$core$ep3.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$ep3__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$ep3;\n})()\n}));\n\n(cljs.core.every_pred.cljs$core$IFn$_invoke$arity$variadic \x3d (function (p1,p2,p3,ps){\nvar ps__$1 \x3d cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(p1,p2,p3,ps);\nreturn (function() {\nvar cljs$core$epn \x3d null;\nvar cljs$core$epn__0 \x3d (function (){\nreturn true;\n});\nvar cljs$core$epn__1 \x3d (function (x){\nreturn cljs.core.every_QMARK_((function (p1__18032_SHARP_){\nreturn (p1__18032_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18032_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__18032_SHARP_.call(null, x));\n}),ps__$1);\n});\nvar cljs$core$epn__2 \x3d (function (x,y){\nreturn cljs.core.every_QMARK_((function (p1__18033_SHARP_){\nvar and__5000__auto__ \x3d (p1__18033_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18033_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__18033_SHARP_.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (p1__18033_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18033_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__18033_SHARP_.call(null, y));\n} else {\nreturn and__5000__auto__;\n}\n}),ps__$1);\n});\nvar cljs$core$epn__3 \x3d (function (x,y,z){\nreturn cljs.core.every_QMARK_((function (p1__18034_SHARP_){\nvar and__5000__auto__ \x3d (p1__18034_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18034_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__18034_SHARP_.call(null, x));\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d (p1__18034_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18034_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__18034_SHARP_.call(null, y));\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn (p1__18034_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18034_SHARP_.cljs$core$IFn$_invoke$arity$1(z) : p1__18034_SHARP_.call(null, z));\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n}),ps__$1);\n});\nvar cljs$core$epn__4 \x3d (function() { \nvar G__24086__delegate \x3d function (x,y,z,args){\nreturn cljs.core.boolean$((function (){var and__5000__auto__ \x3d cljs$core$epn.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.every_QMARK_((function (p1__18035_SHARP_){\nreturn cljs.core.every_QMARK_(p1__18035_SHARP_,args);\n}),ps__$1);\n} else {\nreturn and__5000__auto__;\n}\n})());\n};\nvar G__24086 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24090__i \x3d 0, G__24090__a \x3d new Array(arguments.length -  3);\nwhile (G__24090__i \x3c G__24090__a.length) {G__24090__a[G__24090__i] \x3d arguments[G__24090__i + 3]; ++G__24090__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24090__a,0,null);\n} \nreturn G__24086__delegate.call(this,x,y,z,args);};\nG__24086.cljs$lang$maxFixedArity \x3d 3;\nG__24086.cljs$lang$applyTo \x3d (function (arglist__24091){\nvar x \x3d cljs.core.first(arglist__24091);\narglist__24091 \x3d cljs.core.next(arglist__24091);\nvar y \x3d cljs.core.first(arglist__24091);\narglist__24091 \x3d cljs.core.next(arglist__24091);\nvar z \x3d cljs.core.first(arglist__24091);\nvar args \x3d cljs.core.rest(arglist__24091);\nreturn G__24086__delegate(x,y,z,args);\n});\nG__24086.cljs$core$IFn$_invoke$arity$variadic \x3d G__24086__delegate;\nreturn G__24086;\n})()\n;\ncljs$core$epn \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$epn__0.call(this);\ncase 1:\nreturn cljs$core$epn__1.call(this,x);\ncase 2:\nreturn cljs$core$epn__2.call(this,x,y);\ncase 3:\nreturn cljs$core$epn__3.call(this,x,y,z);\ndefault:\nvar G__24092 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24093__i \x3d 0, G__24093__a \x3d new Array(arguments.length -  3);\nwhile (G__24093__i \x3c G__24093__a.length) {G__24093__a[G__24093__i] \x3d arguments[G__24093__i + 3]; ++G__24093__i;}\nG__24092 \x3d new cljs.core.IndexedSeq(G__24093__a,0,null);\n}\nreturn cljs$core$epn__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24092);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$epn.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$epn.cljs$lang$applyTo \x3d cljs$core$epn__4.cljs$lang$applyTo;\ncljs$core$epn.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$epn__0;\ncljs$core$epn.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$epn__1;\ncljs$core$epn.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$epn__2;\ncljs$core$epn.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$epn__3;\ncljs$core$epn.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$epn__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$epn;\n})()\n}));\n\n/** @this {Function} */\n(cljs.core.every_pred.cljs$lang$applyTo \x3d (function (seq18037){\nvar G__18038 \x3d cljs.core.first(seq18037);\nvar seq18037__$1 \x3d cljs.core.next(seq18037);\nvar G__18039 \x3d cljs.core.first(seq18037__$1);\nvar seq18037__$2 \x3d cljs.core.next(seq18037__$1);\nvar G__18040 \x3d cljs.core.first(seq18037__$2);\nvar seq18037__$3 \x3d cljs.core.next(seq18037__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18038,G__18039,G__18040,seq18037__$3);\n}));\n\n(cljs.core.every_pred.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * Takes a set of predicates and returns a function f that returns the first logical true value\n *   returned by one of its composing predicates against any of its arguments, else it returns\n *   logical false. Note that f is short-circuiting in that it will stop execution on the first\n *   argument that triggers a logical true result against the original predicates.\n */\ncljs.core.some_fn \x3d (function cljs$core$some_fn(var_args){\nvar G__18053 \x3d arguments.length;\nswitch (G__18053) {\ncase 1:\nreturn cljs.core.some_fn.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.some_fn.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.some_fn.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24098 \x3d arguments.length;\nvar i__5727__auto___24099 \x3d (0);\nwhile(true){\nif((i__5727__auto___24099 \x3c len__5726__auto___24098)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24099]));\n\nvar G__24100 \x3d (i__5727__auto___24099 + (1));\ni__5727__auto___24099 \x3d G__24100;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.some_fn.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.some_fn.cljs$core$IFn$_invoke$arity$1 \x3d (function (p){\nreturn (function() {\nvar cljs$core$sp1 \x3d null;\nvar cljs$core$sp1__0 \x3d (function (){\nreturn null;\n});\nvar cljs$core$sp1__1 \x3d (function (x){\nreturn (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null, x));\n});\nvar cljs$core$sp1__2 \x3d (function (x,y){\nvar or__5002__auto__ \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null, y));\n}\n});\nvar cljs$core$sp1__3 \x3d (function (x,y,z){\nvar or__5002__auto__ \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(z) : p.call(null, z));\n}\n}\n});\nvar cljs$core$sp1__4 \x3d (function() { \nvar G__24108__delegate \x3d function (x,y,z,args){\nvar or__5002__auto__ \x3d cljs$core$sp1.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.some(p,args);\n}\n};\nvar G__24108 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24115__i \x3d 0, G__24115__a \x3d new Array(arguments.length -  3);\nwhile (G__24115__i \x3c G__24115__a.length) {G__24115__a[G__24115__i] \x3d arguments[G__24115__i + 3]; ++G__24115__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24115__a,0,null);\n} \nreturn G__24108__delegate.call(this,x,y,z,args);};\nG__24108.cljs$lang$maxFixedArity \x3d 3;\nG__24108.cljs$lang$applyTo \x3d (function (arglist__24116){\nvar x \x3d cljs.core.first(arglist__24116);\narglist__24116 \x3d cljs.core.next(arglist__24116);\nvar y \x3d cljs.core.first(arglist__24116);\narglist__24116 \x3d cljs.core.next(arglist__24116);\nvar z \x3d cljs.core.first(arglist__24116);\nvar args \x3d cljs.core.rest(arglist__24116);\nreturn G__24108__delegate(x,y,z,args);\n});\nG__24108.cljs$core$IFn$_invoke$arity$variadic \x3d G__24108__delegate;\nreturn G__24108;\n})()\n;\ncljs$core$sp1 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$sp1__0.call(this);\ncase 1:\nreturn cljs$core$sp1__1.call(this,x);\ncase 2:\nreturn cljs$core$sp1__2.call(this,x,y);\ncase 3:\nreturn cljs$core$sp1__3.call(this,x,y,z);\ndefault:\nvar G__24117 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24118__i \x3d 0, G__24118__a \x3d new Array(arguments.length -  3);\nwhile (G__24118__i \x3c G__24118__a.length) {G__24118__a[G__24118__i] \x3d arguments[G__24118__i + 3]; ++G__24118__i;}\nG__24117 \x3d new cljs.core.IndexedSeq(G__24118__a,0,null);\n}\nreturn cljs$core$sp1__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24117);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$sp1.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$sp1.cljs$lang$applyTo \x3d cljs$core$sp1__4.cljs$lang$applyTo;\ncljs$core$sp1.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$sp1__0;\ncljs$core$sp1.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$sp1__1;\ncljs$core$sp1.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$sp1__2;\ncljs$core$sp1.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$sp1__3;\ncljs$core$sp1.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$sp1__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$sp1;\n})()\n}));\n\n(cljs.core.some_fn.cljs$core$IFn$_invoke$arity$2 \x3d (function (p1,p2){\nreturn (function() {\nvar cljs$core$sp2 \x3d null;\nvar cljs$core$sp2__0 \x3d (function (){\nreturn null;\n});\nvar cljs$core$sp2__1 \x3d (function (x){\nvar or__5002__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\n}\n});\nvar cljs$core$sp2__2 \x3d (function (x,y){\nvar or__5002__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nvar or__5002__auto____$2 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(or__5002__auto____$2)){\nreturn or__5002__auto____$2;\n} else {\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\n}\n}\n}\n});\nvar cljs$core$sp2__3 \x3d (function (x,y,z){\nvar or__5002__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nvar or__5002__auto____$2 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null, z));\nif(cljs.core.truth_(or__5002__auto____$2)){\nreturn or__5002__auto____$2;\n} else {\nvar or__5002__auto____$3 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(or__5002__auto____$3)){\nreturn or__5002__auto____$3;\n} else {\nvar or__5002__auto____$4 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$4)){\nreturn or__5002__auto____$4;\n} else {\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null, z));\n}\n}\n}\n}\n}\n});\nvar cljs$core$sp2__4 \x3d (function() { \nvar G__24125__delegate \x3d function (x,y,z,args){\nvar or__5002__auto__ \x3d cljs$core$sp2.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.some((function (p1__18042_SHARP_){\nvar or__5002__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__18042_SHARP_) : p1.call(null, p1__18042_SHARP_));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__18042_SHARP_) : p2.call(null, p1__18042_SHARP_));\n}\n}),args);\n}\n};\nvar G__24125 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24130__i \x3d 0, G__24130__a \x3d new Array(arguments.length -  3);\nwhile (G__24130__i \x3c G__24130__a.length) {G__24130__a[G__24130__i] \x3d arguments[G__24130__i + 3]; ++G__24130__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24130__a,0,null);\n} \nreturn G__24125__delegate.call(this,x,y,z,args);};\nG__24125.cljs$lang$maxFixedArity \x3d 3;\nG__24125.cljs$lang$applyTo \x3d (function (arglist__24131){\nvar x \x3d cljs.core.first(arglist__24131);\narglist__24131 \x3d cljs.core.next(arglist__24131);\nvar y \x3d cljs.core.first(arglist__24131);\narglist__24131 \x3d cljs.core.next(arglist__24131);\nvar z \x3d cljs.core.first(arglist__24131);\nvar args \x3d cljs.core.rest(arglist__24131);\nreturn G__24125__delegate(x,y,z,args);\n});\nG__24125.cljs$core$IFn$_invoke$arity$variadic \x3d G__24125__delegate;\nreturn G__24125;\n})()\n;\ncljs$core$sp2 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$sp2__0.call(this);\ncase 1:\nreturn cljs$core$sp2__1.call(this,x);\ncase 2:\nreturn cljs$core$sp2__2.call(this,x,y);\ncase 3:\nreturn cljs$core$sp2__3.call(this,x,y,z);\ndefault:\nvar G__24135 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24136__i \x3d 0, G__24136__a \x3d new Array(arguments.length -  3);\nwhile (G__24136__i \x3c G__24136__a.length) {G__24136__a[G__24136__i] \x3d arguments[G__24136__i + 3]; ++G__24136__i;}\nG__24135 \x3d new cljs.core.IndexedSeq(G__24136__a,0,null);\n}\nreturn cljs$core$sp2__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24135);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$sp2.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$sp2.cljs$lang$applyTo \x3d cljs$core$sp2__4.cljs$lang$applyTo;\ncljs$core$sp2.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$sp2__0;\ncljs$core$sp2.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$sp2__1;\ncljs$core$sp2.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$sp2__2;\ncljs$core$sp2.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$sp2__3;\ncljs$core$sp2.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$sp2__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$sp2;\n})()\n}));\n\n(cljs.core.some_fn.cljs$core$IFn$_invoke$arity$3 \x3d (function (p1,p2,p3){\nreturn (function() {\nvar cljs$core$sp3 \x3d null;\nvar cljs$core$sp3__0 \x3d (function (){\nreturn null;\n});\nvar cljs$core$sp3__1 \x3d (function (x){\nvar or__5002__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null, x));\n}\n}\n});\nvar cljs$core$sp3__2 \x3d (function (x,y){\nvar or__5002__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nvar or__5002__auto____$2 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(or__5002__auto____$2)){\nreturn or__5002__auto____$2;\n} else {\nvar or__5002__auto____$3 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$3)){\nreturn or__5002__auto____$3;\n} else {\nvar or__5002__auto____$4 \x3d (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null, x));\nif(cljs.core.truth_(or__5002__auto____$4)){\nreturn or__5002__auto____$4;\n} else {\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null, y));\n}\n}\n}\n}\n}\n});\nvar cljs$core$sp3__3 \x3d (function (x,y,z){\nvar or__5002__auto__ \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nvar or__5002__auto____$2 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null, z));\nif(cljs.core.truth_(or__5002__auto____$2)){\nreturn or__5002__auto____$2;\n} else {\nvar or__5002__auto____$3 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null, x));\nif(cljs.core.truth_(or__5002__auto____$3)){\nreturn or__5002__auto____$3;\n} else {\nvar or__5002__auto____$4 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$4)){\nreturn or__5002__auto____$4;\n} else {\nvar or__5002__auto____$5 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null, z));\nif(cljs.core.truth_(or__5002__auto____$5)){\nreturn or__5002__auto____$5;\n} else {\nvar or__5002__auto____$6 \x3d (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null, x));\nif(cljs.core.truth_(or__5002__auto____$6)){\nreturn or__5002__auto____$6;\n} else {\nvar or__5002__auto____$7 \x3d (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$7)){\nreturn or__5002__auto____$7;\n} else {\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(z) : p3.call(null, z));\n}\n}\n}\n}\n}\n}\n}\n}\n});\nvar cljs$core$sp3__4 \x3d (function() { \nvar G__24144__delegate \x3d function (x,y,z,args){\nvar or__5002__auto__ \x3d cljs$core$sp3.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.some((function (p1__18043_SHARP_){\nvar or__5002__auto____$1 \x3d (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__18043_SHARP_) : p1.call(null, p1__18043_SHARP_));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nvar or__5002__auto____$2 \x3d (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__18043_SHARP_) : p2.call(null, p1__18043_SHARP_));\nif(cljs.core.truth_(or__5002__auto____$2)){\nreturn or__5002__auto____$2;\n} else {\nreturn (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(p1__18043_SHARP_) : p3.call(null, p1__18043_SHARP_));\n}\n}\n}),args);\n}\n};\nvar G__24144 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24145__i \x3d 0, G__24145__a \x3d new Array(arguments.length -  3);\nwhile (G__24145__i \x3c G__24145__a.length) {G__24145__a[G__24145__i] \x3d arguments[G__24145__i + 3]; ++G__24145__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24145__a,0,null);\n} \nreturn G__24144__delegate.call(this,x,y,z,args);};\nG__24144.cljs$lang$maxFixedArity \x3d 3;\nG__24144.cljs$lang$applyTo \x3d (function (arglist__24146){\nvar x \x3d cljs.core.first(arglist__24146);\narglist__24146 \x3d cljs.core.next(arglist__24146);\nvar y \x3d cljs.core.first(arglist__24146);\narglist__24146 \x3d cljs.core.next(arglist__24146);\nvar z \x3d cljs.core.first(arglist__24146);\nvar args \x3d cljs.core.rest(arglist__24146);\nreturn G__24144__delegate(x,y,z,args);\n});\nG__24144.cljs$core$IFn$_invoke$arity$variadic \x3d G__24144__delegate;\nreturn G__24144;\n})()\n;\ncljs$core$sp3 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$sp3__0.call(this);\ncase 1:\nreturn cljs$core$sp3__1.call(this,x);\ncase 2:\nreturn cljs$core$sp3__2.call(this,x,y);\ncase 3:\nreturn cljs$core$sp3__3.call(this,x,y,z);\ndefault:\nvar G__24147 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24148__i \x3d 0, G__24148__a \x3d new Array(arguments.length -  3);\nwhile (G__24148__i \x3c G__24148__a.length) {G__24148__a[G__24148__i] \x3d arguments[G__24148__i + 3]; ++G__24148__i;}\nG__24147 \x3d new cljs.core.IndexedSeq(G__24148__a,0,null);\n}\nreturn cljs$core$sp3__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24147);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$sp3.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$sp3.cljs$lang$applyTo \x3d cljs$core$sp3__4.cljs$lang$applyTo;\ncljs$core$sp3.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$sp3__0;\ncljs$core$sp3.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$sp3__1;\ncljs$core$sp3.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$sp3__2;\ncljs$core$sp3.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$sp3__3;\ncljs$core$sp3.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$sp3__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$sp3;\n})()\n}));\n\n(cljs.core.some_fn.cljs$core$IFn$_invoke$arity$variadic \x3d (function (p1,p2,p3,ps){\nvar ps__$1 \x3d cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(p1,p2,p3,ps);\nreturn (function() {\nvar cljs$core$spn \x3d null;\nvar cljs$core$spn__0 \x3d (function (){\nreturn null;\n});\nvar cljs$core$spn__1 \x3d (function (x){\nreturn cljs.core.some((function (p1__18044_SHARP_){\nreturn (p1__18044_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18044_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__18044_SHARP_.call(null, x));\n}),ps__$1);\n});\nvar cljs$core$spn__2 \x3d (function (x,y){\nreturn cljs.core.some((function (p1__18045_SHARP_){\nvar or__5002__auto__ \x3d (p1__18045_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18045_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__18045_SHARP_.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (p1__18045_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18045_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__18045_SHARP_.call(null, y));\n}\n}),ps__$1);\n});\nvar cljs$core$spn__3 \x3d (function (x,y,z){\nreturn cljs.core.some((function (p1__18046_SHARP_){\nvar or__5002__auto__ \x3d (p1__18046_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18046_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__18046_SHARP_.call(null, x));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (p1__18046_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18046_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__18046_SHARP_.call(null, y));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn (p1__18046_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__18046_SHARP_.cljs$core$IFn$_invoke$arity$1(z) : p1__18046_SHARP_.call(null, z));\n}\n}\n}),ps__$1);\n});\nvar cljs$core$spn__4 \x3d (function() { \nvar G__24152__delegate \x3d function (x,y,z,args){\nvar or__5002__auto__ \x3d cljs$core$spn.cljs$core$IFn$_invoke$arity$3(x,y,z);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.some((function (p1__18047_SHARP_){\nreturn cljs.core.some(p1__18047_SHARP_,args);\n}),ps__$1);\n}\n};\nvar G__24152 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24153__i \x3d 0, G__24153__a \x3d new Array(arguments.length -  3);\nwhile (G__24153__i \x3c G__24153__a.length) {G__24153__a[G__24153__i] \x3d arguments[G__24153__i + 3]; ++G__24153__i;}\n  args \x3d new cljs.core.IndexedSeq(G__24153__a,0,null);\n} \nreturn G__24152__delegate.call(this,x,y,z,args);};\nG__24152.cljs$lang$maxFixedArity \x3d 3;\nG__24152.cljs$lang$applyTo \x3d (function (arglist__24155){\nvar x \x3d cljs.core.first(arglist__24155);\narglist__24155 \x3d cljs.core.next(arglist__24155);\nvar y \x3d cljs.core.first(arglist__24155);\narglist__24155 \x3d cljs.core.next(arglist__24155);\nvar z \x3d cljs.core.first(arglist__24155);\nvar args \x3d cljs.core.rest(arglist__24155);\nreturn G__24152__delegate(x,y,z,args);\n});\nG__24152.cljs$core$IFn$_invoke$arity$variadic \x3d G__24152__delegate;\nreturn G__24152;\n})()\n;\ncljs$core$spn \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$spn__0.call(this);\ncase 1:\nreturn cljs$core$spn__1.call(this,x);\ncase 2:\nreturn cljs$core$spn__2.call(this,x,y);\ncase 3:\nreturn cljs$core$spn__3.call(this,x,y,z);\ndefault:\nvar G__24161 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__24162__i \x3d 0, G__24162__a \x3d new Array(arguments.length -  3);\nwhile (G__24162__i \x3c G__24162__a.length) {G__24162__a[G__24162__i] \x3d arguments[G__24162__i + 3]; ++G__24162__i;}\nG__24161 \x3d new cljs.core.IndexedSeq(G__24162__a,0,null);\n}\nreturn cljs$core$spn__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__24161);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$spn.cljs$lang$maxFixedArity \x3d 3;\ncljs$core$spn.cljs$lang$applyTo \x3d cljs$core$spn__4.cljs$lang$applyTo;\ncljs$core$spn.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$spn__0;\ncljs$core$spn.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$spn__1;\ncljs$core$spn.cljs$core$IFn$_invoke$arity$2 \x3d cljs$core$spn__2;\ncljs$core$spn.cljs$core$IFn$_invoke$arity$3 \x3d cljs$core$spn__3;\ncljs$core$spn.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$spn__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn cljs$core$spn;\n})()\n}));\n\n/** @this {Function} */\n(cljs.core.some_fn.cljs$lang$applyTo \x3d (function (seq18049){\nvar G__18050 \x3d cljs.core.first(seq18049);\nvar seq18049__$1 \x3d cljs.core.next(seq18049);\nvar G__18051 \x3d cljs.core.first(seq18049__$1);\nvar seq18049__$2 \x3d cljs.core.next(seq18049__$1);\nvar G__18052 \x3d cljs.core.first(seq18049__$2);\nvar seq18049__$3 \x3d cljs.core.next(seq18049__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18050,G__18051,G__18052,seq18049__$3);\n}));\n\n(cljs.core.some_fn.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * Returns a lazy sequence consisting of the result of applying f to\n *   the set of first items of each coll, followed by applying f to the\n *   set of second items in each coll, until any one of the colls is\n *   exhausted.  Any remaining items in other colls are ignored. Function\n *   f should accept number-of-colls arguments. Returns a transducer when\n *   no collection is provided.\n */\ncljs.core.map \x3d (function cljs$core$map(var_args){\nvar G__18061 \x3d arguments.length;\nswitch (G__18061) {\ncase 1:\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24165 \x3d arguments.length;\nvar i__5727__auto___24166 \x3d (0);\nwhile(true){\nif((i__5727__auto___24166 \x3c len__5726__auto___24165)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24166]));\n\nvar G__24167 \x3d (i__5727__auto___24166 + (1));\ni__5727__auto___24166 \x3d G__24167;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((4) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((4)),(0),null)):null);\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.map.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn (function (rf){\nreturn (function() {\nvar G__24168 \x3d null;\nvar G__24168__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__24168__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__24168__2 \x3d (function (result,input){\nvar G__18062 \x3d result;\nvar G__18063 \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(input) : f.call(null, input));\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__18062,G__18063) : rf.call(null, G__18062,G__18063));\n});\nvar G__24168__3 \x3d (function() { \nvar G__24169__delegate \x3d function (result,input,inputs){\nvar G__18064 \x3d result;\nvar G__18065 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,input,inputs);\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__18064,G__18065) : rf.call(null, G__18064,G__18065));\n};\nvar G__24169 \x3d function (result,input,var_args){\nvar inputs \x3d null;\nif (arguments.length \x3e 2) {\nvar G__24170__i \x3d 0, G__24170__a \x3d new Array(arguments.length -  2);\nwhile (G__24170__i \x3c G__24170__a.length) {G__24170__a[G__24170__i] \x3d arguments[G__24170__i + 2]; ++G__24170__i;}\n  inputs \x3d new cljs.core.IndexedSeq(G__24170__a,0,null);\n} \nreturn G__24169__delegate.call(this,result,input,inputs);};\nG__24169.cljs$lang$maxFixedArity \x3d 2;\nG__24169.cljs$lang$applyTo \x3d (function (arglist__24171){\nvar result \x3d cljs.core.first(arglist__24171);\narglist__24171 \x3d cljs.core.next(arglist__24171);\nvar input \x3d cljs.core.first(arglist__24171);\nvar inputs \x3d cljs.core.rest(arglist__24171);\nreturn G__24169__delegate(result,input,inputs);\n});\nG__24169.cljs$core$IFn$_invoke$arity$variadic \x3d G__24169__delegate;\nreturn G__24169;\n})()\n;\nG__24168 \x3d function(result,input,var_args){\nvar inputs \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__24168__0.call(this);\ncase 1:\nreturn G__24168__1.call(this,result);\ncase 2:\nreturn G__24168__2.call(this,result,input);\ndefault:\nvar G__24172 \x3d null;\nif (arguments.length \x3e 2) {\nvar G__24173__i \x3d 0, G__24173__a \x3d new Array(arguments.length -  2);\nwhile (G__24173__i \x3c G__24173__a.length) {G__24173__a[G__24173__i] \x3d arguments[G__24173__i + 2]; ++G__24173__i;}\nG__24172 \x3d new cljs.core.IndexedSeq(G__24173__a,0,null);\n}\nreturn G__24168__3.cljs$core$IFn$_invoke$arity$variadic(result,input, G__24172);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24168.cljs$lang$maxFixedArity \x3d 2;\nG__24168.cljs$lang$applyTo \x3d G__24168__3.cljs$lang$applyTo;\nG__24168.cljs$core$IFn$_invoke$arity$0 \x3d G__24168__0;\nG__24168.cljs$core$IFn$_invoke$arity$1 \x3d G__24168__1;\nG__24168.cljs$core$IFn$_invoke$arity$2 \x3d G__24168__2;\nG__24168.cljs$core$IFn$_invoke$arity$variadic \x3d G__24168__3.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__24168;\n})()\n});\n}));\n\n(cljs.core.map.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s)){\nvar c \x3d cljs.core.chunk_first(s);\nvar size \x3d cljs.core.count(c);\nvar b \x3d cljs.core.chunk_buffer(size);\nvar n__5593__auto___24174 \x3d size;\nvar i_24175 \x3d (0);\nwhile(true){\nif((i_24175 \x3c n__5593__auto___24174)){\ncljs.core.chunk_append(b,(function (){var G__18066 \x3d cljs.core._nth(c,i_24175);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__18066) : f.call(null, G__18066));\n})());\n\nvar G__24176 \x3d (i_24175 + (1));\ni_24175 \x3d G__24176;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core.chunk_cons(cljs.core.chunk(b),cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,cljs.core.chunk_rest(s)));\n} else {\nreturn cljs.core.cons((function (){var G__18067 \x3d cljs.core.first(s);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__18067) : f.call(null, G__18067));\n})(),cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,cljs.core.rest(s)));\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.map.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,c1,c2){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s1 \x3d cljs.core.seq(c1);\nvar s2 \x3d cljs.core.seq(c2);\nif(((s1) \x26\x26 (s2))){\nreturn cljs.core.cons((function (){var G__18068 \x3d cljs.core.first(s1);\nvar G__18069 \x3d cljs.core.first(s2);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18068,G__18069) : f.call(null, G__18068,G__18069));\n})(),cljs.core.map.cljs$core$IFn$_invoke$arity$3(f,cljs.core.rest(s1),cljs.core.rest(s2)));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.map.cljs$core$IFn$_invoke$arity$4 \x3d (function (f,c1,c2,c3){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s1 \x3d cljs.core.seq(c1);\nvar s2 \x3d cljs.core.seq(c2);\nvar s3 \x3d cljs.core.seq(c3);\nif(((s1) \x26\x26 (((s2) \x26\x26 (s3))))){\nreturn cljs.core.cons((function (){var G__18070 \x3d cljs.core.first(s1);\nvar G__18071 \x3d cljs.core.first(s2);\nvar G__18072 \x3d cljs.core.first(s3);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18070,G__18071,G__18072) : f.call(null, G__18070,G__18071,G__18072));\n})(),cljs.core.map.cljs$core$IFn$_invoke$arity$4(f,cljs.core.rest(s1),cljs.core.rest(s2),cljs.core.rest(s3)));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.map.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,c1,c2,c3,colls){\nvar step \x3d (function cljs$core$step(cs){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar ss \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.seq,cs);\nif(cljs.core.every_QMARK_(cljs.core.identity,ss)){\nreturn 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)));\n} else {\nreturn null;\n}\n}),null,null));\n});\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__18054_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,p1__18054_SHARP_);\n}),step(cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(colls,c3,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([c2,c1], 0))));\n}));\n\n/** @this {Function} */\n(cljs.core.map.cljs$lang$applyTo \x3d (function (seq18056){\nvar G__18057 \x3d cljs.core.first(seq18056);\nvar seq18056__$1 \x3d cljs.core.next(seq18056);\nvar G__18058 \x3d cljs.core.first(seq18056__$1);\nvar seq18056__$2 \x3d cljs.core.next(seq18056__$1);\nvar G__18059 \x3d cljs.core.first(seq18056__$2);\nvar seq18056__$3 \x3d cljs.core.next(seq18056__$2);\nvar G__18060 \x3d cljs.core.first(seq18056__$3);\nvar seq18056__$4 \x3d cljs.core.next(seq18056__$3);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18057,G__18058,G__18059,G__18060,seq18056__$4);\n}));\n\n(cljs.core.map.cljs$lang$maxFixedArity \x3d (4));\n\n/**\n * Returns a lazy sequence of the first n items in coll, or all items if\n *   there are fewer than n.  Returns a stateful transducer when\n *   no collection is provided.\n */\ncljs.core.take \x3d (function cljs$core$take(var_args){\nvar G__18074 \x3d arguments.length;\nswitch (G__18074) {\ncase 1:\nreturn cljs.core.take.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.take.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.take.cljs$core$IFn$_invoke$arity$1 \x3d (function (n){\nif(typeof n \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? n)\x22));\n}\n\nreturn (function (rf){\nvar na \x3d cljs.core.volatile_BANG_(n);\nreturn (function() {\nvar G__24199 \x3d null;\nvar G__24199__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__24199__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__24199__2 \x3d (function (result,input){\nvar n__$1 \x3d cljs.core.deref(na);\nvar nn \x3d na.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (na.cljs$core$IDeref$_deref$arity$1(null, ) - (1)));\nvar result__$1 \x3d (((n__$1 \x3e (0)))?(rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input)):result);\nif((!((nn \x3e (0))))){\nreturn cljs.core.ensure_reduced(result__$1);\n} else {\nreturn result__$1;\n}\n});\nG__24199 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__24199__0.call(this);\ncase 1:\nreturn G__24199__1.call(this,result);\ncase 2:\nreturn G__24199__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24199.cljs$core$IFn$_invoke$arity$0 \x3d G__24199__0;\nG__24199.cljs$core$IFn$_invoke$arity$1 \x3d G__24199__1;\nG__24199.cljs$core$IFn$_invoke$arity$2 \x3d G__24199__2;\nreturn G__24199;\n})()\n});\n}));\n\n(cljs.core.take.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nif(typeof n \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? n)\x22));\n}\n\nreturn (new cljs.core.LazySeq(null,(function (){\nif((n \x3e (0))){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nreturn cljs.core.cons(cljs.core.first(s),cljs.core.take.cljs$core$IFn$_invoke$arity$2((n - (1)),cljs.core.rest(s)));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.take.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a laziness-preserving sequence of all but the first n items in coll.\n *   Returns a stateful transducer when no collection is provided.\n */\ncljs.core.drop \x3d (function cljs$core$drop(var_args){\nvar G__18076 \x3d arguments.length;\nswitch (G__18076) {\ncase 1:\nreturn cljs.core.drop.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.drop.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.drop.cljs$core$IFn$_invoke$arity$1 \x3d (function (n){\nif(typeof n \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? n)\x22));\n}\n\nreturn (function (rf){\nvar na \x3d cljs.core.volatile_BANG_(n);\nreturn (function() {\nvar G__24220 \x3d null;\nvar G__24220__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__24220__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__24220__2 \x3d (function (result,input){\nvar n__$1 \x3d cljs.core.deref(na);\nna.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (na.cljs$core$IDeref$_deref$arity$1(null, ) - (1)));\n\nif((n__$1 \x3e (0))){\nreturn result;\n} else {\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n}\n});\nG__24220 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__24220__0.call(this);\ncase 1:\nreturn G__24220__1.call(this,result);\ncase 2:\nreturn G__24220__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24220.cljs$core$IFn$_invoke$arity$0 \x3d G__24220__0;\nG__24220.cljs$core$IFn$_invoke$arity$1 \x3d G__24220__1;\nG__24220.cljs$core$IFn$_invoke$arity$2 \x3d G__24220__2;\nreturn G__24220;\n})()\n});\n}));\n\n(cljs.core.drop.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nif(typeof n \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? n)\x22));\n}\n\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition1$ \x26 (262144))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IDrop$))))?true:false):false)){\nvar or__5002__auto__ \x3d (((n \x3e (0)))?coll.cljs$core$IDrop$_drop$arity$2(null, Math.ceil(n)):cljs.core.seq(coll));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n} else {\nvar step \x3d (function (n__$1,coll__$1){\nwhile(true){\nvar s \x3d cljs.core.seq(coll__$1);\nif((((n__$1 \x3e (0))) \x26\x26 (s))){\nvar G__24227 \x3d (n__$1 - (1));\nvar G__24228 \x3d cljs.core.rest(s);\nn__$1 \x3d G__24227;\ncoll__$1 \x3d G__24228;\ncontinue;\n} else {\nreturn s;\n}\nbreak;\n}\n});\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn step(n,coll);\n}),null,null));\n}\n}));\n\n(cljs.core.drop.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Return a lazy sequence of all but the last n (default 1) items in coll\n */\ncljs.core.drop_last \x3d (function cljs$core$drop_last(var_args){\nvar G__18079 \x3d arguments.length;\nswitch (G__18079) {\ncase 1:\nreturn cljs.core.drop_last.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.drop_last.cljs$core$IFn$_invoke$arity$1 \x3d (function (s){\nreturn cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2((1),s);\n}));\n\n(cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,s){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (x,_){\nreturn x;\n}),s,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,s));\n}));\n\n(cljs.core.drop_last.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a seq of the last n items in coll.  Depending on the type\n *   of coll may be no better than linear time.  For vectors, see also subvec.\n */\ncljs.core.take_last \x3d (function cljs$core$take_last(n,coll){\nvar s \x3d cljs.core.seq(coll);\nvar lead \x3d cljs.core.seq(cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,coll));\nwhile(true){\nif(lead){\nvar G__24247 \x3d cljs.core.next(s);\nvar G__24248 \x3d cljs.core.next(lead);\ns \x3d G__24247;\nlead \x3d G__24248;\ncontinue;\n} else {\nreturn s;\n}\nbreak;\n}\n});\n/**\n * Returns a lazy sequence of the items in coll starting from the\n *   first item for which (pred item) returns logical false.  Returns a\n *   stateful transducer when no collection is provided.\n */\ncljs.core.drop_while \x3d (function cljs$core$drop_while(var_args){\nvar G__18081 \x3d arguments.length;\nswitch (G__18081) {\ncase 1:\nreturn cljs.core.drop_while.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.drop_while.cljs$core$IFn$_invoke$arity$1 \x3d (function (pred){\nreturn (function (rf){\nvar da \x3d cljs.core.volatile_BANG_(true);\nreturn (function() {\nvar G__24257 \x3d null;\nvar G__24257__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__24257__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__24257__2 \x3d (function (result,input){\nvar drop_QMARK_ \x3d cljs.core.deref(da);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d drop_QMARK_;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null, input));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn result;\n} else {\ncljs.core.vreset_BANG_(da,null);\n\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n}\n});\nG__24257 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__24257__0.call(this);\ncase 1:\nreturn G__24257__1.call(this,result);\ncase 2:\nreturn G__24257__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24257.cljs$core$IFn$_invoke$arity$0 \x3d G__24257__0;\nG__24257.cljs$core$IFn$_invoke$arity$1 \x3d G__24257__1;\nG__24257.cljs$core$IFn$_invoke$arity$2 \x3d G__24257__2;\nreturn G__24257;\n})()\n});\n}));\n\n(cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2 \x3d (function (pred,coll){\nvar step \x3d (function (pred__$1,coll__$1){\nwhile(true){\nvar s \x3d cljs.core.seq(coll__$1);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d s;\nif(and__5000__auto__){\nvar G__18082 \x3d cljs.core.first(s);\nreturn (pred__$1.cljs$core$IFn$_invoke$arity$1 ? pred__$1.cljs$core$IFn$_invoke$arity$1(G__18082) : pred__$1.call(null, G__18082));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nvar G__24303 \x3d pred__$1;\nvar G__24304 \x3d cljs.core.rest(s);\npred__$1 \x3d G__24303;\ncoll__$1 \x3d G__24304;\ncontinue;\n} else {\nreturn s;\n}\nbreak;\n}\n});\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn step(pred,coll);\n}),null,null));\n}));\n\n(cljs.core.drop_while.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n* @constructor\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IPending}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.Cycle \x3d (function (meta,all,prev,current,_next){\nthis.meta \x3d meta;\nthis.all \x3d all;\nthis.prev \x3d prev;\nthis.current \x3d current;\nthis._next \x3d _next;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 26083532;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 1;\n});\n(cljs.core.Cycle.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.Cycle.prototype.currentval \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nif(self__.current){\n} else {\nvar temp__5802__auto___24327 \x3d cljs.core.next(self__.prev);\nif(temp__5802__auto___24327){\nvar c_24329 \x3d temp__5802__auto___24327;\n(self__.current \x3d c_24329);\n} else {\n(self__.current \x3d self__.all);\n}\n}\n\nreturn self__.current;\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ISeq$_rest$arity$1(null, );\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (!((self__.current \x3d\x3d null)));\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar s \x3d coll__$1.currentval();\nvar ret \x3d cljs.core.first(s);\nwhile(true){\nvar s__$1 \x3d (function (){var or__5002__auto__ \x3d cljs.core.next(s);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn self__.all;\n}\n})();\nvar ret__$1 \x3d (function (){var G__18085 \x3d ret;\nvar G__18086 \x3d cljs.core.first(s__$1);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18085,G__18086) : f.call(null, G__18085,G__18086));\n})();\nif(cljs.core.reduced_QMARK_(ret__$1)){\nreturn cljs.core.deref(ret__$1);\n} else {\nvar G__24362 \x3d s__$1;\nvar G__24363 \x3d ret__$1;\ns \x3d G__24362;\nret \x3d G__24363;\ncontinue;\n}\nbreak;\n}\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar s \x3d coll__$1.currentval();\nvar ret \x3d start;\nwhile(true){\nvar ret__$1 \x3d (function (){var G__18087 \x3d ret;\nvar G__18088 \x3d cljs.core.first(s);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18087,G__18088) : f.call(null, G__18087,G__18088));\n})();\nif(cljs.core.reduced_QMARK_(ret__$1)){\nreturn cljs.core.deref(ret__$1);\n} else {\nvar G__24407 \x3d (function (){var or__5002__auto__ \x3d cljs.core.next(s);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn self__.all;\n}\n})();\nvar G__24408 \x3d ret__$1;\ns \x3d G__24407;\nret \x3d G__24408;\ncontinue;\n}\nbreak;\n}\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.first(coll__$1.currentval());\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__._next \x3d\x3d null)){\n(self__._next \x3d (new cljs.core.Cycle(null,self__.all,coll__$1.currentval(),null,null)));\n} else {\n}\n\nreturn self__._next;\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.Cycle(new_meta,self__.all,self__.prev,self__.current,self__._next));\n}\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.Cycle.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22all\x22,\x22all\x22,-1762306027,null),new cljs.core.Symbol(null,\x22prev\x22,\x22prev\x22,43462301,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22current\x22,\x22current\x22,552492924,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22_next\x22,\x22_next\x22,101877036,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Cycle.cljs$lang$type \x3d true);\n\n(cljs.core.Cycle.cljs$lang$ctorStr \x3d \x22cljs.core/Cycle\x22);\n\n(cljs.core.Cycle.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Cycle\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Cycle.\n */\ncljs.core.__GT_Cycle \x3d (function cljs$core$__GT_Cycle(meta,all,prev,current,_next){\nreturn (new cljs.core.Cycle(meta,all,prev,current,_next));\n});\n\n/**\n * Returns a lazy (infinite!) sequence of repetitions of the items in coll.\n */\ncljs.core.cycle \x3d (function cljs$core$cycle(coll){\nvar temp__5802__auto__ \x3d cljs.core.seq(coll);\nif(temp__5802__auto__){\nvar vals \x3d temp__5802__auto__;\nreturn (new cljs.core.Cycle(null,vals,null,vals,null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n});\n/**\n * Returns a vector of [(take n coll) (drop n coll)]\n */\ncljs.core.split_at \x3d (function cljs$core$split_at(n,coll){\nreturn 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);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IDrop}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IPending}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.Repeat \x3d (function (meta,count,val,next,__hash){\nthis.meta \x3d meta;\nthis.count \x3d count;\nthis.val \x3d val;\nthis.next \x3d next;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374988;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 262145;\n});\n(cljs.core.Repeat.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.Repeat.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.Repeat.prototype.indexOf \x3d (function() {\nvar G__24458 \x3d null;\nvar G__24458__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__24458__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24458 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24458__1.call(this,x);\ncase 2:\nreturn G__24458__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24458.cljs$core$IFn$_invoke$arity$1 \x3d G__24458__1;\nG__24458.cljs$core$IFn$_invoke$arity$2 \x3d G__24458__2;\nreturn G__24458;\n})()\n);\n\n(cljs.core.Repeat.prototype.lastIndexOf \x3d (function() {\nvar G__24465 \x3d null;\nvar G__24465__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,self__.count);\n});\nvar G__24465__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24465 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24465__1.call(this,x);\ncase 2:\nreturn G__24465__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24465.cljs$core$IFn$_invoke$arity$1 \x3d G__24465__1;\nG__24465.cljs$core$IFn$_invoke$arity$2 \x3d G__24465__2;\nreturn G__24465;\n})()\n);\n\n(cljs.core.Repeat.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.next \x3d\x3d null)){\nif((self__.count \x3e (1))){\n(self__.next \x3d (new cljs.core.Repeat(null,(self__.count - (1)),self__.val,null,null)));\n\nreturn self__.next;\n} else {\nif(((-1) \x3d\x3d\x3d self__.count)){\nreturn coll__$1;\n} else {\nreturn null;\n}\n}\n} else {\nreturn self__.next;\n}\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn false;\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.count \x3d\x3d\x3d (-1))){\nvar ret \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(self__.val,self__.val) : f.call(null, self__.val,self__.val));\nwhile(true){\nif(cljs.core.reduced_QMARK_(ret)){\nreturn cljs.core.deref(ret);\n} else {\nvar G__24503 \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null, ret,self__.val));\nret \x3d G__24503;\ncontinue;\n}\nbreak;\n}\n} else {\nvar i \x3d (1);\nvar ret \x3d self__.val;\nwhile(true){\nif((i \x3c self__.count)){\nvar ret__$1 \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null, ret,self__.val));\nif(cljs.core.reduced_QMARK_(ret__$1)){\nreturn cljs.core.deref(ret__$1);\n} else {\nvar G__24508 \x3d (i + (1));\nvar G__24509 \x3d ret__$1;\ni \x3d G__24508;\nret \x3d G__24509;\ncontinue;\n}\n} else {\nreturn ret;\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.count \x3d\x3d\x3d (-1))){\nvar ret \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(start,self__.val) : f.call(null, start,self__.val));\nwhile(true){\nif(cljs.core.reduced_QMARK_(ret)){\nreturn cljs.core.deref(ret);\n} else {\nvar G__24511 \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null, ret,self__.val));\nret \x3d G__24511;\ncontinue;\n}\nbreak;\n}\n} else {\nvar i \x3d (0);\nvar ret \x3d start;\nwhile(true){\nif((i \x3c self__.count)){\nvar ret__$1 \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null, ret,self__.val));\nif(cljs.core.reduced_QMARK_(ret__$1)){\nreturn cljs.core.deref(ret__$1);\n} else {\nvar G__24512 \x3d (i + (1));\nvar G__24513 \x3d ret__$1;\ni \x3d G__24512;\nret \x3d G__24513;\ncontinue;\n}\n} else {\nreturn ret;\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.next \x3d\x3d null)){\nif((self__.count \x3e (1))){\n(self__.next \x3d (new cljs.core.Repeat(null,(self__.count - (1)),self__.val,null,null)));\n\nreturn self__.next;\n} else {\nif(((-1) \x3d\x3d\x3d self__.count)){\nreturn coll__$1;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}\n} else {\nreturn self__.next;\n}\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.Repeat(new_meta,self__.count,self__.val,self__.next,null));\n}\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IDrop$_drop$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.count \x3d\x3d\x3d (-1))){\nreturn coll__$1;\n} else {\nvar dropped_count \x3d (self__.count - n);\nif((dropped_count \x3e (0))){\nreturn (new cljs.core.Repeat(null,dropped_count,self__.val,null,null));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.core.Repeat.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22count\x22,\x22count\x22,-514511684,null),new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22next\x22,\x22next\x22,1522830042,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Repeat.cljs$lang$type \x3d true);\n\n(cljs.core.Repeat.cljs$lang$ctorStr \x3d \x22cljs.core/Repeat\x22);\n\n(cljs.core.Repeat.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Repeat\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Repeat.\n */\ncljs.core.__GT_Repeat \x3d (function cljs$core$__GT_Repeat(meta,count,val,next,__hash){\nreturn (new cljs.core.Repeat(meta,count,val,next,__hash));\n});\n\n/**\n * Returns a lazy (infinite!, or length n if supplied) sequence of xs.\n */\ncljs.core.repeat \x3d (function cljs$core$repeat(var_args){\nvar G__18090 \x3d arguments.length;\nswitch (G__18090) {\ncase 1:\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.repeat.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn (new cljs.core.Repeat(null,(-1),x,null,null));\n}));\n\n(cljs.core.repeat.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,x){\nif((n \x3e (0))){\nreturn (new cljs.core.Repeat(null,n,x,null,null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.repeat.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * DEPRECATED: Use \x27repeat\x27 instead.\n *   Returns a lazy seq of n xs.\n */\ncljs.core.replicate \x3d (function cljs$core$replicate(n,x){\nreturn cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(x));\n});\n/**\n * Takes a function of no args, presumably with side effects, and\n *   returns an infinite (or length n if supplied) lazy sequence of calls\n *   to it\n */\ncljs.core.repeatedly \x3d (function cljs$core$repeatedly(var_args){\nvar G__18092 \x3d arguments.length;\nswitch (G__18092) {\ncase 1:\nreturn cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn 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));\n}),null,null));\n}));\n\n(cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,f){\nreturn cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1(f));\n}));\n\n(cljs.core.repeatedly.cljs$lang$maxFixedArity \x3d 2);\n\ncljs.core.UNREALIZED_SEED \x3d ({});\n\n/**\n* @constructor\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IPending}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.Iterate \x3d (function (meta,f,prev_seed,seed,next){\nthis.meta \x3d meta;\nthis.f \x3d f;\nthis.prev_seed \x3d prev_seed;\nthis.seed \x3d seed;\nthis.next \x3d next;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 26083532;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 1;\n});\n(cljs.core.Iterate.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ISeq$_rest$arity$1(null, );\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (!((self__.seed \x3d\x3d\x3d cljs.core.UNREALIZED_SEED)));\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,rf){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar first \x3d coll__$1.cljs$core$ISeq$_first$arity$1(null, );\nvar v \x3d (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(first) : self__.f.call(null, first));\nvar ret \x3d (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(first,v) : rf.call(null, first,v));\nvar v__$1 \x3d v;\nwhile(true){\nif(cljs.core.reduced_QMARK_(ret)){\nreturn cljs.core.deref(ret);\n} else {\nvar v__$2 \x3d (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(v__$1) : self__.f.call(null, v__$1));\nvar G__24544 \x3d (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(ret,v__$2) : rf.call(null, ret,v__$2));\nvar G__24545 \x3d v__$2;\nret \x3d G__24544;\nv__$1 \x3d G__24545;\ncontinue;\n}\nbreak;\n}\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,rf,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar v \x3d coll__$1.cljs$core$ISeq$_first$arity$1(null, );\nvar ret \x3d (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(start,v) : rf.call(null, start,v));\nvar v__$1 \x3d v;\nwhile(true){\nif(cljs.core.reduced_QMARK_(ret)){\nreturn cljs.core.deref(ret);\n} else {\nvar v__$2 \x3d (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(v__$1) : self__.f.call(null, v__$1));\nvar G__24547 \x3d (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(ret,v__$2) : rf.call(null, ret,v__$2));\nvar G__24548 \x3d v__$2;\nret \x3d G__24547;\nv__$1 \x3d G__24548;\ncontinue;\n}\nbreak;\n}\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((cljs.core.UNREALIZED_SEED \x3d\x3d\x3d self__.seed)){\n(self__.seed \x3d (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(self__.prev_seed) : self__.f.call(null, self__.prev_seed)));\n} else {\n}\n\nreturn self__.seed;\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.next \x3d\x3d null)){\n(self__.next \x3d (new cljs.core.Iterate(null,self__.f,coll__$1.cljs$core$ISeq$_first$arity$1(null, ),cljs.core.UNREALIZED_SEED,null)));\n} else {\n}\n\nreturn self__.next;\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.Iterate(new_meta,self__.f,self__.prev_seed,self__.seed,self__.next));\n}\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.Iterate.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),new cljs.core.Symbol(null,\x22prev-seed\x22,\x22prev-seed\x22,2126381367,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22seed\x22,\x22seed\x22,1709144854,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22next\x22,\x22next\x22,1522830042,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Iterate.cljs$lang$type \x3d true);\n\n(cljs.core.Iterate.cljs$lang$ctorStr \x3d \x22cljs.core/Iterate\x22);\n\n(cljs.core.Iterate.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Iterate\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Iterate.\n */\ncljs.core.__GT_Iterate \x3d (function cljs$core$__GT_Iterate(meta,f,prev_seed,seed,next){\nreturn (new cljs.core.Iterate(meta,f,prev_seed,seed,next));\n});\n\n/**\n * Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects\n */\ncljs.core.iterate \x3d (function cljs$core$iterate(f,x){\nreturn (new cljs.core.Iterate(null,f,null,x,null));\n});\n/**\n * Returns a lazy seq of the first item in each coll, then the second etc.\n */\ncljs.core.interleave \x3d (function cljs$core$interleave(var_args){\nvar G__18097 \x3d arguments.length;\nswitch (G__18097) {\ncase 0:\nreturn cljs.core.interleave.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.interleave.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.interleave.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24559 \x3d arguments.length;\nvar i__5727__auto___24560 \x3d (0);\nwhile(true){\nif((i__5727__auto___24560 \x3c len__5726__auto___24559)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24560]));\n\nvar G__24562 \x3d (i__5727__auto___24560 + (1));\ni__5727__auto___24560 \x3d G__24562;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.interleave.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.interleave.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.interleave.cljs$core$IFn$_invoke$arity$1 \x3d (function (c1){\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn c1;\n}),null,null));\n}));\n\n(cljs.core.interleave.cljs$core$IFn$_invoke$arity$2 \x3d (function (c1,c2){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s1 \x3d cljs.core.seq(c1);\nvar s2 \x3d cljs.core.seq(c2);\nif(((s1) \x26\x26 (s2))){\nreturn 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))));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.interleave.cljs$core$IFn$_invoke$arity$variadic \x3d (function (c1,c2,colls){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar ss \x3d 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.prim_seq.cljs$core$IFn$_invoke$arity$2([c1], 0)));\nif(cljs.core.every_QMARK_(cljs.core.identity,ss)){\nreturn 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)));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n/** @this {Function} */\n(cljs.core.interleave.cljs$lang$applyTo \x3d (function (seq18094){\nvar G__18095 \x3d cljs.core.first(seq18094);\nvar seq18094__$1 \x3d cljs.core.next(seq18094);\nvar G__18096 \x3d cljs.core.first(seq18094__$1);\nvar seq18094__$2 \x3d cljs.core.next(seq18094__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18095,G__18096,seq18094__$2);\n}));\n\n(cljs.core.interleave.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns a lazy seq of the elements of coll separated by sep.\n *   Returns a stateful transducer when no collection is provided.\n */\ncljs.core.interpose \x3d (function cljs$core$interpose(var_args){\nvar G__18099 \x3d arguments.length;\nswitch (G__18099) {\ncase 1:\nreturn cljs.core.interpose.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.interpose.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.interpose.cljs$core$IFn$_invoke$arity$1 \x3d (function (sep){\nreturn (function (rf){\nvar started \x3d cljs.core.volatile_BANG_(false);\nreturn (function() {\nvar G__24574 \x3d null;\nvar G__24574__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__24574__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__24574__2 \x3d (function (result,input){\nif(cljs.core.truth_(cljs.core.deref(started))){\nvar sepr \x3d (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,sep) : rf.call(null, result,sep));\nif(cljs.core.reduced_QMARK_(sepr)){\nreturn sepr;\n} else {\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(sepr,input) : rf.call(null, sepr,input));\n}\n} else {\ncljs.core.vreset_BANG_(started,true);\n\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n}\n});\nG__24574 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__24574__0.call(this);\ncase 1:\nreturn G__24574__1.call(this,result);\ncase 2:\nreturn G__24574__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24574.cljs$core$IFn$_invoke$arity$0 \x3d G__24574__0;\nG__24574.cljs$core$IFn$_invoke$arity$1 \x3d G__24574__1;\nG__24574.cljs$core$IFn$_invoke$arity$2 \x3d G__24574__2;\nreturn G__24574;\n})()\n});\n}));\n\n(cljs.core.interpose.cljs$core$IFn$_invoke$arity$2 \x3d (function (sep,coll){\nreturn 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));\n}));\n\n(cljs.core.interpose.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Take a collection of collections, and return a lazy seq\n *   of items from the inner collection\n */\ncljs.core.flatten1 \x3d (function cljs$core$flatten1(colls){\nvar cat \x3d (function cljs$core$flatten1_$_cat(coll,colls__$1){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5802__auto__ \x3d cljs.core.seq(coll);\nif(temp__5802__auto__){\nvar coll__$1 \x3d temp__5802__auto__;\nreturn cljs.core.cons(cljs.core.first(coll__$1),cljs$core$flatten1_$_cat(cljs.core.rest(coll__$1),colls__$1));\n} else {\nif(cljs.core.seq(colls__$1)){\nreturn cljs$core$flatten1_$_cat(cljs.core.first(colls__$1),cljs.core.rest(colls__$1));\n} else {\nreturn null;\n}\n}\n}),null,null));\n});\nreturn cat(null,colls);\n});\n/**\n * Returns the result of applying concat to the result of applying map\n *   to f and colls.  Thus function f should return a collection. Returns\n *   a transducer when no collections are provided\n */\ncljs.core.mapcat \x3d (function cljs$core$mapcat(var_args){\nvar G__18103 \x3d arguments.length;\nswitch (G__18103) {\ncase 1:\nreturn cljs.core.mapcat.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24580 \x3d arguments.length;\nvar i__5727__auto___24582 \x3d (0);\nwhile(true){\nif((i__5727__auto___24582 \x3c len__5726__auto___24580)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24582]));\n\nvar G__24583 \x3d (i__5727__auto___24582 + (1));\ni__5727__auto___24582 \x3d G__24583;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((1) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.mapcat.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn cljs.core.comp.cljs$core$IFn$_invoke$arity$2(cljs.core.map.cljs$core$IFn$_invoke$arity$1(f),cljs.core.cat);\n}));\n\n(cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,colls){\nreturn 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));\n}));\n\n/** @this {Function} */\n(cljs.core.mapcat.cljs$lang$applyTo \x3d (function (seq18101){\nvar G__18102 \x3d cljs.core.first(seq18101);\nvar seq18101__$1 \x3d cljs.core.next(seq18101);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18102,seq18101__$1);\n}));\n\n(cljs.core.mapcat.cljs$lang$maxFixedArity \x3d (1));\n\n/**\n * Returns a lazy sequence of the items in coll for which\n *   (pred item) returns logical true. pred must be free of side-effects.\n *   Returns a transducer when no collection is provided.\n */\ncljs.core.filter \x3d (function cljs$core$filter(var_args){\nvar G__18105 \x3d arguments.length;\nswitch (G__18105) {\ncase 1:\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.filter.cljs$core$IFn$_invoke$arity$1 \x3d (function (pred){\nreturn (function (rf){\nreturn (function() {\nvar G__24590 \x3d null;\nvar G__24590__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__24590__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__24590__2 \x3d (function (result,input){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null, input)))){\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n} else {\nreturn result;\n}\n});\nG__24590 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__24590__0.call(this);\ncase 1:\nreturn G__24590__1.call(this,result);\ncase 2:\nreturn G__24590__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24590.cljs$core$IFn$_invoke$arity$0 \x3d G__24590__0;\nG__24590.cljs$core$IFn$_invoke$arity$1 \x3d G__24590__1;\nG__24590.cljs$core$IFn$_invoke$arity$2 \x3d G__24590__2;\nreturn G__24590;\n})()\n});\n}));\n\n(cljs.core.filter.cljs$core$IFn$_invoke$arity$2 \x3d (function (pred,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s)){\nvar c \x3d cljs.core.chunk_first(s);\nvar size \x3d cljs.core.count(c);\nvar b \x3d cljs.core.chunk_buffer(size);\nvar n__5593__auto___24593 \x3d size;\nvar i_24595 \x3d (0);\nwhile(true){\nif((i_24595 \x3c n__5593__auto___24593)){\nif(cljs.core.truth_((function (){var G__18106 \x3d cljs.core._nth(c,i_24595);\nreturn (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__18106) : pred.call(null, G__18106));\n})())){\ncljs.core.chunk_append(b,cljs.core._nth(c,i_24595));\n} else {\n}\n\nvar G__24596 \x3d (i_24595 + (1));\ni_24595 \x3d G__24596;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core.chunk_cons(cljs.core.chunk(b),cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred,cljs.core.chunk_rest(s)));\n} else {\nvar f \x3d cljs.core.first(s);\nvar r \x3d cljs.core.rest(s);\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(f) : pred.call(null, f)))){\nreturn cljs.core.cons(f,cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred,r));\n} else {\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred,r);\n}\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.filter.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a lazy sequence of the items in coll for which\n *   (pred item) returns logical false. pred must be free of side-effects.\n *   Returns a transducer when no collection is provided.\n */\ncljs.core.remove \x3d (function cljs$core$remove(var_args){\nvar G__18108 \x3d arguments.length;\nswitch (G__18108) {\ncase 1:\nreturn cljs.core.remove.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.remove.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.remove.cljs$core$IFn$_invoke$arity$1 \x3d (function (pred){\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$1(cljs.core.complement(pred));\n}));\n\n(cljs.core.remove.cljs$core$IFn$_invoke$arity$2 \x3d (function (pred,coll){\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$2(cljs.core.complement(pred),coll);\n}));\n\n(cljs.core.remove.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n *   branch? must be a fn of one arg that returns true if passed a node\n *   that can have children (but may not).  children must be a fn of one\n *   arg that returns a sequence of the children. Will only be called on\n *   nodes for which branch? returns true. Root is the root node of the\n *   tree.\n */\ncljs.core.tree_seq \x3d (function cljs$core$tree_seq(branch_QMARK_,children,root){\nvar walk \x3d (function cljs$core$tree_seq_$_walk(node){\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn 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.prim_seq.cljs$core$IFn$_invoke$arity$2([(children.cljs$core$IFn$_invoke$arity$1 ? children.cljs$core$IFn$_invoke$arity$1(node) : children.call(null, node))], 0)):null));\n}),null,null));\n});\nreturn walk(root);\n});\n/**\n * Takes any nested combination of sequential things (lists, vectors,\n *   etc.) and returns their contents as a single, flat sequence.\n *   (flatten nil) returns nil.\n */\ncljs.core.flatten \x3d (function cljs$core$flatten(x){\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__18109_SHARP_){\nreturn (!(cljs.core.sequential_QMARK_(p1__18109_SHARP_)));\n}),cljs.core.rest(cljs.core.tree_seq(cljs.core.sequential_QMARK_,cljs.core.seq,x)));\n});\n/**\n * Returns a new coll consisting of to-coll with all of the items of\n *   from-coll conjoined. A transducer may be supplied.\n */\ncljs.core.into \x3d (function cljs$core$into(var_args){\nvar G__18111 \x3d arguments.length;\nswitch (G__18111) {\ncase 0:\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.into.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cljs.core.into.cljs$core$IFn$_invoke$arity$1 \x3d (function (to){\nreturn to;\n}));\n\n(cljs.core.into.cljs$core$IFn$_invoke$arity$2 \x3d (function (to,from){\nif((!((to \x3d\x3d null)))){\nif((((!((to \x3d\x3d null))))?(((((to.cljs$lang$protocol_mask$partition1$ \x26 (4))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d to.cljs$core$IEditableCollection$))))?true:false):false)){\nreturn 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));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,to,from);\n}\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,to,from);\n}\n}));\n\n(cljs.core.into.cljs$core$IFn$_invoke$arity$3 \x3d (function (to,xform,from){\nif((((!((to \x3d\x3d null))))?(((((to.cljs$lang$protocol_mask$partition1$ \x26 (4))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d to.cljs$core$IEditableCollection$))))?true:false):false)){\nvar tm \x3d cljs.core.meta(to);\nvar rf \x3d (function() {\nvar G__24611 \x3d null;\nvar G__24611__1 \x3d (function (coll){\nreturn cljs.core._with_meta(cljs.core.persistent_BANG_(coll),tm);\n});\nvar G__24611__2 \x3d (function (coll,v){\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(coll,v);\n});\nG__24611 \x3d function(coll,v){\nswitch(arguments.length){\ncase 1:\nreturn G__24611__1.call(this,coll);\ncase 2:\nreturn G__24611__2.call(this,coll,v);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24611.cljs$core$IFn$_invoke$arity$1 \x3d G__24611__1;\nG__24611.cljs$core$IFn$_invoke$arity$2 \x3d G__24611__2;\nreturn G__24611;\n})()\n;\nreturn cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(xform,rf,cljs.core.transient$(to),from);\n} else {\nreturn cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(xform,cljs.core.conj,to,from);\n}\n}));\n\n(cljs.core.into.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns a vector consisting of the result of applying f to the\n *   set of first items of each coll, followed by applying f to the set\n *   of second items in each coll, until any one of the colls is\n *   exhausted.  Any remaining items in other colls are ignored. Function\n *   f should accept number-of-colls arguments.\n */\ncljs.core.mapv \x3d (function cljs$core$mapv(var_args){\nvar G__18120 \x3d arguments.length;\nswitch (G__18120) {\ncase 2:\nreturn cljs.core.mapv.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.mapv.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.mapv.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24616 \x3d arguments.length;\nvar i__5727__auto___24617 \x3d (0);\nwhile(true){\nif((i__5727__auto___24617 \x3c len__5726__auto___24616)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24617]));\n\nvar G__24619 \x3d (i__5727__auto___24617 + (1));\ni__5727__auto___24617 \x3d G__24619;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((4) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((4)),(0),null)):null);\nreturn cljs.core.mapv.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.mapv.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (v,o){\nreturn 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)));\n}),cljs.core.transient$(cljs.core.PersistentVector.EMPTY),coll));\n}));\n\n(cljs.core.mapv.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,c1,c2){\nreturn 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));\n}));\n\n(cljs.core.mapv.cljs$core$IFn$_invoke$arity$4 \x3d (function (f,c1,c2,c3){\nreturn 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));\n}));\n\n(cljs.core.mapv.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,c1,c2,c3,colls){\nreturn 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.prim_seq.cljs$core$IFn$_invoke$arity$2([colls], 0)));\n}));\n\n/** @this {Function} */\n(cljs.core.mapv.cljs$lang$applyTo \x3d (function (seq18115){\nvar G__18116 \x3d cljs.core.first(seq18115);\nvar seq18115__$1 \x3d cljs.core.next(seq18115);\nvar G__18117 \x3d cljs.core.first(seq18115__$1);\nvar seq18115__$2 \x3d cljs.core.next(seq18115__$1);\nvar G__18118 \x3d cljs.core.first(seq18115__$2);\nvar seq18115__$3 \x3d cljs.core.next(seq18115__$2);\nvar G__18119 \x3d cljs.core.first(seq18115__$3);\nvar seq18115__$4 \x3d cljs.core.next(seq18115__$3);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18116,G__18117,G__18118,G__18119,seq18115__$4);\n}));\n\n(cljs.core.mapv.cljs$lang$maxFixedArity \x3d (4));\n\n/**\n * Returns a vector of the items in coll for which\n *   (pred item) returns logical true. pred must be free of side-effects.\n */\ncljs.core.filterv \x3d (function cljs$core$filterv(pred,coll){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (v,o){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(o) : pred.call(null, o)))){\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(v,o);\n} else {\nreturn v;\n}\n}),cljs.core.transient$(cljs.core.PersistentVector.EMPTY),coll));\n});\n/**\n * Returns a lazy sequence of lists of n items each, at offsets step\n *   apart. If step is not supplied, defaults to n, i.e. the partitions\n *   do not overlap. If a pad collection is supplied, use its elements as\n *   necessary to complete last partition up to n items. In case there are\n *   not enough padding elements, return a partition with less than n items.\n */\ncljs.core.partition \x3d (function cljs$core$partition(var_args){\nvar G__18122 \x3d arguments.length;\nswitch (G__18122) {\ncase 2:\nreturn cljs.core.partition.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.partition.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.partition.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.partition.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nreturn cljs.core.partition.cljs$core$IFn$_invoke$arity$3(n,n,coll);\n}));\n\n(cljs.core.partition.cljs$core$IFn$_invoke$arity$3 \x3d (function (n,step,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar p \x3d cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,s);\nif((n \x3d\x3d\x3d cljs.core.count(p))){\nreturn 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)));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.partition.cljs$core$IFn$_invoke$arity$4 \x3d (function (n,step,pad,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar p \x3d cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,s);\nif((n \x3d\x3d\x3d cljs.core.count(p))){\nreturn 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)));\n} else {\nreturn (new cljs.core.List(null,cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(p,pad)),null,(1),null));\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.partition.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Returns the value in a nested associative structure,\n *   where ks is a sequence of keys. Returns nil if the key is not present,\n *   or the not-found value if supplied.\n */\ncljs.core.get_in \x3d (function cljs$core$get_in(var_args){\nvar G__18124 \x3d arguments.length;\nswitch (G__18124) {\ncase 2:\nreturn cljs.core.get_in.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.get_in.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2 \x3d (function (m,ks){\nvar m__$1 \x3d m;\nvar ks__$1 \x3d cljs.core.seq(ks);\nwhile(true){\nif((ks__$1 \x3d\x3d null)){\nreturn m__$1;\n} else {\nvar G__24638 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m__$1,cljs.core.first(ks__$1));\nvar G__24639 \x3d cljs.core.next(ks__$1);\nm__$1 \x3d G__24638;\nks__$1 \x3d G__24639;\ncontinue;\n}\nbreak;\n}\n}));\n\n(cljs.core.get_in.cljs$core$IFn$_invoke$arity$3 \x3d (function (m,ks,not_found){\nvar sentinel \x3d cljs.core.lookup_sentinel;\nvar m__$1 \x3d m;\nvar ks__$1 \x3d cljs.core.seq(ks);\nwhile(true){\nif((!((ks__$1 \x3d\x3d null)))){\nvar m__$2 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(m__$1,cljs.core.first(ks__$1),sentinel);\nif((sentinel \x3d\x3d\x3d m__$2)){\nreturn not_found;\n} else {\nvar G__24642 \x3d sentinel;\nvar G__24643 \x3d m__$2;\nvar G__24644 \x3d cljs.core.next(ks__$1);\nsentinel \x3d G__24642;\nm__$1 \x3d G__24643;\nks__$1 \x3d G__24644;\ncontinue;\n}\n} else {\nreturn m__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.get_in.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Associates a value in a nested associative structure, where ks is a\n *   sequence of keys and v is the new value and returns a new nested structure.\n *   If any levels do not exist, hash-maps will be created.\n */\ncljs.core.assoc_in \x3d (function cljs$core$assoc_in(m,p__18125,v){\nvar vec__18126 \x3d p__18125;\nvar seq__18127 \x3d cljs.core.seq(vec__18126);\nvar first__18128 \x3d cljs.core.first(seq__18127);\nvar seq__18127__$1 \x3d cljs.core.next(seq__18127);\nvar k \x3d first__18128;\nvar ks \x3d seq__18127__$1;\nif(ks){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18129 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__18130 \x3d ks;\nvar G__18131 \x3d v;\nreturn (cljs.core.assoc_in.cljs$core$IFn$_invoke$arity$3 ? cljs.core.assoc_in.cljs$core$IFn$_invoke$arity$3(G__18129,G__18130,G__18131) : cljs.core.assoc_in.call(null, G__18129,G__18130,G__18131));\n})());\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,v);\n}\n});\n/**\n * \x27Updates\x27 a value in a nested associative structure, where ks is a\n *   sequence of keys and f is a function that will take the old value\n *   and any supplied args and return the new value, and returns a new\n *   nested structure.  If any levels do not exist, hash-maps will be\n *   created.\n */\ncljs.core.update_in \x3d (function cljs$core$update_in(var_args){\nvar G__18140 \x3d arguments.length;\nswitch (G__18140) {\ncase 3:\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24649 \x3d arguments.length;\nvar i__5727__auto___24650 \x3d (0);\nwhile(true){\nif((i__5727__auto___24650 \x3c len__5726__auto___24649)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24650]));\n\nvar G__24651 \x3d (i__5727__auto___24650 + (1));\ni__5727__auto___24650 \x3d G__24651;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((6) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((6)),(0),null)):null);\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.update_in.cljs$core$IFn$_invoke$arity$3 \x3d (function (m,p__18141,f){\nvar vec__18142 \x3d p__18141;\nvar seq__18143 \x3d cljs.core.seq(vec__18142);\nvar first__18144 \x3d cljs.core.first(seq__18143);\nvar seq__18143__$1 \x3d cljs.core.next(seq__18143);\nvar k \x3d first__18144;\nvar ks \x3d seq__18143__$1;\nif(ks){\nreturn 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));\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18145 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__18145) : f.call(null, G__18145));\n})());\n}\n}));\n\n(cljs.core.update_in.cljs$core$IFn$_invoke$arity$4 \x3d (function (m,p__18146,f,a){\nvar vec__18147 \x3d p__18146;\nvar seq__18148 \x3d cljs.core.seq(vec__18147);\nvar first__18149 \x3d cljs.core.first(seq__18148);\nvar seq__18148__$1 \x3d cljs.core.next(seq__18148);\nvar k \x3d first__18149;\nvar ks \x3d seq__18148__$1;\nif(ks){\nreturn 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));\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18150 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__18151 \x3d a;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18150,G__18151) : f.call(null, G__18150,G__18151));\n})());\n}\n}));\n\n(cljs.core.update_in.cljs$core$IFn$_invoke$arity$5 \x3d (function (m,p__18152,f,a,b){\nvar vec__18153 \x3d p__18152;\nvar seq__18154 \x3d cljs.core.seq(vec__18153);\nvar first__18155 \x3d cljs.core.first(seq__18154);\nvar seq__18154__$1 \x3d cljs.core.next(seq__18154);\nvar k \x3d first__18155;\nvar ks \x3d seq__18154__$1;\nif(ks){\nreturn 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));\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18156 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__18157 \x3d a;\nvar G__18158 \x3d b;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18156,G__18157,G__18158) : f.call(null, G__18156,G__18157,G__18158));\n})());\n}\n}));\n\n(cljs.core.update_in.cljs$core$IFn$_invoke$arity$6 \x3d (function (m,p__18159,f,a,b,c){\nvar vec__18160 \x3d p__18159;\nvar seq__18161 \x3d cljs.core.seq(vec__18160);\nvar first__18162 \x3d cljs.core.first(seq__18161);\nvar seq__18161__$1 \x3d cljs.core.next(seq__18161);\nvar k \x3d first__18162;\nvar ks \x3d seq__18161__$1;\nif(ks){\nreturn 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));\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18163 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__18164 \x3d a;\nvar G__18165 \x3d b;\nvar G__18166 \x3d c;\nreturn (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(G__18163,G__18164,G__18165,G__18166) : f.call(null, G__18163,G__18164,G__18165,G__18166));\n})());\n}\n}));\n\n(cljs.core.update_in.cljs$core$IFn$_invoke$arity$variadic \x3d (function (m,p__18167,f,a,b,c,args){\nvar vec__18168 \x3d p__18167;\nvar seq__18169 \x3d cljs.core.seq(vec__18168);\nvar first__18170 \x3d cljs.core.first(seq__18169);\nvar seq__18169__$1 \x3d cljs.core.next(seq__18169);\nvar k \x3d first__18170;\nvar ks \x3d seq__18169__$1;\nif(ks){\nreturn 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.prim_seq.cljs$core$IFn$_invoke$arity$2([b,c,args], 0)));\n} else {\nreturn 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.prim_seq.cljs$core$IFn$_invoke$arity$2([args], 0)));\n}\n}));\n\n/** @this {Function} */\n(cljs.core.update_in.cljs$lang$applyTo \x3d (function (seq18133){\nvar G__18134 \x3d cljs.core.first(seq18133);\nvar seq18133__$1 \x3d cljs.core.next(seq18133);\nvar G__18135 \x3d cljs.core.first(seq18133__$1);\nvar seq18133__$2 \x3d cljs.core.next(seq18133__$1);\nvar G__18136 \x3d cljs.core.first(seq18133__$2);\nvar seq18133__$3 \x3d cljs.core.next(seq18133__$2);\nvar G__18137 \x3d cljs.core.first(seq18133__$3);\nvar seq18133__$4 \x3d cljs.core.next(seq18133__$3);\nvar G__18138 \x3d cljs.core.first(seq18133__$4);\nvar seq18133__$5 \x3d cljs.core.next(seq18133__$4);\nvar G__18139 \x3d cljs.core.first(seq18133__$5);\nvar seq18133__$6 \x3d cljs.core.next(seq18133__$5);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18134,G__18135,G__18136,G__18137,G__18138,G__18139,seq18133__$6);\n}));\n\n(cljs.core.update_in.cljs$lang$maxFixedArity \x3d (6));\n\n/**\n * \x27Updates\x27 a value in an associative structure, where k is a\n *   key and f is a function that will take the old value\n *   and any supplied args and return the new value, and returns a new\n *   structure.  If the key does not exist, nil is passed as the old value.\n */\ncljs.core.update \x3d (function cljs$core$update(var_args){\nvar G__18179 \x3d arguments.length;\nswitch (G__18179) {\ncase 3:\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___24668 \x3d arguments.length;\nvar i__5727__auto___24670 \x3d (0);\nwhile(true){\nif((i__5727__auto___24670 \x3c len__5726__auto___24668)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___24670]));\n\nvar G__24671 \x3d (i__5727__auto___24670 + (1));\ni__5727__auto___24670 \x3d G__24671;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((6) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((6)),(0),null)):null);\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.update.cljs$core$IFn$_invoke$arity$3 \x3d (function (m,k,f){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18180 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__18180) : f.call(null, G__18180));\n})());\n}));\n\n(cljs.core.update.cljs$core$IFn$_invoke$arity$4 \x3d (function (m,k,f,x){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18181 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__18182 \x3d x;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18181,G__18182) : f.call(null, G__18181,G__18182));\n})());\n}));\n\n(cljs.core.update.cljs$core$IFn$_invoke$arity$5 \x3d (function (m,k,f,x,y){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18183 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__18184 \x3d x;\nvar G__18185 \x3d y;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18183,G__18184,G__18185) : f.call(null, G__18183,G__18184,G__18185));\n})());\n}));\n\n(cljs.core.update.cljs$core$IFn$_invoke$arity$6 \x3d (function (m,k,f,x,y,z){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__18186 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__18187 \x3d x;\nvar G__18188 \x3d y;\nvar G__18189 \x3d z;\nreturn (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(G__18186,G__18187,G__18188,G__18189) : f.call(null, G__18186,G__18187,G__18188,G__18189));\n})());\n}));\n\n(cljs.core.update.cljs$core$IFn$_invoke$arity$variadic \x3d (function (m,k,f,x,y,z,more){\nreturn 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.prim_seq.cljs$core$IFn$_invoke$arity$2([more], 0)));\n}));\n\n/** @this {Function} */\n(cljs.core.update.cljs$lang$applyTo \x3d (function (seq18172){\nvar G__18173 \x3d cljs.core.first(seq18172);\nvar seq18172__$1 \x3d cljs.core.next(seq18172);\nvar G__18174 \x3d cljs.core.first(seq18172__$1);\nvar seq18172__$2 \x3d cljs.core.next(seq18172__$1);\nvar G__18175 \x3d cljs.core.first(seq18172__$2);\nvar seq18172__$3 \x3d cljs.core.next(seq18172__$2);\nvar G__18176 \x3d cljs.core.first(seq18172__$3);\nvar seq18172__$4 \x3d cljs.core.next(seq18172__$3);\nvar G__18177 \x3d cljs.core.first(seq18172__$4);\nvar seq18172__$5 \x3d cljs.core.next(seq18172__$4);\nvar G__18178 \x3d cljs.core.first(seq18172__$5);\nvar seq18172__$6 \x3d cljs.core.next(seq18172__$5);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__18173,G__18174,G__18175,G__18176,G__18177,G__18178,seq18172__$6);\n}));\n\n(cljs.core.update.cljs$lang$maxFixedArity \x3d (6));\n\n\n/**\n* @constructor\n*/\ncljs.core.VectorNode \x3d (function (edit,arr){\nthis.edit \x3d edit;\nthis.arr \x3d arr;\n});\n\n(cljs.core.VectorNode.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22edit\x22,\x22edit\x22,-1302639,null),new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null)], null);\n}));\n\n(cljs.core.VectorNode.cljs$lang$type \x3d true);\n\n(cljs.core.VectorNode.cljs$lang$ctorStr \x3d \x22cljs.core/VectorNode\x22);\n\n(cljs.core.VectorNode.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/VectorNode\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/VectorNode.\n */\ncljs.core.__GT_VectorNode \x3d (function cljs$core$__GT_VectorNode(edit,arr){\nreturn (new cljs.core.VectorNode(edit,arr));\n});\n\ncljs.core.pv_fresh_node \x3d (function cljs$core$pv_fresh_node(edit){\nreturn (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]));\n});\ncljs.core.pv_aget \x3d (function cljs$core$pv_aget(node,idx){\nreturn (node.arr[idx]);\n});\ncljs.core.pv_aset \x3d (function cljs$core$pv_aset(node,idx,val){\nreturn (node.arr[idx] \x3d val);\n});\ncljs.core.pv_clone_node \x3d (function cljs$core$pv_clone_node(node){\nreturn (new cljs.core.VectorNode(node.edit,cljs.core.aclone(node.arr)));\n});\ncljs.core.tail_off \x3d (function cljs$core$tail_off(pv){\nvar cnt \x3d pv.cnt;\nif((cnt \x3c (32))){\nreturn (0);\n} else {\nreturn (((cnt - (1)) \x3e\x3e\x3e (5)) \x3c\x3c (5));\n}\n});\ncljs.core.new_path \x3d (function cljs$core$new_path(edit,level,node){\nvar ll \x3d level;\nvar ret \x3d node;\nwhile(true){\nif((ll \x3d\x3d\x3d (0))){\nreturn ret;\n} else {\nvar embed \x3d ret;\nvar r \x3d cljs.core.pv_fresh_node(edit);\nvar _ \x3d cljs.core.pv_aset(r,(0),embed);\nvar G__24680 \x3d (ll - (5));\nvar G__24681 \x3d r;\nll \x3d G__24680;\nret \x3d G__24681;\ncontinue;\n}\nbreak;\n}\n});\ncljs.core.push_tail \x3d (function cljs$core$push_tail(pv,level,parent,tailnode){\nvar ret \x3d cljs.core.pv_clone_node(parent);\nvar subidx \x3d (((pv.cnt - (1)) \x3e\x3e\x3e level) \x26 (31));\nif(((5) \x3d\x3d\x3d level)){\ncljs.core.pv_aset(ret,subidx,tailnode);\n\nreturn ret;\n} else {\nvar child \x3d cljs.core.pv_aget(parent,subidx);\nif((!((child \x3d\x3d null)))){\nvar node_to_insert \x3d (function (){var G__18190 \x3d pv;\nvar G__18191 \x3d (level - (5));\nvar G__18192 \x3d child;\nvar G__18193 \x3d tailnode;\nreturn (cljs.core.push_tail.cljs$core$IFn$_invoke$arity$4 ? cljs.core.push_tail.cljs$core$IFn$_invoke$arity$4(G__18190,G__18191,G__18192,G__18193) : cljs.core.push_tail.call(null, G__18190,G__18191,G__18192,G__18193));\n})();\ncljs.core.pv_aset(ret,subidx,node_to_insert);\n\nreturn ret;\n} else {\nvar node_to_insert \x3d cljs.core.new_path(null,(level - (5)),tailnode);\ncljs.core.pv_aset(ret,subidx,node_to_insert);\n\nreturn ret;\n}\n}\n});\ncljs.core.vector_index_out_of_bounds \x3d (function cljs$core$vector_index_out_of_bounds(i,cnt){\nthrow (new Error([\x22No item \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(i),\x22 in vector of length \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cnt)].join(\x27\x27)));\n});\ncljs.core.first_array_for_longvec \x3d (function cljs$core$first_array_for_longvec(pv){\nvar node \x3d pv.root;\nvar level \x3d pv.shift;\nwhile(true){\nif((level \x3e (0))){\nvar G__24686 \x3d cljs.core.pv_aget(node,(0));\nvar G__24687 \x3d (level - (5));\nnode \x3d G__24686;\nlevel \x3d G__24687;\ncontinue;\n} else {\nreturn node.arr;\n}\nbreak;\n}\n});\ncljs.core.unchecked_array_for \x3d (function cljs$core$unchecked_array_for(pv,i){\nif((i \x3e\x3d cljs.core.tail_off(pv))){\nreturn pv.tail;\n} else {\nvar node \x3d pv.root;\nvar level \x3d pv.shift;\nwhile(true){\nif((level \x3e (0))){\nvar G__24688 \x3d cljs.core.pv_aget(node,((i \x3e\x3e\x3e level) \x26 (31)));\nvar G__24689 \x3d (level - (5));\nnode \x3d G__24688;\nlevel \x3d G__24689;\ncontinue;\n} else {\nreturn node.arr;\n}\nbreak;\n}\n}\n});\ncljs.core.array_for \x3d (function cljs$core$array_for(pv,i){\nif(((((0) \x3c\x3d i)) \x26\x26 ((i \x3c pv.cnt)))){\nreturn cljs.core.unchecked_array_for(pv,i);\n} else {\nreturn cljs.core.vector_index_out_of_bounds(i,pv.cnt);\n}\n});\ncljs.core.do_assoc \x3d (function cljs$core$do_assoc(pv,level,node,i,val){\nvar ret \x3d cljs.core.pv_clone_node(node);\nif((level \x3d\x3d\x3d (0))){\ncljs.core.pv_aset(ret,(i \x26 (31)),val);\n\nreturn ret;\n} else {\nvar subidx \x3d ((i \x3e\x3e\x3e level) \x26 (31));\ncljs.core.pv_aset(ret,subidx,(function (){var G__18194 \x3d pv;\nvar G__18195 \x3d (level - (5));\nvar G__18196 \x3d cljs.core.pv_aget(node,subidx);\nvar G__18197 \x3d i;\nvar G__18198 \x3d val;\nreturn (cljs.core.do_assoc.cljs$core$IFn$_invoke$arity$5 ? cljs.core.do_assoc.cljs$core$IFn$_invoke$arity$5(G__18194,G__18195,G__18196,G__18197,G__18198) : cljs.core.do_assoc.call(null, G__18194,G__18195,G__18196,G__18197,G__18198));\n})());\n\nreturn ret;\n}\n});\ncljs.core.pop_tail \x3d (function cljs$core$pop_tail(pv,level,node){\nvar subidx \x3d (((pv.cnt - (2)) \x3e\x3e\x3e level) \x26 (31));\nif((level \x3e (5))){\nvar new_child \x3d (function (){var G__18199 \x3d pv;\nvar G__18200 \x3d (level - (5));\nvar G__18201 \x3d cljs.core.pv_aget(node,subidx);\nreturn (cljs.core.pop_tail.cljs$core$IFn$_invoke$arity$3 ? cljs.core.pop_tail.cljs$core$IFn$_invoke$arity$3(G__18199,G__18200,G__18201) : cljs.core.pop_tail.call(null, G__18199,G__18200,G__18201));\n})();\nif((((new_child \x3d\x3d null)) \x26\x26 ((subidx \x3d\x3d\x3d (0))))){\nreturn null;\n} else {\nvar ret \x3d cljs.core.pv_clone_node(node);\ncljs.core.pv_aset(ret,subidx,new_child);\n\nreturn ret;\n}\n} else {\nif((subidx \x3d\x3d\x3d (0))){\nreturn null;\n} else {\nvar ret \x3d cljs.core.pv_clone_node(node);\ncljs.core.pv_aset(ret,subidx,null);\n\nreturn ret;\n\n}\n}\n});\n\n/**\n* @constructor\n*/\ncljs.core.RangedIterator \x3d (function (i,base,arr,v,start,end){\nthis.i \x3d i;\nthis.base \x3d base;\nthis.arr \x3d arr;\nthis.v \x3d v;\nthis.start \x3d start;\nthis.end \x3d end;\n});\n(cljs.core.RangedIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn (self__.i \x3c self__.end);\n}));\n\n(cljs.core.RangedIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif(((self__.i - self__.base) \x3d\x3d\x3d (32))){\n(self__.arr \x3d cljs.core.unchecked_array_for(self__.v,self__.i));\n\n(self__.base \x3d (self__.base + (32)));\n} else {\n}\n\nvar ret \x3d (self__.arr[(self__.i \x26 (31))]);\n(self__.i \x3d (self__.i + (1)));\n\nreturn ret;\n}));\n\n(cljs.core.RangedIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22base\x22,\x22base\x22,1825810849,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22v\x22,\x22v\x22,1661996586,null),new cljs.core.Symbol(null,\x22start\x22,\x22start\x22,1285322546,null),new cljs.core.Symbol(null,\x22end\x22,\x22end\x22,1372345569,null)], null);\n}));\n\n(cljs.core.RangedIterator.cljs$lang$type \x3d true);\n\n(cljs.core.RangedIterator.cljs$lang$ctorStr \x3d \x22cljs.core/RangedIterator\x22);\n\n(cljs.core.RangedIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/RangedIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/RangedIterator.\n */\ncljs.core.__GT_RangedIterator \x3d (function cljs$core$__GT_RangedIterator(i,base,arr,v,start,end){\nreturn (new cljs.core.RangedIterator(i,base,arr,v,start,end));\n});\n\ncljs.core.ranged_iterator \x3d (function cljs$core$ranged_iterator(v,start,end){\nvar i \x3d start;\nreturn (new cljs.core.RangedIterator(i,(i - (i % (32))),(((start \x3c cljs.core.count(v)))?cljs.core.unchecked_array_for(v,i):null),v,start,end));\n});\ncljs.core.pv_reduce \x3d (function cljs$core$pv_reduce(var_args){\nvar G__18203 \x3d arguments.length;\nswitch (G__18203) {\ncase 4:\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4 \x3d (function (pv,f,start,end){\nif((start \x3c end)){\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5(pv,f,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(pv,start),(start + (1)),end);\n} else {\nreturn (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n}\n}));\n\n(cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5 \x3d (function (pv,f,init,start,end){\nvar acc \x3d init;\nvar i \x3d start;\nvar arr \x3d cljs.core.unchecked_array_for(pv,start);\nwhile(true){\nif((i \x3c end)){\nvar j \x3d (i \x26 (31));\nvar arr__$1 \x3d (((j \x3d\x3d\x3d (0)))?cljs.core.unchecked_array_for(pv,i):arr);\nvar nacc \x3d (function (){var G__18204 \x3d acc;\nvar G__18205 \x3d (arr__$1[j]);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18204,G__18205) : f.call(null, G__18204,G__18205));\n})();\nif(cljs.core.reduced_QMARK_(nacc)){\nreturn cljs.core.deref(nacc);\n} else {\nvar G__24698 \x3d nacc;\nvar G__24699 \x3d (i + (1));\nvar G__24700 \x3d arr__$1;\nacc \x3d G__24698;\ni \x3d G__24699;\narr \x3d G__24700;\ncontinue;\n}\n} else {\nreturn acc;\n}\nbreak;\n}\n}));\n\n(cljs.core.pv_reduce.cljs$lang$maxFixedArity \x3d 5);\n\n\n\n\n\n\n\n/**\n * Marker protocol\n * @interface\n */\ncljs.core.APersistentVector \x3d function(){};\n\n\n/**\n* @constructor\n * @implements {cljs.core.IDrop}\n * @implements {cljs.core.APersistentVector}\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IVector}\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEditableCollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.ILookup}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.PersistentVector \x3d (function (meta,cnt,shift,root,tail,__hash){\nthis.meta \x3d meta;\nthis.cnt \x3d cnt;\nthis.shift \x3d shift;\nthis.root \x3d root;\nthis.tail \x3d tail;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 167666463;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 401412;\n});\n(cljs.core.PersistentVector.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentVector.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((((0) \x3c\x3d n)) \x26\x26 ((n \x3c self__.cnt)))){\nreturn (new cljs.core.MapEntry(n,(cljs.core.unchecked_array_for(coll__$1,n)[(n \x26 (31))]),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentVector.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentVector.prototype.indexOf \x3d (function() {\nvar G__24703 \x3d null;\nvar G__24703__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__24703__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24703 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24703__1.call(this,x);\ncase 2:\nreturn G__24703__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24703.cljs$core$IFn$_invoke$arity$1 \x3d G__24703__1;\nG__24703.cljs$core$IFn$_invoke$arity$2 \x3d G__24703__2;\nreturn G__24703;\n})()\n);\n\n(cljs.core.PersistentVector.prototype.lastIndexOf \x3d (function() {\nvar G__24704 \x3d null;\nvar G__24704__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__24704__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24704 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24704__1.call(this,x);\ncase 2:\nreturn G__24704__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24704.cljs$core$IFn$_invoke$arity$1 \x3d G__24704__1;\nG__24704.cljs$core$IFn$_invoke$arity$2 \x3d G__24704__2;\nreturn G__24704;\n})()\n);\n\n(cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,k,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(typeof k \x3d\x3d\x3d \x27number\x27){\nreturn coll__$1.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (v,f,init){\nvar self__ \x3d this;\nvar v__$1 \x3d this;\nvar i \x3d (0);\nvar init__$1 \x3d init;\nwhile(true){\nif((i \x3c self__.cnt)){\nvar arr \x3d cljs.core.unchecked_array_for(v__$1,i);\nvar len \x3d arr.length;\nvar init__$2 \x3d (function (){var j \x3d (0);\nvar init__$2 \x3d init__$1;\nwhile(true){\nif((j \x3c len)){\nvar init__$3 \x3d (function (){var G__18207 \x3d init__$2;\nvar G__18208 \x3d (j + i);\nvar G__18209 \x3d (arr[j]);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18207,G__18208,G__18209) : f.call(null, G__18207,G__18208,G__18209));\n})();\nif(cljs.core.reduced_QMARK_(init__$3)){\nreturn init__$3;\n} else {\nvar G__24709 \x3d (j + (1));\nvar G__24710 \x3d init__$3;\nj \x3d G__24709;\ninit__$2 \x3d G__24710;\ncontinue;\n}\n} else {\nreturn init__$2;\n}\nbreak;\n}\n})();\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn cljs.core.deref(init__$2);\n} else {\nvar G__24711 \x3d (i + len);\nvar G__24712 \x3d init__$2;\ni \x3d G__24711;\ninit__$1 \x3d G__24712;\ncontinue;\n}\n} else {\nreturn init__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$APersistentVector$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (cljs.core.array_for(coll__$1,n)[(n \x26 (31))]);\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (coll,n,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((((0) \x3c\x3d n)) \x26\x26 ((n \x3c self__.cnt)))){\nreturn (cljs.core.unchecked_array_for(coll__$1,n)[(n \x26 (31))]);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IVector$_assoc_n$arity$3 \x3d (function (coll,n,val){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((((0) \x3c\x3d n)) \x26\x26 ((n \x3c self__.cnt)))){\nif((cljs.core.tail_off(coll__$1) \x3c\x3d n)){\nvar new_tail \x3d cljs.core.aclone(self__.tail);\n(new_tail[(n \x26 (31))] \x3d val);\n\nreturn (new cljs.core.PersistentVector(self__.meta,self__.cnt,self__.shift,self__.root,new_tail,null));\n} else {\nreturn (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));\n}\n} else {\nif((n \x3d\x3d\x3d self__.cnt)){\nreturn coll__$1.cljs$core$ICollection$_conj$arity$2(null, val);\n} else {\nthrow (new Error([\x22Index \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),\x22 out of bounds  [0,\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.cnt),\x22]\x22].join(\x27\x27)));\n\n}\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core.ranged_iterator(this$__$1,(0),self__.cnt);\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.PersistentVector(self__.meta,self__.cnt,self__.shift,self__.root,self__.tail,self__.__hash));\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.cnt;\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3e (0))){\nreturn coll__$1.cljs$core$IIndexed$_nth$arity$2(null, (self__.cnt - (1)));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3d\x3d\x3d (0))){\nthrow (new Error(\x22Can\x27t pop empty vector\x22));\n} else {\nif(((1) \x3d\x3d\x3d self__.cnt)){\nreturn cljs.core._with_meta(cljs.core.PersistentVector.EMPTY,self__.meta);\n} else {\nif(((1) \x3c (self__.cnt - cljs.core.tail_off(coll__$1)))){\nreturn (new cljs.core.PersistentVector(self__.meta,(self__.cnt - (1)),self__.shift,self__.root,self__.tail.slice((0),(-1)),null));\n} else {\nvar new_tail \x3d cljs.core.unchecked_array_for(coll__$1,(self__.cnt - (2)));\nvar nr \x3d cljs.core.pop_tail(coll__$1,self__.shift,self__.root);\nvar new_root \x3d (((nr \x3d\x3d null))?cljs.core.PersistentVector.EMPTY_NODE:nr);\nvar cnt_1 \x3d (self__.cnt - (1));\nif(((((5) \x3c self__.shift)) \x26\x26 ((cljs.core.pv_aget(new_root,(1)) \x3d\x3d null)))){\nreturn (new cljs.core.PersistentVector(self__.meta,cnt_1,(self__.shift - (5)),cljs.core.pv_aget(new_root,(0)),new_tail,null));\n} else {\nreturn (new cljs.core.PersistentVector(self__.meta,cnt_1,self__.shift,new_root,new_tail,null));\n}\n\n}\n}\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3e (0))){\nreturn (new cljs.core.RSeq(coll__$1,(self__.cnt - (1)),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((other instanceof cljs.core.PersistentVector)){\nif((self__.cnt \x3d\x3d\x3d cljs.core.count(other))){\nvar me_iter \x3d coll__$1.cljs$core$IIterable$_iterator$arity$1(null, );\nvar you_iter \x3d other.cljs$core$IIterable$_iterator$arity$1(null, );\nwhile(true){\nif(me_iter.hasNext()){\nvar x \x3d me_iter.next();\nvar y \x3d you_iter.next();\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)){\ncontinue;\n} else {\nreturn false;\n}\n} else {\nreturn true;\n}\nbreak;\n}\n} else {\nreturn false;\n}\n} else {\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (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))));\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.PersistentVector.EMPTY,self__.meta);\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (v,f){\nvar self__ \x3d this;\nvar v__$1 \x3d this;\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4(v__$1,f,(0),self__.cnt);\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (v,f,init){\nvar self__ \x3d this;\nvar v__$1 \x3d this;\nvar i \x3d (0);\nvar init__$1 \x3d init;\nwhile(true){\nif((i \x3c self__.cnt)){\nvar arr \x3d cljs.core.unchecked_array_for(v__$1,i);\nvar len \x3d arr.length;\nvar init__$2 \x3d (function (){var j \x3d (0);\nvar init__$2 \x3d init__$1;\nwhile(true){\nif((j \x3c len)){\nvar init__$3 \x3d (function (){var G__18210 \x3d init__$2;\nvar G__18211 \x3d (arr[j]);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__18210,G__18211) : f.call(null, G__18210,G__18211));\n})();\nif(cljs.core.reduced_QMARK_(init__$3)){\nreturn init__$3;\n} else {\nvar G__24726 \x3d (j + (1));\nvar G__24727 \x3d init__$3;\nj \x3d G__24726;\ninit__$2 \x3d G__24727;\ncontinue;\n}\n} else {\nreturn init__$2;\n}\nbreak;\n}\n})();\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn cljs.core.deref(init__$2);\n} else {\nvar G__24728 \x3d (i + len);\nvar G__24729 \x3d init__$2;\ni \x3d G__24728;\ninit__$1 \x3d G__24729;\ncontinue;\n}\n} else {\nreturn init__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (coll,k,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(typeof k \x3d\x3d\x3d \x27number\x27){\nreturn coll__$1.cljs$core$IVector$_assoc_n$arity$3(null, k,v);\n} else {\nthrow (new Error(\x22Vector\x27s key for assoc must be a number.\x22));\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.integer_QMARK_(k)){\nreturn ((((0) \x3c\x3d k)) \x26\x26 ((k \x3c self__.cnt)));\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3d\x3d\x3d (0))){\nreturn null;\n} else {\nif((self__.cnt \x3c\x3d (32))){\nreturn (new cljs.core.IndexedSeq(self__.tail,(0),null));\n} else {\nvar G__18212 \x3d coll__$1;\nvar G__18213 \x3d cljs.core.first_array_for_longvec(coll__$1);\nvar G__18214 \x3d (0);\nvar G__18215 \x3d (0);\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(G__18212,G__18213,G__18214,G__18215) : cljs.core.chunked_seq.call(null, G__18212,G__18213,G__18214,G__18215));\n\n}\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentVector(new_meta,self__.cnt,self__.shift,self__.root,self__.tail,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((self__.cnt - cljs.core.tail_off(coll__$1)) \x3c (32))){\nvar len \x3d self__.tail.length;\nvar new_tail \x3d (new Array((len + (1))));\nvar n__5593__auto___24734 \x3d len;\nvar i_24735 \x3d (0);\nwhile(true){\nif((i_24735 \x3c n__5593__auto___24734)){\n(new_tail[i_24735] \x3d (self__.tail[i_24735]));\n\nvar G__24736 \x3d (i_24735 + (1));\ni_24735 \x3d G__24736;\ncontinue;\n} else {\n}\nbreak;\n}\n\n(new_tail[len] \x3d o);\n\nreturn (new cljs.core.PersistentVector(self__.meta,(self__.cnt + (1)),self__.shift,self__.root,new_tail,null));\n} else {\nvar root_overflow_QMARK_ \x3d ((self__.cnt \x3e\x3e\x3e (5)) \x3e ((1) \x3c\x3c self__.shift));\nvar new_shift \x3d ((root_overflow_QMARK_)?(self__.shift + (5)):self__.shift);\nvar new_root \x3d ((root_overflow_QMARK_)?(function (){var n_r \x3d cljs.core.pv_fresh_node(null);\ncljs.core.pv_aset(n_r,(0),self__.root);\n\ncljs.core.pv_aset(n_r,(1),cljs.core.new_path(null,self__.shift,(new cljs.core.VectorNode(null,self__.tail))));\n\nreturn n_r;\n})():cljs.core.push_tail(coll__$1,self__.shift,self__.root,(new cljs.core.VectorNode(null,self__.tail))));\nreturn (new cljs.core.PersistentVector(self__.meta,(self__.cnt + (1)),new_shift,new_root,[o],null));\n}\n}));\n\n(cljs.core.PersistentVector.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18216 \x3d (arguments.length - (1));\nswitch (G__18216) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.PersistentVector.prototype.apply \x3d (function (self__,args18206){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18206)));\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nif(typeof k \x3d\x3d\x3d \x27number\x27){\nreturn coll.cljs$core$IIndexed$_nth$arity$2(null, k);\n} else {\nthrow (new Error(\x22Key must be integer\x22));\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IDrop$_drop$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((n \x3c self__.cnt)){\nvar offset \x3d (n % (32));\nvar G__18217 \x3d coll__$1;\nvar G__18218 \x3d cljs.core.unchecked_array_for(coll__$1,n);\nvar G__18219 \x3d (n - offset);\nvar G__18220 \x3d offset;\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(G__18217,G__18218,G__18219,G__18220) : cljs.core.chunked_seq.call(null, G__18217,G__18218,G__18219,G__18220));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentVector.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.Symbol(null,\x22shift\x22,\x22shift\x22,-1657295705,null),new cljs.core.Symbol(null,\x22root\x22,\x22root\x22,1191874074,null),new cljs.core.Symbol(null,\x22tail\x22,\x22tail\x22,494507963,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentVector.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentVector.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentVector\x22);\n\n(cljs.core.PersistentVector.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentVector\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentVector.\n */\ncljs.core.__GT_PersistentVector \x3d (function cljs$core$__GT_PersistentVector(meta,cnt,shift,root,tail,__hash){\nreturn (new cljs.core.PersistentVector(meta,cnt,shift,root,tail,__hash));\n});\n\n(cljs.core.PersistentVector.EMPTY_NODE \x3d (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])));\n(cljs.core.PersistentVector.EMPTY \x3d (new cljs.core.PersistentVector(null,(0),(5),cljs.core.PersistentVector.EMPTY_NODE,[],cljs.core.empty_ordered_hash)));\n(cljs.core.PersistentVector.fromArray \x3d (function (xs,no_clone){\nvar l \x3d xs.length;\nvar xs__$1 \x3d ((no_clone)?xs:cljs.core.aclone(xs));\nif((l \x3c (32))){\nreturn (new cljs.core.PersistentVector(null,l,(5),cljs.core.PersistentVector.EMPTY_NODE,xs__$1,null));\n} else {\nvar node \x3d xs__$1.slice((0),(32));\nvar v \x3d (new cljs.core.PersistentVector(null,(32),(5),cljs.core.PersistentVector.EMPTY_NODE,node,null));\nvar i \x3d (32);\nvar out \x3d v.cljs$core$IEditableCollection$_as_transient$arity$1(null, );\nwhile(true){\nif((i \x3c l)){\nvar G__24743 \x3d (i + (1));\nvar G__24744 \x3d cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(out,(xs__$1[i]));\ni \x3d G__24743;\nout \x3d G__24744;\ncontinue;\n} else {\nreturn cljs.core.persistent_BANG_(out);\n}\nbreak;\n}\n}\n}));\n(cljs.core.PersistentVector.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Creates a new vector containing the contents of coll. JavaScript arrays\n *   will be aliased and should not be modified.\n */\ncljs.core.vec \x3d (function cljs$core$vec(coll){\nif(cljs.core.truth_((cljs.core.map_entry_QMARK_.cljs$core$IFn$_invoke$arity$1 ? cljs.core.map_entry_QMARK_.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.map_entry_QMARK_.call(null, coll)))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(cljs.core.key.cljs$core$IFn$_invoke$arity$1 ? cljs.core.key.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.key.call(null, coll)),(cljs.core.val.cljs$core$IFn$_invoke$arity$1 ? cljs.core.val.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.val.call(null, coll))], null);\n} else {\nif(cljs.core.vector_QMARK_(coll)){\nreturn cljs.core.with_meta(coll,null);\n} else {\nif(cljs.core.array_QMARK_(coll)){\nreturn cljs.core.PersistentVector.fromArray(coll,true);\n} else {\nreturn 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));\n\n}\n}\n}\n});\n/**\n * Creates a new vector containing the args.\n */\ncljs.core.vector \x3d (function cljs$core$vector(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___24745 \x3d arguments.length;\nvar i__5727__auto___24746 \x3d (0);\nwhile(true){\nif((i__5727__auto___24746 \x3c len__5726__auto___24745)){\nargs__5732__auto__.push((arguments[i__5727__auto___24746]));\n\nvar G__24747 \x3d (i__5727__auto___24746 + (1));\ni__5727__auto___24746 \x3d G__24747;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.vector.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.vector.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nif((((args instanceof cljs.core.IndexedSeq)) \x26\x26 ((args.i \x3d\x3d\x3d (0))))){\nreturn cljs.core.PersistentVector.fromArray(args.arr,(!(cljs.core.array_QMARK_(args.arr))));\n} else {\nreturn cljs.core.vec(args);\n}\n}));\n\n(cljs.core.vector.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.vector.cljs$lang$applyTo \x3d (function (seq18221){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq18221));\n}));\n\n\n/**\n* @constructor\n * @implements {cljs.core.IDrop}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ASeq}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IChunkedNext}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IChunkedSeq}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.ChunkedSeq \x3d (function (vec,node,i,off,meta,__hash){\nthis.vec \x3d vec;\nthis.node \x3d node;\nthis.i \x3d i;\nthis.off \x3d off;\nthis.meta \x3d meta;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32375020;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 263680;\n});\n(cljs.core.ChunkedSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.ChunkedSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.ChunkedSeq.prototype.indexOf \x3d (function() {\nvar G__24749 \x3d null;\nvar G__24749__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__24749__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24749 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24749__1.call(this,x);\ncase 2:\nreturn G__24749__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24749.cljs$core$IFn$_invoke$arity$1 \x3d G__24749__1;\nG__24749.cljs$core$IFn$_invoke$arity$2 \x3d G__24749__2;\nreturn G__24749;\n})()\n);\n\n(cljs.core.ChunkedSeq.prototype.lastIndexOf \x3d (function() {\nvar G__24750 \x3d null;\nvar G__24750__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__24750__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24750 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24750__1.call(this,x);\ncase 2:\nreturn G__24750__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24750.cljs$core$IFn$_invoke$arity$1 \x3d G__24750__1;\nG__24750.cljs$core$IFn$_invoke$arity$2 \x3d G__24750__2;\nreturn G__24750;\n})()\n);\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((self__.off + (1)) \x3c self__.node.length)){\nvar s \x3d (function (){var G__18222 \x3d self__.vec;\nvar G__18223 \x3d self__.node;\nvar G__18224 \x3d self__.i;\nvar G__18225 \x3d (self__.off + (1));\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(G__18222,G__18223,G__18224,G__18225) : cljs.core.chunked_seq.call(null, G__18222,G__18223,G__18224,G__18225));\n})();\nif((s \x3d\x3d null)){\nreturn null;\n} else {\nreturn s;\n}\n} else {\nreturn coll__$1.cljs$core$IChunkedNext$_chunked_next$arity$1(null, );\n}\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4(self__.vec,f,(self__.i + self__.off),cljs.core.count(self__.vec));\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5(self__.vec,f,start,(self__.i + self__.off),cljs.core.count(self__.vec));\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (self__.node[self__.off]);\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((self__.off + (1)) \x3c self__.node.length)){\nvar s \x3d (function (){var G__18226 \x3d self__.vec;\nvar G__18227 \x3d self__.node;\nvar G__18228 \x3d self__.i;\nvar G__18229 \x3d (self__.off + (1));\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(G__18226,G__18227,G__18228,G__18229) : cljs.core.chunked_seq.call(null, G__18226,G__18227,G__18228,G__18229));\n})();\nif((s \x3d\x3d null)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn s;\n}\n} else {\nreturn coll__$1.cljs$core$IChunkedSeq$_chunked_rest$arity$1(null, );\n}\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2(self__.node,self__.off);\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar end \x3d (self__.i + self__.node.length);\nif((end \x3c cljs.core._count(self__.vec))){\nvar G__18230 \x3d self__.vec;\nvar G__18231 \x3d cljs.core.unchecked_array_for(self__.vec,end);\nvar G__18232 \x3d end;\nvar G__18233 \x3d (0);\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(G__18230,G__18231,G__18232,G__18233) : cljs.core.chunked_seq.call(null, G__18230,G__18231,G__18232,G__18233));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (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,new_meta) : cljs.core.chunked_seq.call(null, self__.vec,self__.node,self__.i,self__.off,new_meta));\n}\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IDrop$_drop$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar o \x3d (self__.off + n);\nif((o \x3c self__.node.length)){\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(self__.vec,self__.node,self__.i,o) : cljs.core.chunked_seq.call(null, self__.vec,self__.node,self__.i,o));\n} else {\nvar i__$1 \x3d (self__.i + o);\nif((i__$1 \x3c cljs.core._count(self__.vec))){\nvar new_offset \x3d (i__$1 % (32));\nvar G__18234 \x3d self__.vec;\nvar G__18235 \x3d cljs.core.unchecked_array_for(self__.vec,i__$1);\nvar G__18236 \x3d (i__$1 - new_offset);\nvar G__18237 \x3d new_offset;\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(G__18234,G__18235,G__18236,G__18237) : cljs.core.chunked_seq.call(null, G__18234,G__18235,G__18236,G__18237));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar end \x3d (self__.i + self__.node.length);\nif((end \x3c cljs.core._count(self__.vec))){\nvar G__18238 \x3d self__.vec;\nvar G__18239 \x3d cljs.core.unchecked_array_for(self__.vec,end);\nvar G__18240 \x3d end;\nvar G__18241 \x3d (0);\nreturn (cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(G__18238,G__18239,G__18240,G__18241) : cljs.core.chunked_seq.call(null, G__18238,G__18239,G__18240,G__18241));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.ChunkedSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22vec\x22,\x22vec\x22,982683596,null),new cljs.core.Symbol(null,\x22node\x22,\x22node\x22,-2073234571,null),new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.Symbol(null,\x22off\x22,\x22off\x22,-2047994980,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ChunkedSeq.cljs$lang$type \x3d true);\n\n(cljs.core.ChunkedSeq.cljs$lang$ctorStr \x3d \x22cljs.core/ChunkedSeq\x22);\n\n(cljs.core.ChunkedSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ChunkedSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ChunkedSeq.\n */\ncljs.core.__GT_ChunkedSeq \x3d (function cljs$core$__GT_ChunkedSeq(vec,node,i,off,meta,__hash){\nreturn (new cljs.core.ChunkedSeq(vec,node,i,off,meta,__hash));\n});\n\n(cljs.core.ChunkedSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.chunked_seq \x3d (function cljs$core$chunked_seq(var_args){\nvar G__18243 \x3d arguments.length;\nswitch (G__18243) {\ncase 3:\nreturn cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$3 \x3d (function (vec,i,off){\nreturn (new cljs.core.ChunkedSeq(vec,cljs.core.array_for(vec,i),i,off,null,null));\n}));\n\n(cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 \x3d (function (vec,node,i,off){\nreturn (new cljs.core.ChunkedSeq(vec,node,i,off,null,null));\n}));\n\n(cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5 \x3d (function (vec,node,i,off,meta){\nreturn (new cljs.core.ChunkedSeq(vec,node,i,off,meta,null));\n}));\n\n(cljs.core.chunked_seq.cljs$lang$maxFixedArity \x3d 5);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IVector}\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.ILookup}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.Subvec \x3d (function (meta,v,start,end,__hash){\nthis.meta \x3d meta;\nthis.v \x3d v;\nthis.start \x3d start;\nthis.end \x3d end;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 167666463;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.core.Subvec.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Subvec.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((n \x3c (0))){\nreturn null;\n} else {\nvar idx \x3d (self__.start + n);\nif((idx \x3c self__.end)){\nreturn (new cljs.core.MapEntry(n,cljs.core._lookup(self__.v,idx),null));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.core.Subvec.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.Subvec.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.Subvec.prototype.indexOf \x3d (function() {\nvar G__24802 \x3d null;\nvar G__24802__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__24802__2 \x3d (function (x,start__$1){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1);\n});\nG__24802 \x3d function(x,start__$1){\nswitch(arguments.length){\ncase 1:\nreturn G__24802__1.call(this,x);\ncase 2:\nreturn G__24802__2.call(this,x,start__$1);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24802.cljs$core$IFn$_invoke$arity$1 \x3d G__24802__1;\nG__24802.cljs$core$IFn$_invoke$arity$2 \x3d G__24802__2;\nreturn G__24802;\n})()\n);\n\n(cljs.core.Subvec.prototype.lastIndexOf \x3d (function() {\nvar G__24806 \x3d null;\nvar G__24806__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__24806__2 \x3d (function (x,start__$1){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1);\n});\nG__24806 \x3d function(x,start__$1){\nswitch(arguments.length){\ncase 1:\nreturn G__24806__1.call(this,x);\ncase 2:\nreturn G__24806__2.call(this,x,start__$1);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24806.cljs$core$IFn$_invoke$arity$1 \x3d G__24806__1;\nG__24806.cljs$core$IFn$_invoke$arity$2 \x3d G__24806__2;\nreturn G__24806;\n})()\n);\n\n(cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,k,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(typeof k \x3d\x3d\x3d \x27number\x27){\nreturn coll__$1.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (coll,f,init){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar i \x3d self__.start;\nvar j \x3d (0);\nvar init__$1 \x3d init;\nwhile(true){\nif((i \x3c self__.end)){\nvar init__$2 \x3d (function (){var G__18245 \x3d init__$1;\nvar G__18246 \x3d j;\nvar G__18247 \x3d cljs.core._nth(self__.v,i);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18245,G__18246,G__18247) : f.call(null, G__18245,G__18246,G__18247));\n})();\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn cljs.core.deref(init__$2);\n} else {\nvar G__24836 \x3d (i + (1));\nvar G__24837 \x3d (j + (1));\nvar G__24838 \x3d init__$2;\ni \x3d G__24836;\nj \x3d G__24837;\ninit__$1 \x3d G__24838;\ncontinue;\n}\n} else {\nreturn init__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((((n \x3c (0))) || ((self__.end \x3c\x3d (self__.start + n))))){\nreturn cljs.core.vector_index_out_of_bounds(n,(self__.end - self__.start));\n} else {\nreturn cljs.core._nth(self__.v,(self__.start + n));\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (coll,n,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((((n \x3c (0))) || ((self__.end \x3c\x3d (self__.start + n))))){\nreturn not_found;\n} else {\nreturn cljs.core._nth(self__.v,(self__.start + n),not_found);\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IVector$_assoc_n$arity$3 \x3d (function (coll,n,val){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar v_pos \x3d (self__.start + n);\nif((((n \x3c (0))) || (((self__.end + (1)) \x3c\x3d v_pos)))){\nthrow (new Error([\x22Index \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),\x22 out of bounds [0,\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll__$1.cljs$core$ICounted$_count$arity$1(null, )),\x22]\x22].join(\x27\x27)));\n} else {\nvar G__18248 \x3d self__.meta;\nvar G__18249 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.v,v_pos,val);\nvar G__18250 \x3d self__.start;\nvar G__18251 \x3d (function (){var x__5087__auto__ \x3d self__.end;\nvar y__5088__auto__ \x3d (v_pos + (1));\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})();\nvar G__18252 \x3d null;\nreturn (cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5 ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(G__18248,G__18249,G__18250,G__18251,G__18252) : cljs.core.build_subvec.call(null, G__18248,G__18249,G__18250,G__18251,G__18252));\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((((!((self__.v \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d self__.v.cljs$core$APersistentVector$))))?true:false):false)){\nreturn cljs.core.ranged_iterator(self__.v,self__.start,self__.end);\n} else {\nreturn cljs.core.seq_iter(coll__$1);\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.Subvec(self__.meta,self__.v,self__.start,self__.end,self__.__hash));\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (self__.end - self__.start);\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.start \x3d\x3d\x3d self__.end)){\nreturn null;\n} else {\nreturn cljs.core._nth(self__.v,(self__.end - (1)));\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.start \x3d\x3d\x3d self__.end)){\nthrow (new Error(\x22Can\x27t pop empty vector\x22));\n} else {\nvar G__18254 \x3d self__.meta;\nvar G__18255 \x3d self__.v;\nvar G__18256 \x3d self__.start;\nvar G__18257 \x3d (self__.end - (1));\nvar G__18258 \x3d null;\nreturn (cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5 ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(G__18254,G__18255,G__18256,G__18257,G__18258) : cljs.core.build_subvec.call(null, G__18254,G__18255,G__18256,G__18257,G__18258));\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((!((self__.start \x3d\x3d\x3d self__.end)))){\nreturn (new cljs.core.RSeq(coll__$1,((self__.end - self__.start) - (1)),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.PersistentVector.EMPTY,self__.meta);\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((((!((self__.v \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d self__.v.cljs$core$APersistentVector$))))?true:false):false)){\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4(self__.v,f,self__.start,self__.end);\n} else {\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(coll__$1,f);\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,init){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((((!((self__.v \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d self__.v.cljs$core$APersistentVector$))))?true:false):false)){\nreturn cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5(self__.v,f,init,self__.start,self__.end);\n} else {\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(coll__$1,f,init);\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (coll,key,val){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(typeof key \x3d\x3d\x3d \x27number\x27){\nreturn coll__$1.cljs$core$IVector$_assoc_n$arity$3(null, key,val);\n} else {\nthrow (new Error(\x22Subvec\x27s key for assoc must be a number.\x22));\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (coll,key){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.integer_QMARK_(key)){\nreturn ((((0) \x3c\x3d key)) \x26\x26 ((key \x3c (self__.end - self__.start))));\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar subvec_seq \x3d (function cljs$core$subvec_seq(i){\nif((i \x3d\x3d\x3d self__.end)){\nreturn null;\n} else {\nreturn cljs.core.cons(cljs.core._nth(self__.v,i),(new cljs.core.LazySeq(null,(function (){\nreturn cljs$core$subvec_seq((i + (1)));\n}),null,null)));\n}\n});\nreturn subvec_seq(self__.start);\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5 ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(new_meta,self__.v,self__.start,self__.end,self__.__hash) : cljs.core.build_subvec.call(null, new_meta,self__.v,self__.start,self__.end,self__.__hash));\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar G__18261 \x3d self__.meta;\nvar G__18262 \x3d cljs.core._assoc_n(self__.v,self__.end,o);\nvar G__18263 \x3d self__.start;\nvar G__18264 \x3d (self__.end + (1));\nvar G__18265 \x3d null;\nreturn (cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5 ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(G__18261,G__18262,G__18263,G__18264,G__18265) : cljs.core.build_subvec.call(null, G__18261,G__18262,G__18263,G__18264,G__18265));\n}));\n\n(cljs.core.Subvec.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18266 \x3d (arguments.length - (1));\nswitch (G__18266) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.Subvec.prototype.apply \x3d (function (self__,args18244){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18244)));\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$IIndexed$_nth$arity$2(null, k);\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n}));\n\n(cljs.core.Subvec.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22v\x22,\x22v\x22,1661996586,null),new cljs.core.Symbol(null,\x22start\x22,\x22start\x22,1285322546,null),new cljs.core.Symbol(null,\x22end\x22,\x22end\x22,1372345569,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Subvec.cljs$lang$type \x3d true);\n\n(cljs.core.Subvec.cljs$lang$ctorStr \x3d \x22cljs.core/Subvec\x22);\n\n(cljs.core.Subvec.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Subvec\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Subvec.\n */\ncljs.core.__GT_Subvec \x3d (function cljs$core$__GT_Subvec(meta,v,start,end,__hash){\nreturn (new cljs.core.Subvec(meta,v,start,end,__hash));\n});\n\n(cljs.core.Subvec.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.build_subvec \x3d (function cljs$core$build_subvec(meta,v,start,end,__hash){\nwhile(true){\nif((v instanceof cljs.core.Subvec)){\nvar G__24905 \x3d meta;\nvar G__24906 \x3d v.v;\nvar G__24907 \x3d (v.start + start);\nvar G__24908 \x3d (v.start + end);\nvar G__24909 \x3d __hash;\nmeta \x3d G__24905;\nv \x3d G__24906;\nstart \x3d G__24907;\nend \x3d G__24908;\n__hash \x3d G__24909;\ncontinue;\n} else {\nif(cljs.core.vector_QMARK_(v)){\n} else {\nthrow (new Error(\x22v must satisfy IVector\x22));\n}\n\nif((((start \x3c (0))) || ((((end \x3c start)) || ((end \x3e cljs.core.count(v))))))){\nthrow (new Error(\x22Index out of bounds\x22));\n} else {\n}\n\nreturn (new cljs.core.Subvec(meta,v,start,end,__hash));\n}\nbreak;\n}\n});\n/**\n * Returns a persistent vector of the items in vector from\n *   start (inclusive) to end (exclusive).  If end is not supplied,\n *   defaults to (count vector). This operation is O(1) and very fast, as\n *   the resulting vector shares structure with the original and no\n *   trimming is done.\n */\ncljs.core.subvec \x3d (function cljs$core$subvec(var_args){\nvar G__18268 \x3d arguments.length;\nswitch (G__18268) {\ncase 2:\nreturn cljs.core.subvec.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.subvec.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.subvec.cljs$core$IFn$_invoke$arity$2 \x3d (function (v,start){\nreturn cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(v,start,cljs.core.count(v));\n}));\n\n(cljs.core.subvec.cljs$core$IFn$_invoke$arity$3 \x3d (function (v,start,end){\nif((((!((start \x3d\x3d null)))) \x26\x26 ((!((end \x3d\x3d null)))))){\n} else {\nthrow (new Error(\x22Assert failed: (and (not (nil? start)) (not (nil? end)))\x22));\n}\n\nreturn cljs.core.build_subvec(null,v,(start | (0)),(end | (0)),null);\n}));\n\n(cljs.core.subvec.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.tv_ensure_editable \x3d (function cljs$core$tv_ensure_editable(edit,node){\nif((edit \x3d\x3d\x3d node.edit)){\nreturn node;\n} else {\nreturn (new cljs.core.VectorNode(edit,cljs.core.aclone(node.arr)));\n}\n});\ncljs.core.tv_editable_root \x3d (function cljs$core$tv_editable_root(node){\nreturn (new cljs.core.VectorNode(({}),cljs.core.aclone(node.arr)));\n});\ncljs.core.tv_editable_tail \x3d (function cljs$core$tv_editable_tail(tl){\nvar ret \x3d [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];\ncljs.core.array_copy(tl,(0),ret,(0),tl.length);\n\nreturn ret;\n});\ncljs.core.tv_push_tail \x3d (function cljs$core$tv_push_tail(tv,level,parent,tail_node){\nvar ret \x3d cljs.core.tv_ensure_editable(tv.root.edit,parent);\nvar subidx \x3d (((tv.cnt - (1)) \x3e\x3e\x3e level) \x26 (31));\ncljs.core.pv_aset(ret,subidx,(((level \x3d\x3d\x3d (5)))?tail_node:(function (){var child \x3d cljs.core.pv_aget(ret,subidx);\nif((!((child \x3d\x3d null)))){\nvar G__18271 \x3d tv;\nvar G__18272 \x3d (level - (5));\nvar G__18273 \x3d child;\nvar G__18274 \x3d tail_node;\nreturn (cljs.core.tv_push_tail.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tv_push_tail.cljs$core$IFn$_invoke$arity$4(G__18271,G__18272,G__18273,G__18274) : cljs.core.tv_push_tail.call(null, G__18271,G__18272,G__18273,G__18274));\n} else {\nreturn cljs.core.new_path(tv.root.edit,(level - (5)),tail_node);\n}\n})()));\n\nreturn ret;\n});\ncljs.core.tv_pop_tail \x3d (function cljs$core$tv_pop_tail(tv,level,node){\nvar node__$1 \x3d cljs.core.tv_ensure_editable(tv.root.edit,node);\nvar subidx \x3d (((tv.cnt - (2)) \x3e\x3e\x3e level) \x26 (31));\nif((level \x3e (5))){\nvar new_child \x3d (function (){var G__18275 \x3d tv;\nvar G__18276 \x3d (level - (5));\nvar G__18277 \x3d cljs.core.pv_aget(node__$1,subidx);\nreturn (cljs.core.tv_pop_tail.cljs$core$IFn$_invoke$arity$3 ? cljs.core.tv_pop_tail.cljs$core$IFn$_invoke$arity$3(G__18275,G__18276,G__18277) : cljs.core.tv_pop_tail.call(null, G__18275,G__18276,G__18277));\n})();\nif((((new_child \x3d\x3d null)) \x26\x26 ((subidx \x3d\x3d\x3d (0))))){\nreturn null;\n} else {\ncljs.core.pv_aset(node__$1,subidx,new_child);\n\nreturn node__$1;\n}\n} else {\nif((subidx \x3d\x3d\x3d (0))){\nreturn null;\n} else {\ncljs.core.pv_aset(node__$1,subidx,null);\n\nreturn node__$1;\n\n}\n}\n});\ncljs.core.unchecked_editable_array_for \x3d (function cljs$core$unchecked_editable_array_for(tv,i){\nif((i \x3e\x3d cljs.core.tail_off(tv))){\nreturn tv.tail;\n} else {\nvar root \x3d tv.root;\nvar node \x3d root;\nvar level \x3d tv.shift;\nwhile(true){\nif((level \x3e (0))){\nvar G__24924 \x3d cljs.core.tv_ensure_editable(root.edit,cljs.core.pv_aget(node,((i \x3e\x3e\x3e level) \x26 (31))));\nvar G__24925 \x3d (level - (5));\nnode \x3d G__24924;\nlevel \x3d G__24925;\ncontinue;\n} else {\nreturn node.arr;\n}\nbreak;\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ITransientCollection}\n * @implements {cljs.core.ITransientVector}\n * @implements {cljs.core.ITransientAssociative}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.TransientVector \x3d (function (cnt,shift,root,tail){\nthis.cnt \x3d cnt;\nthis.shift \x3d shift;\nthis.root \x3d root;\nthis.tail \x3d tail;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 88;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 275;\n});\n(cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 \x3d (function (tcoll,o){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.root.edit){\nif(((self__.cnt - cljs.core.tail_off(tcoll__$1)) \x3c (32))){\n(self__.tail[(self__.cnt \x26 (31))] \x3d o);\n\n(self__.cnt \x3d (self__.cnt + (1)));\n\nreturn tcoll__$1;\n} else {\nvar tail_node \x3d (new cljs.core.VectorNode(self__.root.edit,self__.tail));\nvar new_tail \x3d [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];\n(new_tail[(0)] \x3d o);\n\n(self__.tail \x3d new_tail);\n\nif(((self__.cnt \x3e\x3e\x3e (5)) \x3e ((1) \x3c\x3c self__.shift))){\nvar new_root_array \x3d [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];\nvar new_shift \x3d (self__.shift + (5));\n(new_root_array[(0)] \x3d self__.root);\n\n(new_root_array[(1)] \x3d cljs.core.new_path(self__.root.edit,self__.shift,tail_node));\n\n(self__.root \x3d (new cljs.core.VectorNode(self__.root.edit,new_root_array)));\n\n(self__.shift \x3d new_shift);\n\n(self__.cnt \x3d (self__.cnt + (1)));\n\nreturn tcoll__$1;\n} else {\nvar new_root \x3d cljs.core.tv_push_tail(tcoll__$1,self__.shift,self__.root,tail_node);\n(self__.root \x3d new_root);\n\n(self__.cnt \x3d (self__.cnt + (1)));\n\nreturn tcoll__$1;\n}\n}\n} else {\nthrow (new Error(\x22conj! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 \x3d (function (tcoll){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.root.edit){\n(self__.root.edit \x3d null);\n\nvar len \x3d (self__.cnt - cljs.core.tail_off(tcoll__$1));\nvar trimmed_tail \x3d (new Array(len));\ncljs.core.array_copy(self__.tail,(0),trimmed_tail,(0),len);\n\nreturn (new cljs.core.PersistentVector(null,self__.cnt,self__.shift,self__.root,trimmed_tail,null));\n} else {\nthrow (new Error(\x22persistent! called twice\x22));\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 \x3d (function (tcoll,key,val){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(typeof key \x3d\x3d\x3d \x27number\x27){\nreturn tcoll__$1.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(null, key,val);\n} else {\nthrow (new Error(\x22TransientVector\x27s key for assoc! must be a number.\x22));\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3 \x3d (function (tcoll,n,val){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.root.edit){\nif(((((0) \x3c\x3d n)) \x26\x26 ((n \x3c self__.cnt)))){\nif((cljs.core.tail_off(tcoll__$1) \x3c\x3d n)){\n(self__.tail[(n \x26 (31))] \x3d val);\n\nreturn tcoll__$1;\n} else {\nvar new_root \x3d (function cljs$core$go(level,node){\nvar node__$1 \x3d cljs.core.tv_ensure_editable(self__.root.edit,node);\nif((level \x3d\x3d\x3d (0))){\ncljs.core.pv_aset(node__$1,(n \x26 (31)),val);\n\nreturn node__$1;\n} else {\nvar subidx \x3d ((n \x3e\x3e\x3e level) \x26 (31));\ncljs.core.pv_aset(node__$1,subidx,cljs$core$go((level - (5)),cljs.core.pv_aget(node__$1,subidx)));\n\nreturn node__$1;\n}\n})(self__.shift,self__.root);\n(self__.root \x3d new_root);\n\nreturn tcoll__$1;\n}\n} else {\nif((n \x3d\x3d\x3d self__.cnt)){\nreturn tcoll__$1.cljs$core$ITransientCollection$_conj_BANG_$arity$2(null, val);\n} else {\nthrow (new Error([\x22Index \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),\x22 out of bounds for TransientVector of length\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.cnt)].join(\x27\x27)));\n\n}\n}\n} else {\nthrow (new Error(\x22assoc! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_pop_BANG_$arity$1 \x3d (function (tcoll){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.root.edit){\nif((self__.cnt \x3d\x3d\x3d (0))){\nthrow (new Error(\x22Can\x27t pop empty vector\x22));\n} else {\nif(((1) \x3d\x3d\x3d self__.cnt)){\n(self__.cnt \x3d (0));\n\nreturn tcoll__$1;\n} else {\nif((((self__.cnt - (1)) \x26 (31)) \x3e (0))){\n(self__.cnt \x3d (self__.cnt - (1)));\n\nreturn tcoll__$1;\n} else {\nvar new_tail \x3d cljs.core.unchecked_editable_array_for(tcoll__$1,(self__.cnt - (2)));\nvar new_root \x3d (function (){var nr \x3d cljs.core.tv_pop_tail(tcoll__$1,self__.shift,self__.root);\nif((!((nr \x3d\x3d null)))){\nreturn nr;\n} else {\nreturn (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]));\n}\n})();\nif(((((5) \x3c self__.shift)) \x26\x26 ((cljs.core.pv_aget(new_root,(1)) \x3d\x3d null)))){\nvar new_root__$1 \x3d cljs.core.tv_ensure_editable(self__.root.edit,cljs.core.pv_aget(new_root,(0)));\n(self__.root \x3d new_root__$1);\n\n(self__.shift \x3d (self__.shift - (5)));\n\n(self__.cnt \x3d (self__.cnt - (1)));\n\n(self__.tail \x3d new_tail);\n\nreturn tcoll__$1;\n} else {\n(self__.root \x3d new_root);\n\n(self__.cnt \x3d (self__.cnt - (1)));\n\n(self__.tail \x3d new_tail);\n\nreturn tcoll__$1;\n}\n\n}\n}\n}\n} else {\nthrow (new Error(\x22pop! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(self__.root.edit){\nreturn self__.cnt;\n} else {\nthrow (new Error(\x22count after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(self__.root.edit){\nreturn (cljs.core.array_for(coll__$1,n)[(n \x26 (31))]);\n} else {\nthrow (new Error(\x22nth after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (coll,n,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((((0) \x3c\x3d n)) \x26\x26 ((n \x3c self__.cnt)))){\nreturn coll__$1.cljs$core$IIndexed$_nth$arity$2(null, n);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,k,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((!(self__.root.edit))){\nthrow (new Error(\x22lookup after persistent!\x22));\n} else {\nif(typeof k \x3d\x3d\x3d \x27number\x27){\nreturn coll__$1.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n} else {\nreturn not_found;\n\n}\n}\n}));\n\n(cljs.core.TransientVector.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18279 \x3d (arguments.length - (1));\nswitch (G__18279) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.TransientVector.prototype.apply \x3d (function (self__,args18278){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18278)));\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$2(null, k);\n}));\n\n(cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.TransientVector.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22shift\x22,\x22shift\x22,-1657295705,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22root\x22,\x22root\x22,1191874074,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22tail\x22,\x22tail\x22,494507963,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.TransientVector.cljs$lang$type \x3d true);\n\n(cljs.core.TransientVector.cljs$lang$ctorStr \x3d \x22cljs.core/TransientVector\x22);\n\n(cljs.core.TransientVector.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/TransientVector\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/TransientVector.\n */\ncljs.core.__GT_TransientVector \x3d (function cljs$core$__GT_TransientVector(cnt,shift,root,tail){\nreturn (new cljs.core.TransientVector(cnt,shift,root,tail));\n});\n\n\n/**\n* @constructor\n*/\ncljs.core.PersistentQueueIter \x3d (function (fseq,riter){\nthis.fseq \x3d fseq;\nthis.riter \x3d riter;\n});\n(cljs.core.PersistentQueueIter.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar or__5002__auto__ \x3d (((!((self__.fseq \x3d\x3d null)))) \x26\x26 (cljs.core.seq(self__.fseq)));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d (!((self__.riter \x3d\x3d null)));\nif(and__5000__auto__){\nreturn self__.riter.hasNext();\n} else {\nreturn and__5000__auto__;\n}\n}\n}));\n\n(cljs.core.PersistentQueueIter.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((!((self__.fseq \x3d\x3d null)))){\nvar ret \x3d cljs.core.first(self__.fseq);\n(self__.fseq \x3d cljs.core.next(self__.fseq));\n\nreturn ret;\n} else {\nif((((!((self__.riter \x3d\x3d null)))) \x26\x26 (self__.riter.hasNext()))){\nreturn self__.riter.next();\n} else {\nthrow (new Error(\x22No such element\x22));\n\n}\n}\n}));\n\n(cljs.core.PersistentQueueIter.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.PersistentQueueIter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22fseq\x22,\x22fseq\x22,-1466412450,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22riter\x22,\x22riter\x22,-237834262,null)], null);\n}));\n\n(cljs.core.PersistentQueueIter.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentQueueIter.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentQueueIter\x22);\n\n(cljs.core.PersistentQueueIter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentQueueIter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentQueueIter.\n */\ncljs.core.__GT_PersistentQueueIter \x3d (function cljs$core$__GT_PersistentQueueIter(fseq,riter){\nreturn (new cljs.core.PersistentQueueIter(fseq,riter));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.PersistentQueueSeq \x3d (function (meta,front,rear,__hash){\nthis.meta \x3d meta;\nthis.front \x3d front;\nthis.rear \x3d rear;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 31850700;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.PersistentQueueSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.indexOf \x3d (function() {\nvar G__24961 \x3d null;\nvar G__24961__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__24961__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24961 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24961__1.call(this,x);\ncase 2:\nreturn G__24961__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24961.cljs$core$IFn$_invoke$arity$1 \x3d G__24961__1;\nG__24961.cljs$core$IFn$_invoke$arity$2 \x3d G__24961__2;\nreturn G__24961;\n})()\n);\n\n(cljs.core.PersistentQueueSeq.prototype.lastIndexOf \x3d (function() {\nvar G__24964 \x3d null;\nvar G__24964__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__24964__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24964 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24964__1.call(this,x);\ncase 2:\nreturn G__24964__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24964.cljs$core$IFn$_invoke$arity$1 \x3d G__24964__1;\nG__24964.cljs$core$IFn$_invoke$arity$2 \x3d G__24964__2;\nreturn G__24964;\n})()\n);\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar temp__5802__auto__ \x3d cljs.core.next(self__.front);\nif(temp__5802__auto__){\nvar f1 \x3d temp__5802__auto__;\nreturn (new cljs.core.PersistentQueueSeq(self__.meta,f1,self__.rear,null));\n} else {\nif((!((self__.rear \x3d\x3d null)))){\nreturn (new cljs.core.PersistentQueueSeq(self__.meta,self__.rear,null,null));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta);\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.first(self__.front);\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar temp__5802__auto__ \x3d cljs.core.next(self__.front);\nif(temp__5802__auto__){\nvar f1 \x3d temp__5802__auto__;\nreturn (new cljs.core.PersistentQueueSeq(self__.meta,f1,self__.rear,null));\n} else {\nif((self__.rear \x3d\x3d null)){\nreturn coll__$1.cljs$core$IEmptyableCollection$_empty$arity$1(null, );\n} else {\nreturn (new cljs.core.PersistentQueueSeq(self__.meta,self__.rear,null,null));\n}\n}\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentQueueSeq(new_meta,self__.front,self__.rear,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.PersistentQueueSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22front\x22,\x22front\x22,117022539,null),new cljs.core.Symbol(null,\x22rear\x22,\x22rear\x22,-900164830,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentQueueSeq.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentQueueSeq.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentQueueSeq\x22);\n\n(cljs.core.PersistentQueueSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentQueueSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentQueueSeq.\n */\ncljs.core.__GT_PersistentQueueSeq \x3d (function cljs$core$__GT_PersistentQueueSeq(meta,front,rear,__hash){\nreturn (new cljs.core.PersistentQueueSeq(meta,front,rear,__hash));\n});\n\n(cljs.core.PersistentQueueSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.PersistentQueue \x3d (function (meta,count,front,rear,__hash){\nthis.meta \x3d meta;\nthis.count \x3d count;\nthis.front \x3d front;\nthis.rear \x3d rear;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 31858766;\n});\n(cljs.core.PersistentQueue.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentQueue.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentQueue.prototype.indexOf \x3d (function() {\nvar G__24967 \x3d null;\nvar G__24967__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__24967__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24967 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24967__1.call(this,x);\ncase 2:\nreturn G__24967__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24967.cljs$core$IFn$_invoke$arity$1 \x3d G__24967__1;\nG__24967.cljs$core$IFn$_invoke$arity$2 \x3d G__24967__2;\nreturn G__24967;\n})()\n);\n\n(cljs.core.PersistentQueue.prototype.lastIndexOf \x3d (function() {\nvar G__24968 \x3d null;\nvar G__24968__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn 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)));\n});\nvar G__24968__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__24968 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__24968__1.call(this,x);\ncase 2:\nreturn G__24968__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__24968.cljs$core$IFn$_invoke$arity$1 \x3d G__24968__1;\nG__24968.cljs$core$IFn$_invoke$arity$2 \x3d G__24968__2;\nreturn G__24968;\n})()\n);\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentQueueIter(self__.front,cljs.core._iterator(self__.rear)));\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentQueue(self__.meta,self__.count,self__.front,self__.rear,self__.__hash));\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.count;\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.first(self__.front);\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.truth_(self__.front)){\nvar temp__5802__auto__ \x3d cljs.core.next(self__.front);\nif(temp__5802__auto__){\nvar f1 \x3d temp__5802__auto__;\nreturn (new cljs.core.PersistentQueue(self__.meta,(self__.count - (1)),f1,self__.rear,null));\n} else {\nreturn (new cljs.core.PersistentQueue(self__.meta,(self__.count - (1)),cljs.core.seq(self__.rear),cljs.core.PersistentVector.EMPTY,null));\n}\n} else {\nreturn coll__$1;\n}\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.PersistentQueue.EMPTY,self__.meta);\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.first(self__.front);\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.rest(cljs.core.seq(coll__$1));\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar rear__$1 \x3d cljs.core.seq(self__.rear);\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d self__.front;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn rear__$1;\n}\n})())){\nreturn (new cljs.core.PersistentQueueSeq(null,self__.front,cljs.core.seq(rear__$1),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentQueue(new_meta,self__.count,self__.front,self__.rear,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.truth_(self__.front)){\nreturn (new cljs.core.PersistentQueue(self__.meta,(self__.count + (1)),self__.front,cljs.core.conj.cljs$core$IFn$_invoke$arity$2((function (){var or__5002__auto__ \x3d self__.rear;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.PersistentVector.EMPTY;\n}\n})(),o),null));\n} else {\nreturn (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));\n}\n}));\n\n(cljs.core.PersistentQueue.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22count\x22,\x22count\x22,-514511684,null),new cljs.core.Symbol(null,\x22front\x22,\x22front\x22,117022539,null),new cljs.core.Symbol(null,\x22rear\x22,\x22rear\x22,-900164830,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentQueue.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentQueue.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentQueue\x22);\n\n(cljs.core.PersistentQueue.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentQueue\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentQueue.\n */\ncljs.core.__GT_PersistentQueue \x3d (function cljs$core$__GT_PersistentQueue(meta,count,front,rear,__hash){\nreturn (new cljs.core.PersistentQueue(meta,count,front,rear,__hash));\n});\n\n(cljs.core.PersistentQueue.EMPTY \x3d (new cljs.core.PersistentQueue(null,(0),null,cljs.core.PersistentVector.EMPTY,cljs.core.empty_ordered_hash)));\n(cljs.core.PersistentQueue.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n*/\ncljs.core.NeverEquiv \x3d (function (){\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2097152;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.NeverEquiv.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.NeverEquiv.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (o,other){\nvar self__ \x3d this;\nvar o__$1 \x3d this;\nreturn false;\n}));\n\n(cljs.core.NeverEquiv.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cljs.core.NeverEquiv.cljs$lang$type \x3d true);\n\n(cljs.core.NeverEquiv.cljs$lang$ctorStr \x3d \x22cljs.core/NeverEquiv\x22);\n\n(cljs.core.NeverEquiv.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/NeverEquiv\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/NeverEquiv.\n */\ncljs.core.__GT_NeverEquiv \x3d (function cljs$core$__GT_NeverEquiv(){\nreturn (new cljs.core.NeverEquiv());\n});\n\ncljs.core.never_equiv \x3d (new cljs.core.NeverEquiv());\n/**\n * Test map equivalence. Returns true if x equals y, otherwise returns false.\n */\ncljs.core.equiv_map \x3d (function cljs$core$equiv_map(x,y){\nreturn cljs.core.boolean$(((((cljs.core.map_QMARK_(y)) \x26\x26 ((!(cljs.core.record_QMARK_(y))))))?(((cljs.core.count(x) \x3d\x3d\x3d cljs.core.count(y)))?(((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition0$ \x26 (1048576))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IKVReduce$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IKVReduce,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IKVReduce,x)))?cljs.core.reduce_kv((function (_,k,v){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(y,k,cljs.core.never_equiv),v)){\nreturn true;\n} else {\nreturn cljs.core.reduced(false);\n}\n}),true,x):cljs.core.every_QMARK_((function (xkv){\nreturn 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));\n}),x)):null):null));\n});\ncljs.core.scan_array \x3d (function cljs$core$scan_array(incr,k,array){\nvar len \x3d array.length;\nvar i \x3d (0);\nwhile(true){\nif((i \x3c len)){\nif((k \x3d\x3d\x3d (array[i]))){\nreturn i;\n} else {\nvar G__24969 \x3d (i + incr);\ni \x3d G__24969;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});\ncljs.core.obj_map_compare_keys \x3d (function cljs$core$obj_map_compare_keys(a,b){\nvar a__$1 \x3d cljs.core.hash(a);\nvar b__$1 \x3d cljs.core.hash(b);\nif((a__$1 \x3c b__$1)){\nreturn (-1);\n} else {\nif((a__$1 \x3e b__$1)){\nreturn (1);\n} else {\nreturn (0);\n\n}\n}\n});\ncljs.core.obj_map__GT_hash_map \x3d (function cljs$core$obj_map__GT_hash_map(m,k,v){\nvar ks \x3d m.keys;\nvar len \x3d ks.length;\nvar so \x3d m.strobj;\nvar mm \x3d cljs.core.meta(m);\nvar i \x3d (0);\nvar out \x3d cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY);\nwhile(true){\nif((i \x3c len)){\nvar k__$1 \x3d (ks[i]);\nvar G__24970 \x3d (i + (1));\nvar G__24971 \x3d cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,k__$1,cljs.core.goog$module$goog$object.get(so,k__$1));\ni \x3d G__24970;\nout \x3d G__24971;\ncontinue;\n} else {\nreturn cljs.core._with_meta(cljs.core.persistent_BANG_(cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,k,v)),mm);\n}\nbreak;\n}\n});\ncljs.core.obj_clone \x3d (function cljs$core$obj_clone(obj,ks){\nvar new_obj \x3d ({});\nvar l \x3d ks.length;\nvar i_24973 \x3d (0);\nwhile(true){\nif((i_24973 \x3c l)){\nvar k_24974 \x3d (ks[i_24973]);\ncljs.core.goog$module$goog$object.set(new_obj,k_24974,cljs.core.goog$module$goog$object.get(obj,k_24974));\n\nvar G__24976 \x3d (i_24973 + (1));\ni_24973 \x3d G__24976;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn new_obj;\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEditableCollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.ObjMap \x3d (function (meta,keys,strobj,update_count,__hash){\nthis.meta \x3d meta;\nthis.keys \x3d keys;\nthis.strobj \x3d strobj;\nthis.update_count \x3d update_count;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 16123663;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 4;\n});\n(cljs.core.ObjMap.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ObjMap.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((typeof k \x3d\x3d\x3d \x27string\x27) \x26\x26 ((!((cljs.core.scan_array((1),k,self__.keys) \x3d\x3d null)))))){\nreturn (new cljs.core.MapEntry(k,(self__.strobj[k]),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.ObjMap.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.ObjMap.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,k,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((typeof k \x3d\x3d\x3d \x27string\x27) \x26\x26 ((!((cljs.core.scan_array((1),k,self__.keys) \x3d\x3d null)))))){\nreturn (self__.strobj[k]);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (coll,f,init){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar len \x3d self__.keys.length;\nvar keys__$1 \x3d self__.keys.sort(cljs.core.obj_map_compare_keys);\nvar init__$1 \x3d init;\nwhile(true){\nif(cljs.core.seq(keys__$1)){\nvar k \x3d cljs.core.first(keys__$1);\nvar init__$2 \x3d (function (){var G__18285 \x3d init__$1;\nvar G__18286 \x3d k;\nvar G__18287 \x3d (self__.strobj[k]);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18285,G__18286,G__18287) : f.call(null, G__18285,G__18286,G__18287));\n})();\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn cljs.core.deref(init__$2);\n} else {\nvar G__24979 \x3d cljs.core.rest(keys__$1);\nvar G__24980 \x3d init__$2;\nkeys__$1 \x3d G__24979;\ninit__$1 \x3d G__24980;\ncontinue;\n}\n} else {\nreturn init__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.keys.length;\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_unordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_map(coll__$1,other);\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.transient$(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentHashMap.EMPTY,coll__$1));\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.ObjMap.EMPTY,self__.meta);\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((typeof k \x3d\x3d\x3d \x27string\x27) \x26\x26 ((!((cljs.core.scan_array((1),k,self__.keys) \x3d\x3d null)))))){\nvar new_keys \x3d cljs.core.aclone(self__.keys);\nvar new_strobj \x3d cljs.core.obj_clone(self__.strobj,self__.keys);\nnew_keys.splice(cljs.core.scan_array((1),k,new_keys),(1));\n\ndelete new_strobj[k];\n\nreturn (new cljs.core.ObjMap(self__.meta,new_keys,new_strobj,(self__.update_count + (1)),null));\n} else {\nreturn coll__$1;\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (coll,k,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(typeof k \x3d\x3d\x3d \x27string\x27){\nif((((self__.update_count \x3e cljs.core.ObjMap.HASHMAP_THRESHOLD)) || ((self__.keys.length \x3e\x3d cljs.core.ObjMap.HASHMAP_THRESHOLD)))){\nreturn cljs.core.obj_map__GT_hash_map(coll__$1,k,v);\n} else {\nif((!((cljs.core.scan_array((1),k,self__.keys) \x3d\x3d null)))){\nvar new_strobj \x3d cljs.core.obj_clone(self__.strobj,self__.keys);\ncljs.core.goog$module$goog$object.set(new_strobj,k,v);\n\nreturn (new cljs.core.ObjMap(self__.meta,self__.keys,new_strobj,(self__.update_count + (1)),null));\n} else {\nvar new_strobj \x3d cljs.core.obj_clone(self__.strobj,self__.keys);\nvar new_keys \x3d cljs.core.aclone(self__.keys);\ncljs.core.goog$module$goog$object.set(new_strobj,k,v);\n\nnew_keys.push(k);\n\nreturn (new cljs.core.ObjMap(self__.meta,new_keys,new_strobj,(self__.update_count + (1)),null));\n}\n}\n} else {\nreturn cljs.core.obj_map__GT_hash_map(coll__$1,k,v);\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((typeof k \x3d\x3d\x3d \x27string\x27) \x26\x26 ((!((cljs.core.scan_array((1),k,self__.keys) \x3d\x3d null)))))){\nreturn true;\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.keys.length \x3e (0))){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__18283_SHARP_){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[p1__18283_SHARP_,(self__.strobj[p1__18283_SHARP_])],null));\n}),self__.keys.sort(cljs.core.obj_map_compare_keys));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.ObjMap(new_meta,self__.keys,self__.strobj,self__.update_count,self__.__hash));\n}\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,entry){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry)){\nreturn coll__$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry,(0)),cljs.core._nth(entry,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,coll__$1,entry);\n}\n}));\n\n(cljs.core.ObjMap.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18288 \x3d (arguments.length - (1));\nswitch (G__18288) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.ObjMap.prototype.apply \x3d (function (self__,args18284){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18284)));\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$2(null, k);\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.ObjMap.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22keys\x22,\x22keys\x22,-1586012071,null),new cljs.core.Symbol(null,\x22strobj\x22,\x22strobj\x22,1088091283,null),new cljs.core.Symbol(null,\x22update-count\x22,\x22update-count\x22,-411982269,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ObjMap.cljs$lang$type \x3d true);\n\n(cljs.core.ObjMap.cljs$lang$ctorStr \x3d \x22cljs.core/ObjMap\x22);\n\n(cljs.core.ObjMap.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ObjMap\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ObjMap.\n */\ncljs.core.__GT_ObjMap \x3d (function cljs$core$__GT_ObjMap(meta,keys,strobj,update_count,__hash){\nreturn (new cljs.core.ObjMap(meta,keys,strobj,update_count,__hash));\n});\n\n(cljs.core.ObjMap.EMPTY \x3d (new cljs.core.ObjMap(null,[],({}),(0),cljs.core.empty_unordered_hash)));\n(cljs.core.ObjMap.HASHMAP_THRESHOLD \x3d (8));\n(cljs.core.ObjMap.fromObject \x3d (function (ks,obj){\nreturn (new cljs.core.ObjMap(null,ks,obj,(0),null));\n}));\n\n/**\n* @constructor\n*/\ncljs.core.RecordIter \x3d (function (i,record,base_count,fields,ext_map_iter){\nthis.i \x3d i;\nthis.record \x3d record;\nthis.base_count \x3d base_count;\nthis.fields \x3d fields;\nthis.ext_map_iter \x3d ext_map_iter;\n});\n(cljs.core.RecordIter.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar or__5002__auto__ \x3d (self__.i \x3c self__.base_count);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn self__.ext_map_iter.hasNext();\n}\n}));\n\n(cljs.core.RecordIter.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((self__.i \x3c self__.base_count)){\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(self__.fields,self__.i);\n(self__.i \x3d (self__.i + (1)));\n\nreturn (new cljs.core.MapEntry(k,cljs.core._lookup(self__.record,k),null));\n} else {\nreturn self__.ext_map_iter.next();\n}\n}));\n\n(cljs.core.RecordIter.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.RecordIter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22record\x22,\x22record\x22,861424668,null),new cljs.core.Symbol(null,\x22base-count\x22,\x22base-count\x22,-1180647182,null),new cljs.core.Symbol(null,\x22fields\x22,\x22fields\x22,-291534703,null),new cljs.core.Symbol(null,\x22ext-map-iter\x22,\x22ext-map-iter\x22,-1215982757,null)], null);\n}));\n\n(cljs.core.RecordIter.cljs$lang$type \x3d true);\n\n(cljs.core.RecordIter.cljs$lang$ctorStr \x3d \x22cljs.core/RecordIter\x22);\n\n(cljs.core.RecordIter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/RecordIter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/RecordIter.\n */\ncljs.core.__GT_RecordIter \x3d (function cljs$core$__GT_RecordIter(i,record,base_count,fields,ext_map_iter){\nreturn (new cljs.core.RecordIter(i,record,base_count,fields,ext_map_iter));\n});\n\n\n/**\n* @constructor\n*/\ncljs.core.ES6EntriesIterator \x3d (function (s){\nthis.s \x3d s;\n});\n(cljs.core.ES6EntriesIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((!((self__.s \x3d\x3d null)))){\nvar vec__18291 \x3d cljs.core.first(self__.s);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18291,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18291,(1),null);\n(self__.s \x3d cljs.core.next(self__.s));\n\nreturn ({\x22value\x22: [k,v], \x22done\x22: false});\n} else {\nreturn ({\x22value\x22: null, \x22done\x22: true});\n}\n}));\n\n(cljs.core.ES6EntriesIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22s\x22,\x22s\x22,-948495851,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ES6EntriesIterator.cljs$lang$type \x3d true);\n\n(cljs.core.ES6EntriesIterator.cljs$lang$ctorStr \x3d \x22cljs.core/ES6EntriesIterator\x22);\n\n(cljs.core.ES6EntriesIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ES6EntriesIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ES6EntriesIterator.\n */\ncljs.core.__GT_ES6EntriesIterator \x3d (function cljs$core$__GT_ES6EntriesIterator(s){\nreturn (new cljs.core.ES6EntriesIterator(s));\n});\n\ncljs.core.es6_entries_iterator \x3d (function cljs$core$es6_entries_iterator(coll){\nreturn (new cljs.core.ES6EntriesIterator(cljs.core.seq(coll)));\n});\n\n/**\n* @constructor\n*/\ncljs.core.ES6SetEntriesIterator \x3d (function (s){\nthis.s \x3d s;\n});\n(cljs.core.ES6SetEntriesIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((!((self__.s \x3d\x3d null)))){\nvar x \x3d cljs.core.first(self__.s);\n(self__.s \x3d cljs.core.next(self__.s));\n\nreturn ({\x22value\x22: [x,x], \x22done\x22: false});\n} else {\nreturn ({\x22value\x22: null, \x22done\x22: true});\n}\n}));\n\n(cljs.core.ES6SetEntriesIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22s\x22,\x22s\x22,-948495851,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ES6SetEntriesIterator.cljs$lang$type \x3d true);\n\n(cljs.core.ES6SetEntriesIterator.cljs$lang$ctorStr \x3d \x22cljs.core/ES6SetEntriesIterator\x22);\n\n(cljs.core.ES6SetEntriesIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ES6SetEntriesIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ES6SetEntriesIterator.\n */\ncljs.core.__GT_ES6SetEntriesIterator \x3d (function cljs$core$__GT_ES6SetEntriesIterator(s){\nreturn (new cljs.core.ES6SetEntriesIterator(s));\n});\n\ncljs.core.es6_set_entries_iterator \x3d (function cljs$core$es6_set_entries_iterator(coll){\nreturn (new cljs.core.ES6SetEntriesIterator(cljs.core.seq(coll)));\n});\ncljs.core.array_index_of_nil_QMARK_ \x3d (function cljs$core$array_index_of_nil_QMARK_(arr){\nvar len \x3d arr.length;\nvar i \x3d (0);\nwhile(true){\nif((len \x3c\x3d i)){\nreturn (-1);\n} else {\nif(((arr[i]) \x3d\x3d null)){\nreturn i;\n} else {\nvar G__24997 \x3d (i + (2));\ni \x3d G__24997;\ncontinue;\n\n}\n}\nbreak;\n}\n});\ncljs.core.array_index_of_keyword_QMARK_ \x3d (function cljs$core$array_index_of_keyword_QMARK_(arr,k){\nvar len \x3d arr.length;\nvar kstr \x3d k.fqn;\nvar i \x3d (0);\nwhile(true){\nif((len \x3c\x3d i)){\nreturn (-1);\n} else {\nif(((((arr[i]) instanceof cljs.core.Keyword)) \x26\x26 ((kstr \x3d\x3d\x3d (arr[i]).fqn)))){\nreturn i;\n} else {\nvar G__24998 \x3d (i + (2));\ni \x3d G__24998;\ncontinue;\n\n}\n}\nbreak;\n}\n});\ncljs.core.array_index_of_symbol_QMARK_ \x3d (function cljs$core$array_index_of_symbol_QMARK_(arr,k){\nvar len \x3d arr.length;\nvar kstr \x3d k.str;\nvar i \x3d (0);\nwhile(true){\nif((len \x3c\x3d i)){\nreturn (-1);\n} else {\nif(((((arr[i]) instanceof cljs.core.Symbol)) \x26\x26 ((kstr \x3d\x3d\x3d (arr[i]).str)))){\nreturn i;\n} else {\nvar G__24999 \x3d (i + (2));\ni \x3d G__24999;\ncontinue;\n\n}\n}\nbreak;\n}\n});\ncljs.core.array_index_of_identical_QMARK_ \x3d (function cljs$core$array_index_of_identical_QMARK_(arr,k){\nvar len \x3d arr.length;\nvar i \x3d (0);\nwhile(true){\nif((len \x3c\x3d i)){\nreturn (-1);\n} else {\nif((k \x3d\x3d\x3d (arr[i]))){\nreturn i;\n} else {\nvar G__25000 \x3d (i + (2));\ni \x3d G__25000;\ncontinue;\n\n}\n}\nbreak;\n}\n});\ncljs.core.array_index_of_equiv_QMARK_ \x3d (function cljs$core$array_index_of_equiv_QMARK_(arr,k){\nvar len \x3d arr.length;\nvar i \x3d (0);\nwhile(true){\nif((len \x3c\x3d i)){\nreturn (-1);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(k,(arr[i]))){\nreturn i;\n} else {\nvar G__25001 \x3d (i + (2));\ni \x3d G__25001;\ncontinue;\n\n}\n}\nbreak;\n}\n});\ncljs.core.array_index_of \x3d (function cljs$core$array_index_of(arr,k){\nif((k instanceof cljs.core.Keyword)){\nreturn cljs.core.array_index_of_keyword_QMARK_(arr,k);\n} else {\nif(((typeof k \x3d\x3d\x3d \x27string\x27) || (typeof k \x3d\x3d\x3d \x27number\x27))){\nreturn cljs.core.array_index_of_identical_QMARK_(arr,k);\n} else {\nif((k instanceof cljs.core.Symbol)){\nreturn cljs.core.array_index_of_symbol_QMARK_(arr,k);\n} else {\nif((k \x3d\x3d null)){\nreturn cljs.core.array_index_of_nil_QMARK_(arr);\n} else {\nreturn cljs.core.array_index_of_equiv_QMARK_(arr,k);\n\n}\n}\n}\n}\n});\ncljs.core.array_map_index_of \x3d (function cljs$core$array_map_index_of(m,k){\nreturn cljs.core.array_index_of(m.arr,k);\n});\ncljs.core.array_extend_kv \x3d (function cljs$core$array_extend_kv(arr,k,v){\nvar l \x3d arr.length;\nvar narr \x3d (new Array((l + (2))));\nvar i_25002 \x3d (0);\nwhile(true){\nif((i_25002 \x3c l)){\n(narr[i_25002] \x3d (arr[i_25002]));\n\nvar G__25003 \x3d (i_25002 + (1));\ni_25002 \x3d G__25003;\ncontinue;\n} else {\n}\nbreak;\n}\n\n(narr[l] \x3d k);\n\n(narr[(l + (1))] \x3d v);\n\nreturn narr;\n});\ncljs.core.array_map_extend_kv \x3d (function cljs$core$array_map_extend_kv(m,k,v){\nreturn cljs.core.array_extend_kv(m.arr,k,v);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IVector}\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.IMapEntry}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.ILookup}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.MapEntry \x3d (function (key,val,__hash){\nthis.key \x3d key;\nthis.val \x3d val;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 166619935;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.MapEntry.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.MapEntry.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nvar G__18295 \x3d k;\nswitch (G__18295) {\ncase (0):\nreturn (new cljs.core.MapEntry((0),self__.key,null));\n\nbreak;\ncase (1):\nreturn (new cljs.core.MapEntry((1),self__.val,null));\n\nbreak;\ndefault:\nreturn null;\n\n}\n}));\n\n(cljs.core.MapEntry.prototype.indexOf \x3d (function() {\nvar G__25005 \x3d null;\nvar G__25005__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25005__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25005 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25005__1.call(this,x);\ncase 2:\nreturn G__25005__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25005.cljs$core$IFn$_invoke$arity$1 \x3d G__25005__1;\nG__25005.cljs$core$IFn$_invoke$arity$2 \x3d G__25005__2;\nreturn G__25005;\n})()\n);\n\n(cljs.core.MapEntry.prototype.lastIndexOf \x3d (function() {\nvar G__25009 \x3d null;\nvar G__25009__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25009__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25009 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25009__1.call(this,x);\ncase 2:\nreturn G__25009__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25009.cljs$core$IFn$_invoke$arity$1 \x3d G__25009__1;\nG__25009.cljs$core$IFn$_invoke$arity$2 \x3d G__25009__2;\nreturn G__25009;\n})()\n);\n\n(cljs.core.MapEntry.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn node__$1.cljs$core$IIndexed$_nth$arity$3(null, k,null);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (node,k,not_found){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn node__$1.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (node,n){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nif((n \x3d\x3d\x3d (0))){\nreturn self__.key;\n} else {\nif((n \x3d\x3d\x3d (1))){\nreturn self__.val;\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n\n}\n}\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (node,n,not_found){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nif((n \x3d\x3d\x3d (0))){\nreturn self__.key;\n} else {\nif((n \x3d\x3d\x3d (1))){\nreturn self__.val;\n} else {\nreturn not_found;\n\n}\n}\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IVector$_assoc_n$arity$3 \x3d (function (node,n,v){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null).cljs$core$IVector$_assoc_n$arity$3(null, n,v);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (2);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IMapEntry$_key$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.key;\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IMapEntry$_val$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (new cljs.core.IndexedSeq([self__.val,self__.key],(0),null));\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (node,f){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(node__$1,f);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (node,f,start){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(node__$1,f,start);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (node,k,v){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),k,v);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (((k \x3d\x3d\x3d (0))) || ((k \x3d\x3d\x3d (1))));\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (new cljs.core.IndexedSeq([self__.key,self__.val],(0),null));\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (node,meta){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.with_meta(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),meta);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (node,o){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val,o], null);\n}));\n\n(cljs.core.MapEntry.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18296 \x3d (arguments.length - (1));\nswitch (G__18296) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.MapEntry.prototype.apply \x3d (function (self__,args18294){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18294)));\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn node.cljs$core$IIndexed$_nth$arity$2(null, k);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn node.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n}));\n\n(cljs.core.MapEntry.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22key\x22,\x22key\x22,124488940,null),new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.MapEntry.cljs$lang$type \x3d true);\n\n(cljs.core.MapEntry.cljs$lang$ctorStr \x3d \x22cljs.core/MapEntry\x22);\n\n(cljs.core.MapEntry.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/MapEntry\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/MapEntry.\n */\ncljs.core.__GT_MapEntry \x3d (function cljs$core$__GT_MapEntry(key,val,__hash){\nreturn (new cljs.core.MapEntry(key,val,__hash));\n});\n\n/**\n * Returns true if x satisfies IMapEntry\n */\ncljs.core.map_entry_QMARK_ \x3d (function cljs$core$map_entry_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif((((x.cljs$lang$protocol_mask$partition0$ \x26 (2048))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IMapEntry$)))){\nreturn true;\n} else {\nreturn false;\n}\n} else {\nreturn false;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IDrop}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.PersistentArrayMapSeq \x3d (function (arr,i,_meta){\nthis.arr \x3d arr;\nthis.i \x3d i;\nthis._meta \x3d _meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374990;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 262144;\n});\n(cljs.core.PersistentArrayMapSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.indexOf \x3d (function() {\nvar G__25054 \x3d null;\nvar G__25054__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25054__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25054 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25054__1.call(this,x);\ncase 2:\nreturn G__25054__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25054.cljs$core$IFn$_invoke$arity$1 \x3d G__25054__1;\nG__25054.cljs$core$IFn$_invoke$arity$2 \x3d G__25054__2;\nreturn G__25054;\n})()\n);\n\n(cljs.core.PersistentArrayMapSeq.prototype.lastIndexOf \x3d (function() {\nvar G__25058 \x3d null;\nvar G__25058__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25058__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25058 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25058__1.call(this,x);\ncase 2:\nreturn G__25058__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25058.cljs$core$IFn$_invoke$arity$1 \x3d G__25058__1;\nG__25058.cljs$core$IFn$_invoke$arity$2 \x3d G__25058__2;\nreturn G__25058;\n})()\n);\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__._meta;\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.i \x3c (self__.arr.length - (2)))){\nreturn (new cljs.core.PersistentArrayMapSeq(self__.arr,(self__.i + (2)),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn ((self__.arr.length - self__.i) / (2));\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.hash_ordered_coll(coll__$1);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.MapEntry((self__.arr[self__.i]),(self__.arr[(self__.i + (1))]),null));\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.i \x3c (self__.arr.length - (2)))){\nreturn (new cljs.core.PersistentArrayMapSeq(self__.arr,(self__.i + (2)),null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__._meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentArrayMapSeq(self__.arr,self__.i,new_meta));\n}\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IDrop$_drop$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((n \x3c coll__$1.cljs$core$ICounted$_count$arity$1(null, ))){\nreturn (new cljs.core.PersistentArrayMapSeq(self__.arr,(self__.i + ((2) * n)),null));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentArrayMapSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.Symbol(null,\x22_meta\x22,\x22_meta\x22,-1716892533,null)], null);\n}));\n\n(cljs.core.PersistentArrayMapSeq.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentArrayMapSeq.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentArrayMapSeq\x22);\n\n(cljs.core.PersistentArrayMapSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentArrayMapSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentArrayMapSeq.\n */\ncljs.core.__GT_PersistentArrayMapSeq \x3d (function cljs$core$__GT_PersistentArrayMapSeq(arr,i,_meta){\nreturn (new cljs.core.PersistentArrayMapSeq(arr,i,_meta));\n});\n\n(cljs.core.PersistentArrayMapSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.persistent_array_map_seq \x3d (function cljs$core$persistent_array_map_seq(arr,i,_meta){\nif((i \x3c\x3d (arr.length - (2)))){\nreturn (new cljs.core.PersistentArrayMapSeq(arr,i,_meta));\n} else {\nreturn null;\n}\n});\n\n\n/**\n* @constructor\n*/\ncljs.core.PersistentArrayMapIterator \x3d (function (arr,i,cnt){\nthis.arr \x3d arr;\nthis.i \x3d i;\nthis.cnt \x3d cnt;\n});\n(cljs.core.PersistentArrayMapIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.i \x3c self__.cnt);\n}));\n\n(cljs.core.PersistentArrayMapIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d (new cljs.core.MapEntry((self__.arr[self__.i]),(self__.arr[(self__.i + (1))]),null));\n(self__.i \x3d (self__.i + (2)));\n\nreturn ret;\n}));\n\n(cljs.core.PersistentArrayMapIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null)], null);\n}));\n\n(cljs.core.PersistentArrayMapIterator.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentArrayMapIterator.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentArrayMapIterator\x22);\n\n(cljs.core.PersistentArrayMapIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentArrayMapIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentArrayMapIterator.\n */\ncljs.core.__GT_PersistentArrayMapIterator \x3d (function cljs$core$__GT_PersistentArrayMapIterator(arr,i,cnt){\nreturn (new cljs.core.PersistentArrayMapIterator(arr,i,cnt));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IDrop}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEditableCollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.PersistentArrayMap \x3d (function (meta,cnt,arr,__hash){\nthis.meta \x3d meta;\nthis.cnt \x3d cnt;\nthis.arr \x3d arr;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 16647951;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 401412;\n});\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar idx \x3d cljs.core.array_map_index_of(coll__$1,k);\nif((idx \x3d\x3d\x3d (-1))){\nreturn null;\n} else {\nreturn (new cljs.core.MapEntry((self__.arr[idx]),(self__.arr[(idx + (1))]),null));\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.keys \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator((cljs.core.keys.cljs$core$IFn$_invoke$arity$1 ? cljs.core.keys.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.keys.call(null, coll)));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.entries \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_entries_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.values \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator((cljs.core.vals.cljs$core$IFn$_invoke$arity$1 ? cljs.core.vals.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.vals.call(null, coll)));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.has \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.contains_QMARK_(coll,k);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.get \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.forEach \x3d (function (f){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar seq__18299 \x3d cljs.core.seq(coll);\nvar chunk__18300 \x3d null;\nvar count__18301 \x3d (0);\nvar i__18302 \x3d (0);\nwhile(true){\nif((i__18302 \x3c count__18301)){\nvar vec__18309 \x3d chunk__18300.cljs$core$IIndexed$_nth$arity$2(null, i__18302);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18309,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18309,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__25155 \x3d seq__18299;\nvar G__25156 \x3d chunk__18300;\nvar G__25157 \x3d count__18301;\nvar G__25158 \x3d (i__18302 + (1));\nseq__18299 \x3d G__25155;\nchunk__18300 \x3d G__25156;\ncount__18301 \x3d G__25157;\ni__18302 \x3d G__25158;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__18299);\nif(temp__5804__auto__){\nvar seq__18299__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__18299__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__18299__$1);\nvar G__25161 \x3d cljs.core.chunk_rest(seq__18299__$1);\nvar G__25162 \x3d c__5525__auto__;\nvar G__25163 \x3d cljs.core.count(c__5525__auto__);\nvar G__25164 \x3d (0);\nseq__18299 \x3d G__25161;\nchunk__18300 \x3d G__25162;\ncount__18301 \x3d G__25163;\ni__18302 \x3d G__25164;\ncontinue;\n} else {\nvar vec__18312 \x3d cljs.core.first(seq__18299__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18312,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18312,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__25165 \x3d cljs.core.next(seq__18299__$1);\nvar G__25166 \x3d null;\nvar G__25167 \x3d (0);\nvar G__25168 \x3d (0);\nseq__18299 \x3d G__25165;\nchunk__18300 \x3d G__25166;\ncount__18301 \x3d G__25167;\ni__18302 \x3d G__25168;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,k,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar idx \x3d cljs.core.array_map_index_of(coll__$1,k);\nif((idx \x3d\x3d\x3d (-1))){\nreturn not_found;\n} else {\nreturn (self__.arr[(idx + (1))]);\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (coll,f,init){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar len \x3d self__.arr.length;\nvar i \x3d (0);\nvar init__$1 \x3d init;\nwhile(true){\nif((i \x3c len)){\nvar init__$2 \x3d (function (){var G__18315 \x3d init__$1;\nvar G__18316 \x3d (self__.arr[i]);\nvar G__18317 \x3d (self__.arr[(i + (1))]);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18315,G__18316,G__18317) : f.call(null, G__18315,G__18316,G__18317));\n})();\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn cljs.core.deref(init__$2);\n} else {\nvar G__25172 \x3d (i + (2));\nvar G__25173 \x3d init__$2;\ni \x3d G__25172;\ninit__$1 \x3d G__25173;\ncontinue;\n}\n} else {\nreturn init__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (new cljs.core.PersistentArrayMapIterator(self__.arr,(0),(self__.cnt * (2))));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.PersistentArrayMap(self__.meta,self__.cnt,self__.arr,self__.__hash));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.cnt;\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_unordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(((cljs.core.map_QMARK_(other)) \x26\x26 ((!(cljs.core.record_QMARK_(other)))))){\nvar alen \x3d self__.arr.length;\nvar other__$1 \x3d other;\nif((self__.cnt \x3d\x3d\x3d other__$1.cljs$core$ICounted$_count$arity$1(null, ))){\nvar i \x3d (0);\nwhile(true){\nif((i \x3c alen)){\nvar v \x3d other__$1.cljs$core$ILookup$_lookup$arity$3(null, (self__.arr[i]),cljs.core.lookup_sentinel);\nif((!((v \x3d\x3d\x3d cljs.core.lookup_sentinel)))){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((self__.arr[(i + (1))]),v)){\nvar G__25184 \x3d (i + (2));\ni \x3d G__25184;\ncontinue;\n} else {\nreturn false;\n}\n} else {\nreturn false;\n}\n} else {\nreturn true;\n}\nbreak;\n}\n} else {\nreturn false;\n}\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.TransientArrayMap(({}),self__.arr.length,cljs.core.aclone(self__.arr)));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.PersistentArrayMap.EMPTY,self__.meta);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2(coll__$1,f);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3(coll__$1,f,start);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar idx \x3d cljs.core.array_map_index_of(coll__$1,k);\nif((idx \x3e\x3d (0))){\nvar len \x3d self__.arr.length;\nvar new_len \x3d (len - (2));\nif((new_len \x3d\x3d\x3d (0))){\nreturn coll__$1.cljs$core$IEmptyableCollection$_empty$arity$1(null, );\n} else {\nvar new_arr \x3d (new Array(new_len));\nvar s \x3d (0);\nvar d \x3d (0);\nwhile(true){\nif((s \x3e\x3d len)){\nreturn (new cljs.core.PersistentArrayMap(self__.meta,(self__.cnt - (1)),new_arr,null));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(k,(self__.arr[s]))){\nvar G__25189 \x3d (s + (2));\nvar G__25190 \x3d d;\ns \x3d G__25189;\nd \x3d G__25190;\ncontinue;\n} else {\n(new_arr[d] \x3d (self__.arr[s]));\n\n(new_arr[(d + (1))] \x3d (self__.arr[(s + (1))]));\n\nvar G__25191 \x3d (s + (2));\nvar G__25192 \x3d (d + (2));\ns \x3d G__25191;\nd \x3d G__25192;\ncontinue;\n\n}\n}\nbreak;\n}\n}\n} else {\nreturn coll__$1;\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (coll,k,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar idx \x3d cljs.core.array_map_index_of(coll__$1,k);\nif((idx \x3d\x3d\x3d (-1))){\nif((self__.cnt \x3c cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD)){\nvar arr__$1 \x3d cljs.core.array_map_extend_kv(coll__$1,k,v);\nreturn (new cljs.core.PersistentArrayMap(self__.meta,(self__.cnt + (1)),arr__$1,null));\n} else {\nreturn cljs.core._with_meta(cljs.core._assoc(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentHashMap.EMPTY,coll__$1),k,v),self__.meta);\n}\n} else {\nif((v \x3d\x3d\x3d (self__.arr[(idx + (1))]))){\nreturn coll__$1;\n} else {\nvar arr__$1 \x3d (function (){var G__18320 \x3d cljs.core.aclone(self__.arr);\n(G__18320[(idx + (1))] \x3d v);\n\nreturn G__18320;\n})();\nreturn (new cljs.core.PersistentArrayMap(self__.meta,self__.cnt,arr__$1,null));\n\n}\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (!((cljs.core.array_map_index_of(coll__$1,k) \x3d\x3d\x3d (-1))));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.persistent_array_map_seq(self__.arr,(0),null);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentArrayMap(new_meta,self__.cnt,self__.arr,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,entry){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry)){\nreturn coll__$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry,(0)),cljs.core._nth(entry,(1)));\n} else {\nvar ret \x3d coll__$1;\nvar es \x3d cljs.core.seq(entry);\nwhile(true){\nif((es \x3d\x3d null)){\nreturn ret;\n} else {\nvar e \x3d cljs.core.first(es);\nif(cljs.core.vector_QMARK_(e)){\nvar G__25199 \x3d cljs.core._assoc(ret,cljs.core._nth(e,(0)),cljs.core._nth(e,(1)));\nvar G__25200 \x3d cljs.core.next(es);\nret \x3d G__25199;\nes \x3d G__25200;\ncontinue;\n} else {\nthrow (new Error(\x22conj on a map takes map entries or seqables of map entries\x22));\n}\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18321 \x3d (arguments.length - (1));\nswitch (G__18321) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.PersistentArrayMap.prototype.apply \x3d (function (self__,args18298){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18298)));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$2(null, k);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IDrop$_drop$arity$2 \x3d (function (coll,n){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar temp__5808__auto__ \x3d coll__$1.cljs$core$ISeqable$_seq$arity$1(null, );\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar s \x3d temp__5808__auto__;\nreturn cljs.core._drop(s,n);\n}\n}));\n\n(cljs.core.PersistentArrayMap.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentArrayMap.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentArrayMap.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentArrayMap\x22);\n\n(cljs.core.PersistentArrayMap.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentArrayMap\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentArrayMap.\n */\ncljs.core.__GT_PersistentArrayMap \x3d (function cljs$core$__GT_PersistentArrayMap(meta,cnt,arr,__hash){\nreturn (new cljs.core.PersistentArrayMap(meta,cnt,arr,__hash));\n});\n\n(cljs.core.PersistentArrayMap.EMPTY \x3d (new cljs.core.PersistentArrayMap(null,(0),[],cljs.core.empty_unordered_hash)));\n(cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD \x3d (8));\n(cljs.core.PersistentArrayMap.fromArray \x3d (function (arr,no_clone,no_check){\nvar arr__$1 \x3d ((no_clone)?arr:cljs.core.aclone(arr));\nvar arr__$2 \x3d ((no_check)?arr__$1:(function (){var ret \x3d [];\nvar i_25209 \x3d (0);\nwhile(true){\nif((i_25209 \x3c arr__$1.length)){\nvar k_25210 \x3d (arr__$1[i_25209]);\nvar v_25211 \x3d (arr__$1[(i_25209 + (1))]);\nvar idx_25212 \x3d cljs.core.array_index_of(ret,k_25210);\nif((idx_25212 \x3d\x3d\x3d (-1))){\nret.push(k_25210);\n\nret.push(v_25211);\n} else {\n}\n\nvar G__25213 \x3d (i_25209 + (2));\ni_25209 \x3d G__25213;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn ret;\n})());\nvar cnt \x3d (arr__$2.length / (2));\nreturn (new cljs.core.PersistentArrayMap(null,cnt,arr__$2,null));\n}));\n(cljs.core.PersistentArrayMap.createWithCheck \x3d (function (arr){\nvar ret \x3d [];\nvar i_25214 \x3d (0);\nwhile(true){\nif((i_25214 \x3c arr.length)){\nvar k_25215 \x3d (arr[i_25214]);\nvar v_25216 \x3d (arr[(i_25214 + (1))]);\nvar idx_25217 \x3d cljs.core.array_index_of(ret,k_25215);\nif((idx_25217 \x3d\x3d\x3d (-1))){\nvar G__18322_25219 \x3d ret;\nG__18322_25219.push(k_25215);\n\nG__18322_25219.push(v_25216);\n\n} else {\nthrow (new Error([\x22Duplicate key: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(k_25215)].join(\x27\x27)));\n}\n\nvar G__25220 \x3d (i_25214 + (2));\ni_25214 \x3d G__25220;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar cnt \x3d (arr.length / (2));\nreturn (new cljs.core.PersistentArrayMap(null,cnt,arr,null));\n}));\ncljs.core.key_test \x3d (function cljs$core$key_test(key,other){\nif((key \x3d\x3d\x3d other)){\nreturn true;\n} else {\nif(cljs.core.keyword_identical_QMARK_(key,other)){\nreturn true;\n} else {\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(key,other);\n\n}\n}\n});\ncljs.core.pam_dupes_QMARK_ \x3d (function cljs$core$pam_dupes_QMARK_(arr){\nvar i \x3d (0);\nwhile(true){\nif((i \x3c arr.length)){\nvar dupe_QMARK_ \x3d (function (){var j \x3d (0);\nwhile(true){\nif((j \x3c i)){\nvar or__5002__auto__ \x3d cljs.core.key_test((arr[i]),(arr[j]));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar G__25237 \x3d ((2) + j);\nj \x3d G__25237;\ncontinue;\n}\n} else {\nreturn false;\n}\nbreak;\n}\n})();\nvar or__5002__auto__ \x3d dupe_QMARK_;\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar G__25238 \x3d ((2) + i);\ni \x3d G__25238;\ncontinue;\n}\n} else {\nreturn false;\n}\nbreak;\n}\n});\ncljs.core.pam_new_size \x3d (function cljs$core$pam_new_size(arr){\nvar i \x3d (0);\nvar n \x3d (0);\nwhile(true){\nif((i \x3c arr.length)){\nvar dupe_QMARK_ \x3d (function (){var j \x3d (0);\nwhile(true){\nif((j \x3c i)){\nvar or__5002__auto__ \x3d cljs.core.key_test((arr[i]),(arr[j]));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar G__25239 \x3d ((2) + j);\nj \x3d G__25239;\ncontinue;\n}\n} else {\nreturn false;\n}\nbreak;\n}\n})();\nvar G__25241 \x3d ((2) + i);\nvar G__25242 \x3d ((dupe_QMARK_)?n:(n + (2)));\ni \x3d G__25241;\nn \x3d G__25242;\ncontinue;\n} else {\nreturn n;\n}\nbreak;\n}\n});\ncljs.core.pam_grow_seed_array \x3d (function cljs$core$pam_grow_seed_array(seed,trailing){\nvar seed_cnt \x3d (seed.length - (1));\nvar extra_kvs \x3d cljs.core.seq(trailing);\nvar ret \x3d (new Array((seed_cnt + ((2) * cljs.core.count(extra_kvs)))));\nvar ret__$1 \x3d cljs.core.array_copy(seed,(0),ret,(0),seed_cnt);\nvar i \x3d seed_cnt;\nvar extra_kvs__$1 \x3d extra_kvs;\nwhile(true){\nif(extra_kvs__$1){\nvar kv \x3d cljs.core.first(extra_kvs__$1);\n(ret__$1[i] \x3d cljs.core._key(kv));\n\n(ret__$1[(i + (1))] \x3d cljs.core._val(kv));\n\nvar G__25247 \x3d ((2) + seed_cnt);\nvar G__25248 \x3d cljs.core.next(extra_kvs__$1);\ni \x3d G__25247;\nextra_kvs__$1 \x3d G__25248;\ncontinue;\n} else {\nreturn ret__$1;\n}\nbreak;\n}\n});\n(cljs.core.PersistentArrayMap.createAsIfByAssoc \x3d (function (init){\nvar len \x3d init.length;\nvar has_trailing_QMARK_ \x3d ((1) \x3d\x3d\x3d (len \x26 (1)));\nif((!(((has_trailing_QMARK_) || (cljs.core.pam_dupes_QMARK_(init)))))){\nreturn (new cljs.core.PersistentArrayMap(null,(len / (2)),init,null));\n} else {\nreturn cljs.core.PersistentArrayMap.createAsIfByAssocComplexPath(init,has_trailing_QMARK_);\n}\n}));\n(cljs.core.PersistentArrayMap.createAsIfByAssocComplexPath \x3d (function (init,has_trailing_QMARK_){\nvar init__$1 \x3d ((has_trailing_QMARK_)?cljs.core.pam_grow_seed_array(init,cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,(init[(init.length - (1))]))):init);\nvar n \x3d cljs.core.pam_new_size(init__$1);\nvar len \x3d init__$1.length;\nif((n \x3c len)){\nvar nodups \x3d (new Array(n));\nvar i_25251 \x3d (0);\nvar m_25252 \x3d (0);\nwhile(true){\nif((i_25251 \x3c len)){\nvar dupe_QMARK__25253 \x3d (function (){var j \x3d (0);\nwhile(true){\nif((j \x3c m_25252)){\nvar or__5002__auto__ \x3d cljs.core.key_test((init__$1[i_25251]),(init__$1[j]));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar G__25255 \x3d ((2) + j);\nj \x3d G__25255;\ncontinue;\n}\n} else {\nreturn false;\n}\nbreak;\n}\n})();\nif((!(dupe_QMARK__25253))){\nvar j_25257 \x3d (function (){var j_25257 \x3d (len - (2));\nwhile(true){\nif((j_25257 \x3e\x3d i_25251)){\nif(cljs.core.key_test((init__$1[i_25251]),(init__$1[j_25257]))){\nreturn j_25257;\n} else {\nvar G__25258 \x3d (j_25257 - (2));\nj_25257 \x3d G__25258;\ncontinue;\n}\n} else {\nreturn j_25257;\n}\nbreak;\n}\n})();\n(nodups[m_25252] \x3d (init__$1[i_25251]));\n\n(nodups[(m_25252 + (1))] \x3d (init__$1[(j_25257 + (1))]));\n\nvar G__25260 \x3d ((2) + i_25251);\nvar G__25261 \x3d ((2) + m_25252);\ni_25251 \x3d G__25260;\nm_25252 \x3d G__25261;\ncontinue;\n} else {\nvar G__25262 \x3d ((2) + i_25251);\nvar G__25263 \x3d m_25252;\ni_25251 \x3d G__25262;\nm_25252 \x3d G__25263;\ncontinue;\n}\n} else {\n}\nbreak;\n}\n\nreturn (new cljs.core.PersistentArrayMap(null,(nodups.length / (2)),nodups,null));\n} else {\nreturn (new cljs.core.PersistentArrayMap(null,(init__$1.length / (2)),init__$1,null));\n}\n}));\n(cljs.core.PersistentArrayMap.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ITransientMap}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ITransientCollection}\n * @implements {cljs.core.ITransientAssociative}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.TransientArrayMap \x3d (function (editable_QMARK_,len,arr){\nthis.editable_QMARK_ \x3d editable_QMARK_;\nthis.len \x3d len;\nthis.arr \x3d arr;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 259;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 56;\n});\n(cljs.core.TransientArrayMap.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (tcoll){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.editable_QMARK_){\nreturn cljs.core.quot(self__.len,(2));\n} else {\nthrow (new Error(\x22count after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (tcoll,k){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn tcoll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (tcoll,k,not_found){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.editable_QMARK_){\nvar idx \x3d cljs.core.array_map_index_of(tcoll__$1,k);\nif((idx \x3d\x3d\x3d (-1))){\nreturn not_found;\n} else {\nreturn (self__.arr[(idx + (1))]);\n}\n} else {\nthrow (new Error(\x22lookup after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 \x3d (function (tcoll,o){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.editable_QMARK_){\nif(cljs.core.map_entry_QMARK_(o)){\nreturn tcoll__$1.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(null, (cljs.core.key.cljs$core$IFn$_invoke$arity$1 ? cljs.core.key.cljs$core$IFn$_invoke$arity$1(o) : cljs.core.key.call(null, o)),(cljs.core.val.cljs$core$IFn$_invoke$arity$1 ? cljs.core.val.cljs$core$IFn$_invoke$arity$1(o) : cljs.core.val.call(null, o)));\n} else {\nif(cljs.core.vector_QMARK_(o)){\nreturn tcoll__$1.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(null, (o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((0)) : o.call(null, (0))),(o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((1)) : o.call(null, (1))));\n} else {\nvar es \x3d cljs.core.seq(o);\nvar tcoll__$2 \x3d tcoll__$1;\nwhile(true){\nvar temp__5802__auto__ \x3d cljs.core.first(es);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar e \x3d temp__5802__auto__;\nvar G__25266 \x3d cljs.core.next(es);\nvar G__25267 \x3d cljs.core._assoc_BANG_(tcoll__$2,(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.val.cljs$core$IFn$_invoke$arity$1 ? cljs.core.val.cljs$core$IFn$_invoke$arity$1(e) : cljs.core.val.call(null, e)));\nes \x3d G__25266;\ntcoll__$2 \x3d G__25267;\ncontinue;\n} else {\nreturn tcoll__$2;\n}\nbreak;\n}\n\n}\n}\n} else {\nthrow (new Error(\x22conj! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 \x3d (function (tcoll){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.editable_QMARK_){\n(self__.editable_QMARK_ \x3d false);\n\nreturn (new cljs.core.PersistentArrayMap(null,cljs.core.quot(self__.len,(2)),self__.arr,null));\n} else {\nthrow (new Error(\x22persistent! called twice\x22));\n}\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 \x3d (function (tcoll,key,val){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.editable_QMARK_){\nvar idx \x3d cljs.core.array_map_index_of(tcoll__$1,key);\nif((idx \x3d\x3d\x3d (-1))){\nif(((self__.len + (2)) \x3c\x3d ((2) * cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD))){\n(self__.len \x3d (self__.len + (2)));\n\nself__.arr.push(key);\n\nself__.arr.push(val);\n\nreturn tcoll__$1;\n} else {\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3((cljs.core.array__GT_transient_hash_map.cljs$core$IFn$_invoke$arity$2 ? cljs.core.array__GT_transient_hash_map.cljs$core$IFn$_invoke$arity$2(self__.len,self__.arr) : cljs.core.array__GT_transient_hash_map.call(null, self__.len,self__.arr)),key,val);\n}\n} else {\nif((val \x3d\x3d\x3d (self__.arr[(idx + (1))]))){\nreturn tcoll__$1;\n} else {\n(self__.arr[(idx + (1))] \x3d val);\n\nreturn tcoll__$1;\n}\n}\n} else {\nthrow (new Error(\x22assoc! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 \x3d (function (tcoll,key){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif(self__.editable_QMARK_){\nvar idx \x3d cljs.core.array_map_index_of(tcoll__$1,key);\nif((idx \x3e\x3d (0))){\n(self__.arr[idx] \x3d (self__.arr[(self__.len - (2))]));\n\n(self__.arr[(idx + (1))] \x3d (self__.arr[(self__.len - (1))]));\n\nvar G__18324_25275 \x3d self__.arr;\nG__18324_25275.pop();\n\nG__18324_25275.pop();\n\n\n(self__.len \x3d (self__.len - (2)));\n} else {\n}\n\nreturn tcoll__$1;\n} else {\nthrow (new Error(\x22dissoc! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientArrayMap.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18325 \x3d (arguments.length - (1));\nswitch (G__18325) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.TransientArrayMap.prototype.apply \x3d (function (self__,args18323){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18323)));\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (key){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nreturn tcoll.cljs$core$ILookup$_lookup$arity$3(null, key,null);\n}));\n\n(cljs.core.TransientArrayMap.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (key,not_found){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nreturn tcoll.cljs$core$ILookup$_lookup$arity$3(null, key,not_found);\n}));\n\n(cljs.core.TransientArrayMap.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22editable?\x22,\x22editable?\x22,-164945806,null),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22boolean\x22,\x22boolean\x22,-278886877,null),new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22len\x22,\x22len\x22,-1230778691,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null)], null);\n}));\n\n(cljs.core.TransientArrayMap.cljs$lang$type \x3d true);\n\n(cljs.core.TransientArrayMap.cljs$lang$ctorStr \x3d \x22cljs.core/TransientArrayMap\x22);\n\n(cljs.core.TransientArrayMap.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/TransientArrayMap\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/TransientArrayMap.\n */\ncljs.core.__GT_TransientArrayMap \x3d (function cljs$core$__GT_TransientArrayMap(editable_QMARK_,len,arr){\nreturn (new cljs.core.TransientArrayMap(editable_QMARK_,len,arr));\n});\n\ncljs.core.array__GT_transient_hash_map \x3d (function cljs$core$array__GT_transient_hash_map(len,arr){\nvar out \x3d cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY);\nvar i \x3d (0);\nwhile(true){\nif((i \x3c len)){\nvar G__25279 \x3d cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,(arr[i]),(arr[(i + (1))]));\nvar G__25280 \x3d (i + (2));\nout \x3d G__25279;\ni \x3d G__25280;\ncontinue;\n} else {\nreturn out;\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n*/\ncljs.core.Box \x3d (function (val){\nthis.val \x3d val;\n});\n\n(cljs.core.Box.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Box.cljs$lang$type \x3d true);\n\n(cljs.core.Box.cljs$lang$ctorStr \x3d \x22cljs.core/Box\x22);\n\n(cljs.core.Box.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Box\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Box.\n */\ncljs.core.__GT_Box \x3d (function cljs$core$__GT_Box(val){\nreturn (new cljs.core.Box(val));\n});\n\n\n\ncljs.core.mask \x3d (function cljs$core$mask(hash,shift){\nreturn ((hash \x3e\x3e\x3e shift) \x26 (31));\n});\ncljs.core.clone_and_set \x3d (function cljs$core$clone_and_set(var_args){\nvar G__18327 \x3d arguments.length;\nswitch (G__18327) {\ncase 3:\nreturn cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 5:\nreturn cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3 \x3d (function (arr,i,a){\nvar G__18328 \x3d cljs.core.aclone(arr);\n(G__18328[i] \x3d a);\n\nreturn G__18328;\n}));\n\n(cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$5 \x3d (function (arr,i,a,j,b){\nvar G__18329 \x3d cljs.core.aclone(arr);\n(G__18329[i] \x3d a);\n\n(G__18329[j] \x3d b);\n\nreturn G__18329;\n}));\n\n(cljs.core.clone_and_set.cljs$lang$maxFixedArity \x3d 5);\n\ncljs.core.remove_pair \x3d (function cljs$core$remove_pair(arr,i){\nvar new_arr \x3d (new Array((arr.length - (2))));\ncljs.core.array_copy(arr,(0),new_arr,(0),((2) * i));\n\ncljs.core.array_copy(arr,((2) * (i + (1))),new_arr,((2) * i),(new_arr.length - ((2) * i)));\n\nreturn new_arr;\n});\ncljs.core.bitmap_indexed_node_index \x3d (function cljs$core$bitmap_indexed_node_index(bitmap,bit){\nreturn cljs.core.bit_count((bitmap \x26 (bit - (1))));\n});\ncljs.core.bitpos \x3d (function cljs$core$bitpos(hash,shift){\nreturn ((1) \x3c\x3c ((hash \x3e\x3e\x3e shift) \x26 0x01f));\n});\ncljs.core.edit_and_set \x3d (function cljs$core$edit_and_set(var_args){\nvar G__18331 \x3d arguments.length;\nswitch (G__18331) {\ncase 4:\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 6:\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4 \x3d (function (inode,edit,i,a){\nvar editable \x3d inode.ensure_editable(edit);\n(editable.arr[i] \x3d a);\n\nreturn editable;\n}));\n\n(cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6 \x3d (function (inode,edit,i,a,j,b){\nvar editable \x3d inode.ensure_editable(edit);\n(editable.arr[i] \x3d a);\n\n(editable.arr[j] \x3d b);\n\nreturn editable;\n}));\n\n(cljs.core.edit_and_set.cljs$lang$maxFixedArity \x3d 6);\n\ncljs.core.inode_kv_reduce \x3d (function cljs$core$inode_kv_reduce(arr,f,init){\nvar len \x3d arr.length;\nvar i \x3d (0);\nvar init__$1 \x3d init;\nwhile(true){\nif((i \x3c len)){\nvar init__$2 \x3d (function (){var k \x3d (arr[i]);\nif((!((k \x3d\x3d null)))){\nvar G__18332 \x3d init__$1;\nvar G__18333 \x3d k;\nvar G__18334 \x3d (arr[(i + (1))]);\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18332,G__18333,G__18334) : f.call(null, G__18332,G__18333,G__18334));\n} else {\nvar node \x3d (arr[(i + (1))]);\nif((!((node \x3d\x3d null)))){\nreturn node.kv_reduce(f,init__$1);\n} else {\nreturn init__$1;\n}\n}\n})();\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn init__$2;\n} else {\nvar G__25301 \x3d (i + (2));\nvar G__25302 \x3d init__$2;\ni \x3d G__25301;\ninit__$1 \x3d G__25302;\ncontinue;\n}\n} else {\nreturn init__$1;\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n*/\ncljs.core.NodeIterator \x3d (function (arr,i,next_entry,next_iter){\nthis.arr \x3d arr;\nthis.i \x3d i;\nthis.next_entry \x3d next_entry;\nthis.next_iter \x3d next_iter;\n});\n(cljs.core.NodeIterator.prototype.advance \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nvar len \x3d self__.arr.length;\nwhile(true){\nif((self__.i \x3c len)){\nvar key \x3d (self__.arr[self__.i]);\nvar node_or_val \x3d (self__.arr[(self__.i + (1))]);\nvar found \x3d (((!((key \x3d\x3d null))))?(self__.next_entry \x3d (new cljs.core.MapEntry(key,node_or_val,null))):(((!((node_or_val \x3d\x3d null))))?(function (){var new_iter \x3d cljs.core._iterator(node_or_val);\nif(new_iter.hasNext()){\nreturn (self__.next_iter \x3d new_iter);\n} else {\nreturn false;\n}\n})():false\n));\n(self__.i \x3d (self__.i + (2)));\n\nif(found){\nreturn true;\n} else {\ncontinue;\n}\n} else {\nreturn false;\n}\nbreak;\n}\n}));\n\n(cljs.core.NodeIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nvar or__5002__auto__ \x3d (!((self__.next_entry \x3d\x3d null)));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (!((self__.next_iter \x3d\x3d null)));\nif(or__5002__auto____$1){\nreturn or__5002__auto____$1;\n} else {\nreturn this$.advance();\n}\n}\n}));\n\n(cljs.core.NodeIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((!((self__.next_entry \x3d\x3d null)))){\nvar ret \x3d self__.next_entry;\n(self__.next_entry \x3d null);\n\nreturn ret;\n} else {\nif((!((self__.next_iter \x3d\x3d null)))){\nvar ret \x3d self__.next_iter.next();\nif(self__.next_iter.hasNext()){\n} else {\n(self__.next_iter \x3d null);\n}\n\nreturn ret;\n} else {\nif(this$.advance()){\nreturn this$.next();\n} else {\nthrow (new Error(\x22No such element\x22));\n\n}\n}\n}\n}));\n\n(cljs.core.NodeIterator.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.NodeIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22next-entry\x22,\x22next-entry\x22,1091342476,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22next-iter\x22,\x22next-iter\x22,1526626239,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.NodeIterator.cljs$lang$type \x3d true);\n\n(cljs.core.NodeIterator.cljs$lang$ctorStr \x3d \x22cljs.core/NodeIterator\x22);\n\n(cljs.core.NodeIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/NodeIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/NodeIterator.\n */\ncljs.core.__GT_NodeIterator \x3d (function cljs$core$__GT_NodeIterator(arr,i,next_entry,next_iter){\nreturn (new cljs.core.NodeIterator(arr,i,next_entry,next_iter));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IIterable}\n*/\ncljs.core.BitmapIndexedNode \x3d (function (edit,bitmap,arr){\nthis.edit \x3d edit;\nthis.bitmap \x3d bitmap;\nthis.arr \x3d arr;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 131072;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 0;\n});\n(cljs.core.BitmapIndexedNode.prototype.ensure_editable \x3d (function (e){\nvar self__ \x3d this;\nvar inode \x3d this;\nif((e \x3d\x3d\x3d self__.edit)){\nreturn inode;\n} else {\nvar n \x3d cljs.core.bit_count(self__.bitmap);\nvar new_arr \x3d (new Array((((n \x3c (0)))?(4):((2) * (n + (1))))));\ncljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * n));\n\nreturn (new cljs.core.BitmapIndexedNode(e,self__.bitmap,new_arr));\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.inode_without_BANG_ \x3d (function (edit__$1,shift,hash,key,removed_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar bit \x3d (1 \x3c\x3c ((hash \x3e\x3e\x3e shift) \x26 0x01f));\nif(((self__.bitmap \x26 bit) \x3d\x3d\x3d (0))){\nreturn inode;\n} else {\nvar idx \x3d cljs.core.bitmap_indexed_node_index(self__.bitmap,bit);\nvar key_or_nil \x3d (self__.arr[((2) * idx)]);\nvar val_or_node \x3d (self__.arr[(((2) * idx) + (1))]);\nif((key_or_nil \x3d\x3d null)){\nvar n \x3d val_or_node.inode_without_BANG_(edit__$1,(shift + (5)),hash,key,removed_leaf_QMARK_);\nif((n \x3d\x3d\x3d val_or_node)){\nreturn inode;\n} else {\nif((!((n \x3d\x3d null)))){\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(((2) * idx) + (1)),n);\n} else {\nif((self__.bitmap \x3d\x3d\x3d bit)){\nreturn null;\n} else {\nreturn inode.edit_and_remove_pair(edit__$1,bit,idx);\n\n}\n}\n}\n} else {\nif(cljs.core.key_test(key,key_or_nil)){\n(removed_leaf_QMARK_.val \x3d true);\n\nreturn inode.edit_and_remove_pair(edit__$1,bit,idx);\n} else {\nreturn inode;\n\n}\n}\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.edit_and_remove_pair \x3d (function (e,bit,i){\nvar self__ \x3d this;\nvar inode \x3d this;\nif((self__.bitmap \x3d\x3d\x3d bit)){\nreturn null;\n} else {\nvar editable \x3d inode.ensure_editable(e);\nvar earr \x3d editable.arr;\nvar len \x3d earr.length;\n(editable.bitmap \x3d (bit ^ editable.bitmap));\n\ncljs.core.array_copy(earr,((2) * (i + (1))),earr,((2) * i),(len - ((2) * (i + (1)))));\n\n(earr[(len - (2))] \x3d null);\n\n(earr[(len - (1))] \x3d null);\n\nreturn editable;\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.inode_seq \x3d (function (){\nvar self__ \x3d this;\nvar inode \x3d this;\nreturn (cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1 ? cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1(self__.arr) : cljs.core.create_inode_seq.call(null, self__.arr));\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.kv_reduce \x3d (function (f,init){\nvar self__ \x3d this;\nvar inode \x3d this;\nreturn cljs.core.inode_kv_reduce(self__.arr,f,init);\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.inode_lookup \x3d (function (shift,hash,key,not_found){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar bit \x3d (1 \x3c\x3c ((hash \x3e\x3e\x3e shift) \x26 0x01f));\nif(((self__.bitmap \x26 bit) \x3d\x3d\x3d (0))){\nreturn not_found;\n} else {\nvar idx \x3d cljs.core.bitmap_indexed_node_index(self__.bitmap,bit);\nvar key_or_nil \x3d (self__.arr[((2) * idx)]);\nvar val_or_node \x3d (self__.arr[(((2) * idx) + (1))]);\nif((key_or_nil \x3d\x3d null)){\nreturn val_or_node.inode_lookup((shift + (5)),hash,key,not_found);\n} else {\nif(cljs.core.key_test(key,key_or_nil)){\nreturn val_or_node;\n} else {\nreturn not_found;\n\n}\n}\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.inode_assoc_BANG_ \x3d (function (edit__$1,shift,hash,key,val,added_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar bit \x3d (1 \x3c\x3c ((hash \x3e\x3e\x3e shift) \x26 0x01f));\nvar idx \x3d cljs.core.bitmap_indexed_node_index(self__.bitmap,bit);\nif(((self__.bitmap \x26 bit) \x3d\x3d\x3d (0))){\nvar n \x3d cljs.core.bit_count(self__.bitmap);\nif((((2) * n) \x3c self__.arr.length)){\nvar editable \x3d inode.ensure_editable(edit__$1);\nvar earr \x3d editable.arr;\n(added_leaf_QMARK_.val \x3d true);\n\ncljs.core.array_copy_downward(earr,((2) * idx),earr,((2) * (idx + (1))),((2) * (n - idx)));\n\n(earr[((2) * idx)] \x3d key);\n\n(earr[(((2) * idx) + (1))] \x3d val);\n\n(editable.bitmap \x3d (editable.bitmap | bit));\n\nreturn editable;\n} else {\nif((n \x3e\x3d (16))){\nvar nodes \x3d [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];\nvar jdx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\n(nodes[jdx] \x3d cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_));\n\nvar i_25322 \x3d (0);\nvar j_25323 \x3d (0);\nwhile(true){\nif((i_25322 \x3c (32))){\nif((((self__.bitmap \x3e\x3e\x3e i_25322) \x26 (1)) \x3d\x3d\x3d (0))){\nvar G__25324 \x3d (i_25322 + (1));\nvar G__25325 \x3d j_25323;\ni_25322 \x3d G__25324;\nj_25323 \x3d G__25325;\ncontinue;\n} else {\n(nodes[i_25322] \x3d (((!(((self__.arr[j_25323]) \x3d\x3d null))))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + (5)),cljs.core.hash((self__.arr[j_25323])),(self__.arr[j_25323]),(self__.arr[(j_25323 + (1))]),added_leaf_QMARK_):(self__.arr[(j_25323 + (1))])));\n\nvar G__25326 \x3d (i_25322 + (1));\nvar G__25327 \x3d (j_25323 + (2));\ni_25322 \x3d G__25326;\nj_25323 \x3d G__25327;\ncontinue;\n}\n} else {\n}\nbreak;\n}\n\nreturn (new cljs.core.ArrayNode(edit__$1,(n + (1)),nodes));\n} else {\nvar new_arr \x3d (new Array(((2) * (n + (4)))));\ncljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * idx));\n\n(new_arr[((2) * idx)] \x3d key);\n\n(new_arr[(((2) * idx) + (1))] \x3d val);\n\ncljs.core.array_copy(self__.arr,((2) * idx),new_arr,((2) * (idx + (1))),((2) * (n - idx)));\n\n(added_leaf_QMARK_.val \x3d true);\n\nvar editable \x3d inode.ensure_editable(edit__$1);\n(editable.arr \x3d new_arr);\n\n(editable.bitmap \x3d (editable.bitmap | bit));\n\nreturn editable;\n\n}\n}\n} else {\nvar key_or_nil \x3d (self__.arr[((2) * idx)]);\nvar val_or_node \x3d (self__.arr[(((2) * idx) + (1))]);\nif((key_or_nil \x3d\x3d null)){\nvar n \x3d val_or_node.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_);\nif((n \x3d\x3d\x3d val_or_node)){\nreturn inode;\n} else {\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(((2) * idx) + (1)),n);\n}\n} else {\nif(cljs.core.key_test(key,key_or_nil)){\nif((val \x3d\x3d\x3d val_or_node)){\nreturn inode;\n} else {\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(((2) * idx) + (1)),val);\n}\n} else {\n(added_leaf_QMARK_.val \x3d true);\n\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6(inode,edit__$1,((2) * idx),null,(((2) * idx) + (1)),(function (){var G__18335 \x3d edit__$1;\nvar G__18336 \x3d (shift + (5));\nvar G__18337 \x3d key_or_nil;\nvar G__18338 \x3d val_or_node;\nvar G__18339 \x3d hash;\nvar G__18340 \x3d key;\nvar G__18341 \x3d val;\nreturn (cljs.core.create_node.cljs$core$IFn$_invoke$arity$7 ? cljs.core.create_node.cljs$core$IFn$_invoke$arity$7(G__18335,G__18336,G__18337,G__18338,G__18339,G__18340,G__18341) : cljs.core.create_node.call(null, G__18335,G__18336,G__18337,G__18338,G__18339,G__18340,G__18341));\n})());\n\n}\n}\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.inode_assoc \x3d (function (shift,hash,key,val,added_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar bit \x3d (1 \x3c\x3c ((hash \x3e\x3e\x3e shift) \x26 0x01f));\nvar idx \x3d cljs.core.bitmap_indexed_node_index(self__.bitmap,bit);\nif(((self__.bitmap \x26 bit) \x3d\x3d\x3d (0))){\nvar n \x3d cljs.core.bit_count(self__.bitmap);\nif((n \x3e\x3d (16))){\nvar nodes \x3d [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];\nvar jdx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\n(nodes[jdx] \x3d cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_));\n\nvar i_25374 \x3d (0);\nvar j_25376 \x3d (0);\nwhile(true){\nif((i_25374 \x3c (32))){\nif((((self__.bitmap \x3e\x3e\x3e i_25374) \x26 (1)) \x3d\x3d\x3d (0))){\nvar G__25383 \x3d (i_25374 + (1));\nvar G__25384 \x3d j_25376;\ni_25374 \x3d G__25383;\nj_25376 \x3d G__25384;\ncontinue;\n} else {\n(nodes[i_25374] \x3d (((!(((self__.arr[j_25376]) \x3d\x3d null))))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + (5)),cljs.core.hash((self__.arr[j_25376])),(self__.arr[j_25376]),(self__.arr[(j_25376 + (1))]),added_leaf_QMARK_):(self__.arr[(j_25376 + (1))])));\n\nvar G__25385 \x3d (i_25374 + (1));\nvar G__25386 \x3d (j_25376 + (2));\ni_25374 \x3d G__25385;\nj_25376 \x3d G__25386;\ncontinue;\n}\n} else {\n}\nbreak;\n}\n\nreturn (new cljs.core.ArrayNode(null,(n + (1)),nodes));\n} else {\nvar new_arr \x3d (new Array(((2) * (n + (1)))));\ncljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * idx));\n\n(new_arr[((2) * idx)] \x3d key);\n\n(new_arr[(((2) * idx) + (1))] \x3d val);\n\ncljs.core.array_copy(self__.arr,((2) * idx),new_arr,((2) * (idx + (1))),((2) * (n - idx)));\n\n(added_leaf_QMARK_.val \x3d true);\n\nreturn (new cljs.core.BitmapIndexedNode(null,(self__.bitmap | bit),new_arr));\n}\n} else {\nvar key_or_nil \x3d (self__.arr[((2) * idx)]);\nvar val_or_node \x3d (self__.arr[(((2) * idx) + (1))]);\nif((key_or_nil \x3d\x3d null)){\nvar n \x3d val_or_node.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_);\nif((n \x3d\x3d\x3d val_or_node)){\nreturn inode;\n} else {\nreturn (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(((2) * idx) + (1)),n)));\n}\n} else {\nif(cljs.core.key_test(key,key_or_nil)){\nif((val \x3d\x3d\x3d val_or_node)){\nreturn inode;\n} else {\nreturn (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(((2) * idx) + (1)),val)));\n}\n} else {\n(added_leaf_QMARK_.val \x3d true);\n\nreturn (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$5(self__.arr,((2) * idx),null,(((2) * idx) + (1)),(function (){var G__18342 \x3d (shift + (5));\nvar G__18343 \x3d key_or_nil;\nvar G__18344 \x3d val_or_node;\nvar G__18345 \x3d hash;\nvar G__18346 \x3d key;\nvar G__18347 \x3d val;\nreturn (cljs.core.create_node.cljs$core$IFn$_invoke$arity$6 ? cljs.core.create_node.cljs$core$IFn$_invoke$arity$6(G__18342,G__18343,G__18344,G__18345,G__18346,G__18347) : cljs.core.create_node.call(null, G__18342,G__18343,G__18344,G__18345,G__18346,G__18347));\n})())));\n\n}\n}\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.inode_find \x3d (function (shift,hash,key,not_found){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar bit \x3d (1 \x3c\x3c ((hash \x3e\x3e\x3e shift) \x26 0x01f));\nif(((self__.bitmap \x26 bit) \x3d\x3d\x3d (0))){\nreturn not_found;\n} else {\nvar idx \x3d cljs.core.bitmap_indexed_node_index(self__.bitmap,bit);\nvar key_or_nil \x3d (self__.arr[((2) * idx)]);\nvar val_or_node \x3d (self__.arr[(((2) * idx) + (1))]);\nif((key_or_nil \x3d\x3d null)){\nreturn val_or_node.inode_find((shift + (5)),hash,key,not_found);\n} else {\nif(cljs.core.key_test(key,key_or_nil)){\nreturn (new cljs.core.MapEntry(key_or_nil,val_or_node,null));\n} else {\nreturn not_found;\n\n}\n}\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.inode_without \x3d (function (shift,hash,key){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar bit \x3d (1 \x3c\x3c ((hash \x3e\x3e\x3e shift) \x26 0x01f));\nif(((self__.bitmap \x26 bit) \x3d\x3d\x3d (0))){\nreturn inode;\n} else {\nvar idx \x3d cljs.core.bitmap_indexed_node_index(self__.bitmap,bit);\nvar key_or_nil \x3d (self__.arr[((2) * idx)]);\nvar val_or_node \x3d (self__.arr[(((2) * idx) + (1))]);\nif((key_or_nil \x3d\x3d null)){\nvar n \x3d val_or_node.inode_without((shift + (5)),hash,key);\nif((n \x3d\x3d\x3d val_or_node)){\nreturn inode;\n} else {\nif((!((n \x3d\x3d null)))){\nreturn (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(((2) * idx) + (1)),n)));\n} else {\nif((self__.bitmap \x3d\x3d\x3d bit)){\nreturn null;\n} else {\nreturn (new cljs.core.BitmapIndexedNode(null,(self__.bitmap ^ bit),cljs.core.remove_pair(self__.arr,idx)));\n\n}\n}\n}\n} else {\nif(cljs.core.key_test(key,key_or_nil)){\nif((self__.bitmap \x3d\x3d\x3d bit)){\nreturn null;\n} else {\nreturn (new cljs.core.BitmapIndexedNode(null,(self__.bitmap ^ bit),cljs.core.remove_pair(self__.arr,idx)));\n}\n} else {\nreturn inode;\n\n}\n}\n}\n}));\n\n(cljs.core.BitmapIndexedNode.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.NodeIterator(self__.arr,(0),null,null));\n}));\n\n(cljs.core.BitmapIndexedNode.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22edit\x22,\x22edit\x22,-1302639,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22bitmap\x22,\x22bitmap\x22,501334601,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.BitmapIndexedNode.cljs$lang$type \x3d true);\n\n(cljs.core.BitmapIndexedNode.cljs$lang$ctorStr \x3d \x22cljs.core/BitmapIndexedNode\x22);\n\n(cljs.core.BitmapIndexedNode.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/BitmapIndexedNode\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/BitmapIndexedNode.\n */\ncljs.core.__GT_BitmapIndexedNode \x3d (function cljs$core$__GT_BitmapIndexedNode(edit,bitmap,arr){\nreturn (new cljs.core.BitmapIndexedNode(edit,bitmap,arr));\n});\n\n(cljs.core.BitmapIndexedNode.EMPTY \x3d (new cljs.core.BitmapIndexedNode(null,(0),[])));\ncljs.core.pack_array_node \x3d (function cljs$core$pack_array_node(array_node,edit,idx){\nvar arr \x3d array_node.arr;\nvar len \x3d arr.length;\nvar new_arr \x3d (new Array(((2) * (array_node.cnt - (1)))));\nvar i \x3d (0);\nvar j \x3d (1);\nvar bitmap \x3d (0);\nwhile(true){\nif((i \x3c len)){\nif((((!((i \x3d\x3d\x3d idx)))) \x26\x26 ((!(((arr[i]) \x3d\x3d null)))))){\n(new_arr[j] \x3d (arr[i]));\n\nvar G__25399 \x3d (i + (1));\nvar G__25400 \x3d (j + (2));\nvar G__25401 \x3d (bitmap | ((1) \x3c\x3c i));\ni \x3d G__25399;\nj \x3d G__25400;\nbitmap \x3d G__25401;\ncontinue;\n} else {\nvar G__25402 \x3d (i + (1));\nvar G__25403 \x3d j;\nvar G__25404 \x3d bitmap;\ni \x3d G__25402;\nj \x3d G__25403;\nbitmap \x3d G__25404;\ncontinue;\n}\n} else {\nreturn (new cljs.core.BitmapIndexedNode(edit,bitmap,new_arr));\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n*/\ncljs.core.ArrayNodeIterator \x3d (function (arr,i,next_iter){\nthis.arr \x3d arr;\nthis.i \x3d i;\nthis.next_iter \x3d next_iter;\n});\n(cljs.core.ArrayNodeIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nvar len \x3d self__.arr.length;\nwhile(true){\nif((!((((!((self__.next_iter \x3d\x3d null)))) \x26\x26 (self__.next_iter.hasNext()))))){\nif((self__.i \x3c len)){\nvar node \x3d (self__.arr[self__.i]);\n(self__.i \x3d (self__.i + (1)));\n\nif((!((node \x3d\x3d null)))){\n(self__.next_iter \x3d cljs.core._iterator(node));\n} else {\n}\n\ncontinue;\n} else {\nreturn false;\n}\n} else {\nreturn true;\n}\nbreak;\n}\n}));\n\n(cljs.core.ArrayNodeIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif(this$.hasNext()){\nreturn self__.next_iter.next();\n} else {\nthrow (new Error(\x22No such element\x22));\n}\n}));\n\n(cljs.core.ArrayNodeIterator.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.ArrayNodeIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22next-iter\x22,\x22next-iter\x22,1526626239,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ArrayNodeIterator.cljs$lang$type \x3d true);\n\n(cljs.core.ArrayNodeIterator.cljs$lang$ctorStr \x3d \x22cljs.core/ArrayNodeIterator\x22);\n\n(cljs.core.ArrayNodeIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ArrayNodeIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ArrayNodeIterator.\n */\ncljs.core.__GT_ArrayNodeIterator \x3d (function cljs$core$__GT_ArrayNodeIterator(arr,i,next_iter){\nreturn (new cljs.core.ArrayNodeIterator(arr,i,next_iter));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IIterable}\n*/\ncljs.core.ArrayNode \x3d (function (edit,cnt,arr){\nthis.edit \x3d edit;\nthis.cnt \x3d cnt;\nthis.arr \x3d arr;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 131072;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 0;\n});\n(cljs.core.ArrayNode.prototype.ensure_editable \x3d (function (e){\nvar self__ \x3d this;\nvar inode \x3d this;\nif((e \x3d\x3d\x3d self__.edit)){\nreturn inode;\n} else {\nreturn (new cljs.core.ArrayNode(e,self__.cnt,cljs.core.aclone(self__.arr)));\n}\n}));\n\n(cljs.core.ArrayNode.prototype.inode_without_BANG_ \x3d (function (edit__$1,shift,hash,key,removed_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\nvar node \x3d (self__.arr[idx]);\nif((node \x3d\x3d null)){\nreturn inode;\n} else {\nvar n \x3d node.inode_without_BANG_(edit__$1,(shift + (5)),hash,key,removed_leaf_QMARK_);\nif((n \x3d\x3d\x3d node)){\nreturn inode;\n} else {\nif((n \x3d\x3d null)){\nif((self__.cnt \x3c\x3d (8))){\nreturn cljs.core.pack_array_node(inode,edit__$1,idx);\n} else {\nvar editable \x3d cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,n);\n(editable.cnt \x3d (editable.cnt - (1)));\n\nreturn editable;\n}\n} else {\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,n);\n\n}\n}\n}\n}));\n\n(cljs.core.ArrayNode.prototype.inode_seq \x3d (function (){\nvar self__ \x3d this;\nvar inode \x3d this;\nreturn (cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$1 ? cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$1(self__.arr) : cljs.core.create_array_node_seq.call(null, self__.arr));\n}));\n\n(cljs.core.ArrayNode.prototype.kv_reduce \x3d (function (f,init){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar len \x3d self__.arr.length;\nvar i \x3d (0);\nvar init__$1 \x3d init;\nwhile(true){\nif((i \x3c len)){\nvar node \x3d (self__.arr[i]);\nif((!((node \x3d\x3d null)))){\nvar init__$2 \x3d node.kv_reduce(f,init__$1);\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn init__$2;\n} else {\nvar G__25428 \x3d (i + (1));\nvar G__25429 \x3d init__$2;\ni \x3d G__25428;\ninit__$1 \x3d G__25429;\ncontinue;\n}\n} else {\nvar G__25430 \x3d (i + (1));\nvar G__25431 \x3d init__$1;\ni \x3d G__25430;\ninit__$1 \x3d G__25431;\ncontinue;\n}\n} else {\nreturn init__$1;\n}\nbreak;\n}\n}));\n\n(cljs.core.ArrayNode.prototype.inode_lookup \x3d (function (shift,hash,key,not_found){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\nvar node \x3d (self__.arr[idx]);\nif((!((node \x3d\x3d null)))){\nreturn node.inode_lookup((shift + (5)),hash,key,not_found);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.ArrayNode.prototype.inode_assoc_BANG_ \x3d (function (edit__$1,shift,hash,key,val,added_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\nvar node \x3d (self__.arr[idx]);\nif((node \x3d\x3d null)){\nvar editable \x3d cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_));\n(editable.cnt \x3d (editable.cnt + (1)));\n\nreturn editable;\n} else {\nvar n \x3d node.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_);\nif((n \x3d\x3d\x3d node)){\nreturn inode;\n} else {\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,n);\n}\n}\n}));\n\n(cljs.core.ArrayNode.prototype.inode_assoc \x3d (function (shift,hash,key,val,added_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\nvar node \x3d (self__.arr[idx]);\nif((node \x3d\x3d null)){\nreturn (new cljs.core.ArrayNode(null,(self__.cnt + (1)),cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_))));\n} else {\nvar n \x3d node.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_);\nif((n \x3d\x3d\x3d node)){\nreturn inode;\n} else {\nreturn (new cljs.core.ArrayNode(null,self__.cnt,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,n)));\n}\n}\n}));\n\n(cljs.core.ArrayNode.prototype.inode_find \x3d (function (shift,hash,key,not_found){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\nvar node \x3d (self__.arr[idx]);\nif((!((node \x3d\x3d null)))){\nreturn node.inode_find((shift + (5)),hash,key,not_found);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.ArrayNode.prototype.inode_without \x3d (function (shift,hash,key){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d ((hash \x3e\x3e\x3e shift) \x26 0x01f);\nvar node \x3d (self__.arr[idx]);\nif((!((node \x3d\x3d null)))){\nvar n \x3d node.inode_without((shift + (5)),hash,key);\nif((n \x3d\x3d\x3d node)){\nreturn inode;\n} else {\nif((n \x3d\x3d null)){\nif((self__.cnt \x3c\x3d (8))){\nreturn cljs.core.pack_array_node(inode,null,idx);\n} else {\nreturn (new cljs.core.ArrayNode(null,(self__.cnt - (1)),cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,n)));\n}\n} else {\nreturn (new cljs.core.ArrayNode(null,self__.cnt,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,n)));\n\n}\n}\n} else {\nreturn inode;\n}\n}));\n\n(cljs.core.ArrayNode.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.ArrayNodeIterator(self__.arr,(0),null));\n}));\n\n(cljs.core.ArrayNode.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22edit\x22,\x22edit\x22,-1302639,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ArrayNode.cljs$lang$type \x3d true);\n\n(cljs.core.ArrayNode.cljs$lang$ctorStr \x3d \x22cljs.core/ArrayNode\x22);\n\n(cljs.core.ArrayNode.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ArrayNode\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ArrayNode.\n */\ncljs.core.__GT_ArrayNode \x3d (function cljs$core$__GT_ArrayNode(edit,cnt,arr){\nreturn (new cljs.core.ArrayNode(edit,cnt,arr));\n});\n\ncljs.core.hash_collision_node_find_index \x3d (function cljs$core$hash_collision_node_find_index(arr,cnt,key){\nvar lim \x3d ((2) * cnt);\nvar i \x3d (0);\nwhile(true){\nif((i \x3c lim)){\nif(cljs.core.key_test(key,(arr[i]))){\nreturn i;\n} else {\nvar G__25457 \x3d (i + (2));\ni \x3d G__25457;\ncontinue;\n}\n} else {\nreturn (-1);\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IIterable}\n*/\ncljs.core.HashCollisionNode \x3d (function (edit,collision_hash,cnt,arr){\nthis.edit \x3d edit;\nthis.collision_hash \x3d collision_hash;\nthis.cnt \x3d cnt;\nthis.arr \x3d arr;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 131072;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 0;\n});\n(cljs.core.HashCollisionNode.prototype.ensure_editable \x3d (function (e){\nvar self__ \x3d this;\nvar inode \x3d this;\nif((e \x3d\x3d\x3d self__.edit)){\nreturn inode;\n} else {\nvar new_arr \x3d (new Array(((2) * (self__.cnt + (1)))));\ncljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * self__.cnt));\n\nreturn (new cljs.core.HashCollisionNode(e,self__.collision_hash,self__.cnt,new_arr));\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.inode_without_BANG_ \x3d (function (edit__$1,shift,hash,key,removed_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key);\nif((idx \x3d\x3d\x3d (-1))){\nreturn inode;\n} else {\n(removed_leaf_QMARK_.val \x3d true);\n\nif((self__.cnt \x3d\x3d\x3d (1))){\nreturn null;\n} else {\nvar editable \x3d inode.ensure_editable(edit__$1);\nvar earr \x3d editable.arr;\n(earr[idx] \x3d (earr[(((2) * self__.cnt) - (2))]));\n\n(earr[(idx + (1))] \x3d (earr[(((2) * self__.cnt) - (1))]));\n\n(earr[(((2) * self__.cnt) - (1))] \x3d null);\n\n(earr[(((2) * self__.cnt) - (2))] \x3d null);\n\n(editable.cnt \x3d (editable.cnt - (1)));\n\nreturn editable;\n}\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.inode_seq \x3d (function (){\nvar self__ \x3d this;\nvar inode \x3d this;\nreturn (cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1 ? cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1(self__.arr) : cljs.core.create_inode_seq.call(null, self__.arr));\n}));\n\n(cljs.core.HashCollisionNode.prototype.kv_reduce \x3d (function (f,init){\nvar self__ \x3d this;\nvar inode \x3d this;\nreturn cljs.core.inode_kv_reduce(self__.arr,f,init);\n}));\n\n(cljs.core.HashCollisionNode.prototype.inode_lookup \x3d (function (shift,hash,key,not_found){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key);\nif((idx \x3c (0))){\nreturn not_found;\n} else {\nif(cljs.core.key_test(key,(self__.arr[idx]))){\nreturn (self__.arr[(idx + (1))]);\n} else {\nreturn not_found;\n\n}\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.inode_assoc_BANG_ \x3d (function (edit__$1,shift,hash,key,val,added_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nif((hash \x3d\x3d\x3d self__.collision_hash)){\nvar idx \x3d cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key);\nif((idx \x3d\x3d\x3d (-1))){\nif((self__.arr.length \x3e ((2) * self__.cnt))){\nvar editable \x3d cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6(inode,edit__$1,((2) * self__.cnt),key,(((2) * self__.cnt) + (1)),val);\n(added_leaf_QMARK_.val \x3d true);\n\n(editable.cnt \x3d (editable.cnt + (1)));\n\nreturn editable;\n} else {\nvar len \x3d self__.arr.length;\nvar new_arr \x3d (new Array((len + (2))));\ncljs.core.array_copy(self__.arr,(0),new_arr,(0),len);\n\n(new_arr[len] \x3d key);\n\n(new_arr[(len + (1))] \x3d val);\n\n(added_leaf_QMARK_.val \x3d true);\n\nreturn inode.ensure_editable_array(edit__$1,(self__.cnt + (1)),new_arr);\n}\n} else {\nif(((self__.arr[(idx + (1))]) \x3d\x3d\x3d val)){\nreturn inode;\n} else {\nreturn cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(idx + (1)),val);\n}\n}\n} else {\nreturn (new cljs.core.BitmapIndexedNode(edit__$1,(1 \x3c\x3c ((self__.collision_hash \x3e\x3e\x3e shift) \x26 0x01f)),[null,inode,null,null])).inode_assoc_BANG_(edit__$1,shift,hash,key,val,added_leaf_QMARK_);\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.inode_assoc \x3d (function (shift,hash,key,val,added_leaf_QMARK_){\nvar self__ \x3d this;\nvar inode \x3d this;\nif((hash \x3d\x3d\x3d self__.collision_hash)){\nvar idx \x3d cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key);\nif((idx \x3d\x3d\x3d (-1))){\nvar len \x3d ((2) * self__.cnt);\nvar new_arr \x3d (new Array((len + (2))));\ncljs.core.array_copy(self__.arr,(0),new_arr,(0),len);\n\n(new_arr[len] \x3d key);\n\n(new_arr[(len + (1))] \x3d val);\n\n(added_leaf_QMARK_.val \x3d true);\n\nreturn (new cljs.core.HashCollisionNode(null,self__.collision_hash,(self__.cnt + (1)),new_arr));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((self__.arr[(idx + (1))]),val)){\nreturn inode;\n} else {\nreturn (new cljs.core.HashCollisionNode(null,self__.collision_hash,self__.cnt,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(idx + (1)),val)));\n}\n}\n} else {\nreturn (new cljs.core.BitmapIndexedNode(null,(1 \x3c\x3c ((self__.collision_hash \x3e\x3e\x3e shift) \x26 0x01f)),[null,inode])).inode_assoc(shift,hash,key,val,added_leaf_QMARK_);\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.ensure_editable_array \x3d (function (e,count,array){\nvar self__ \x3d this;\nvar inode \x3d this;\nif((e \x3d\x3d\x3d self__.edit)){\n(self__.arr \x3d array);\n\n(self__.cnt \x3d count);\n\nreturn inode;\n} else {\nreturn (new cljs.core.HashCollisionNode(self__.edit,self__.collision_hash,count,array));\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.inode_find \x3d (function (shift,hash,key,not_found){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key);\nif((idx \x3c (0))){\nreturn not_found;\n} else {\nif(cljs.core.key_test(key,(self__.arr[idx]))){\nreturn (new cljs.core.MapEntry((self__.arr[idx]),(self__.arr[(idx + (1))]),null));\n} else {\nreturn not_found;\n\n}\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.inode_without \x3d (function (shift,hash,key){\nvar self__ \x3d this;\nvar inode \x3d this;\nvar idx \x3d cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key);\nif((idx \x3d\x3d\x3d (-1))){\nreturn inode;\n} else {\nif((self__.cnt \x3d\x3d\x3d (1))){\nreturn null;\n} else {\nreturn (new cljs.core.HashCollisionNode(null,self__.collision_hash,(self__.cnt - (1)),cljs.core.remove_pair(self__.arr,cljs.core.quot(idx,(2)))));\n\n}\n}\n}));\n\n(cljs.core.HashCollisionNode.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.NodeIterator(self__.arr,(0),null,null));\n}));\n\n(cljs.core.HashCollisionNode.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22edit\x22,\x22edit\x22,-1302639,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22collision-hash\x22,\x22collision-hash\x22,-35831342,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.HashCollisionNode.cljs$lang$type \x3d true);\n\n(cljs.core.HashCollisionNode.cljs$lang$ctorStr \x3d \x22cljs.core/HashCollisionNode\x22);\n\n(cljs.core.HashCollisionNode.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/HashCollisionNode\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/HashCollisionNode.\n */\ncljs.core.__GT_HashCollisionNode \x3d (function cljs$core$__GT_HashCollisionNode(edit,collision_hash,cnt,arr){\nreturn (new cljs.core.HashCollisionNode(edit,collision_hash,cnt,arr));\n});\n\ncljs.core.create_node \x3d (function cljs$core$create_node(var_args){\nvar G__18407 \x3d arguments.length;\nswitch (G__18407) {\ncase 6:\nreturn cljs.core.create_node.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ncase 7:\nreturn cljs.core.create_node.cljs$core$IFn$_invoke$arity$7((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.create_node.cljs$core$IFn$_invoke$arity$6 \x3d (function (shift,key1,val1,key2hash,key2,val2){\nvar key1hash \x3d cljs.core.hash(key1);\nif((key1hash \x3d\x3d\x3d key2hash)){\nreturn (new cljs.core.HashCollisionNode(null,key1hash,(2),[key1,val1,key2,val2]));\n} else {\nvar added_leaf_QMARK_ \x3d (new cljs.core.Box(false));\nreturn cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift,key1hash,key1,val1,added_leaf_QMARK_).inode_assoc(shift,key2hash,key2,val2,added_leaf_QMARK_);\n}\n}));\n\n(cljs.core.create_node.cljs$core$IFn$_invoke$arity$7 \x3d (function (edit,shift,key1,val1,key2hash,key2,val2){\nvar key1hash \x3d cljs.core.hash(key1);\nif((key1hash \x3d\x3d\x3d key2hash)){\nreturn (new cljs.core.HashCollisionNode(null,key1hash,(2),[key1,val1,key2,val2]));\n} else {\nvar added_leaf_QMARK_ \x3d (new cljs.core.Box(false));\nreturn cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit,shift,key1hash,key1,val1,added_leaf_QMARK_).inode_assoc_BANG_(edit,shift,key2hash,key2,val2,added_leaf_QMARK_);\n}\n}));\n\n(cljs.core.create_node.cljs$lang$maxFixedArity \x3d 7);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.NodeSeq \x3d (function (meta,nodes,i,s,__hash){\nthis.meta \x3d meta;\nthis.nodes \x3d nodes;\nthis.i \x3d i;\nthis.s \x3d s;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374988;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.NodeSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.NodeSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.NodeSeq.prototype.indexOf \x3d (function() {\nvar G__25508 \x3d null;\nvar G__25508__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25508__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25508 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25508__1.call(this,x);\ncase 2:\nreturn G__25508__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25508.cljs$core$IFn$_invoke$arity$1 \x3d G__25508__1;\nG__25508.cljs$core$IFn$_invoke$arity$2 \x3d G__25508__2;\nreturn G__25508;\n})()\n);\n\n(cljs.core.NodeSeq.prototype.lastIndexOf \x3d (function() {\nvar G__25512 \x3d null;\nvar G__25512__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25512__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25512 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25512__1.call(this,x);\ncase 2:\nreturn G__25512__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25512.cljs$core$IFn$_invoke$arity$1 \x3d G__25512__1;\nG__25512.cljs$core$IFn$_invoke$arity$2 \x3d G__25512__2;\nreturn G__25512;\n})()\n);\n\n(cljs.core.NodeSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.s \x3d\x3d null)){\nvar G__18412 \x3d self__.nodes;\nvar G__18413 \x3d (self__.i + (2));\nvar G__18414 \x3d null;\nreturn (cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3 ? cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(G__18412,G__18413,G__18414) : cljs.core.create_inode_seq.call(null, G__18412,G__18413,G__18414));\n} else {\nvar G__18415 \x3d self__.nodes;\nvar G__18416 \x3d self__.i;\nvar G__18417 \x3d cljs.core.next(self__.s);\nreturn (cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3 ? cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(G__18415,G__18416,G__18417) : cljs.core.create_inode_seq.call(null, G__18415,G__18416,G__18417));\n}\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.s \x3d\x3d null)){\nreturn (new cljs.core.MapEntry((self__.nodes[self__.i]),(self__.nodes[(self__.i + (1))]),null));\n} else {\nreturn cljs.core.first(self__.s);\n}\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar ret \x3d (((self__.s \x3d\x3d null))?(function (){var G__18419 \x3d self__.nodes;\nvar G__18420 \x3d (self__.i + (2));\nvar G__18421 \x3d null;\nreturn (cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3 ? cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(G__18419,G__18420,G__18421) : cljs.core.create_inode_seq.call(null, G__18419,G__18420,G__18421));\n})():(function (){var G__18422 \x3d self__.nodes;\nvar G__18423 \x3d self__.i;\nvar G__18424 \x3d cljs.core.next(self__.s);\nreturn (cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3 ? cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(G__18422,G__18423,G__18424) : cljs.core.create_inode_seq.call(null, G__18422,G__18423,G__18424));\n})());\nif((!((ret \x3d\x3d null)))){\nreturn ret;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn this$__$1;\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.NodeSeq(new_meta,self__.nodes,self__.i,self__.s,self__.__hash));\n}\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.NodeSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22nodes\x22,\x22nodes\x22,-459054278,null),new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.Symbol(null,\x22s\x22,\x22s\x22,-948495851,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.NodeSeq.cljs$lang$type \x3d true);\n\n(cljs.core.NodeSeq.cljs$lang$ctorStr \x3d \x22cljs.core/NodeSeq\x22);\n\n(cljs.core.NodeSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/NodeSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/NodeSeq.\n */\ncljs.core.__GT_NodeSeq \x3d (function cljs$core$__GT_NodeSeq(meta,nodes,i,s,__hash){\nreturn (new cljs.core.NodeSeq(meta,nodes,i,s,__hash));\n});\n\n(cljs.core.NodeSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.create_inode_seq \x3d (function cljs$core$create_inode_seq(var_args){\nvar G__18428 \x3d arguments.length;\nswitch (G__18428) {\ncase 1:\nreturn cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 3:\nreturn cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1 \x3d (function (nodes){\nreturn cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(nodes,(0),null);\n}));\n\n(cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3 \x3d (function (nodes,i,s){\nif((s \x3d\x3d null)){\nvar len \x3d nodes.length;\nvar j \x3d i;\nwhile(true){\nif((j \x3c len)){\nif((!(((nodes[j]) \x3d\x3d null)))){\nreturn (new cljs.core.NodeSeq(null,nodes,j,null,null));\n} else {\nvar temp__5802__auto__ \x3d (nodes[(j + (1))]);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar node \x3d temp__5802__auto__;\nvar temp__5802__auto____$1 \x3d node.inode_seq();\nif(cljs.core.truth_(temp__5802__auto____$1)){\nvar node_seq \x3d temp__5802__auto____$1;\nreturn (new cljs.core.NodeSeq(null,nodes,(j + (2)),node_seq,null));\n} else {\nvar G__25559 \x3d (j + (2));\nj \x3d G__25559;\ncontinue;\n}\n} else {\nvar G__25560 \x3d (j + (2));\nj \x3d G__25560;\ncontinue;\n}\n}\n} else {\nreturn null;\n}\nbreak;\n}\n} else {\nreturn (new cljs.core.NodeSeq(null,nodes,i,s,null));\n}\n}));\n\n(cljs.core.create_inode_seq.cljs$lang$maxFixedArity \x3d 3);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.ArrayNodeSeq \x3d (function (meta,nodes,i,s,__hash){\nthis.meta \x3d meta;\nthis.nodes \x3d nodes;\nthis.i \x3d i;\nthis.s \x3d s;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374988;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.ArrayNodeSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.indexOf \x3d (function() {\nvar G__25562 \x3d null;\nvar G__25562__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25562__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25562 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25562__1.call(this,x);\ncase 2:\nreturn G__25562__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25562.cljs$core$IFn$_invoke$arity$1 \x3d G__25562__1;\nG__25562.cljs$core$IFn$_invoke$arity$2 \x3d G__25562__2;\nreturn G__25562;\n})()\n);\n\n(cljs.core.ArrayNodeSeq.prototype.lastIndexOf \x3d (function() {\nvar G__25564 \x3d null;\nvar G__25564__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25564__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25564 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25564__1.call(this,x);\ncase 2:\nreturn G__25564__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25564.cljs$core$IFn$_invoke$arity$1 \x3d G__25564__1;\nG__25564.cljs$core$IFn$_invoke$arity$2 \x3d G__25564__2;\nreturn G__25564;\n})()\n);\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar G__18440 \x3d self__.nodes;\nvar G__18441 \x3d self__.i;\nvar G__18442 \x3d cljs.core.next(self__.s);\nreturn (cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$3 ? cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$3(G__18440,G__18441,G__18442) : cljs.core.create_array_node_seq.call(null, G__18440,G__18441,G__18442));\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.first(self__.s);\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar ret \x3d (function (){var G__18445 \x3d self__.nodes;\nvar G__18446 \x3d self__.i;\nvar G__18447 \x3d cljs.core.next(self__.s);\nreturn (cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$3 ? cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$3(G__18445,G__18446,G__18447) : cljs.core.create_array_node_seq.call(null, G__18445,G__18446,G__18447));\n})();\nif((!((ret \x3d\x3d null)))){\nreturn ret;\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn this$__$1;\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.ArrayNodeSeq(new_meta,self__.nodes,self__.i,self__.s,self__.__hash));\n}\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.ArrayNodeSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22nodes\x22,\x22nodes\x22,-459054278,null),new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.Symbol(null,\x22s\x22,\x22s\x22,-948495851,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ArrayNodeSeq.cljs$lang$type \x3d true);\n\n(cljs.core.ArrayNodeSeq.cljs$lang$ctorStr \x3d \x22cljs.core/ArrayNodeSeq\x22);\n\n(cljs.core.ArrayNodeSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ArrayNodeSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ArrayNodeSeq.\n */\ncljs.core.__GT_ArrayNodeSeq \x3d (function cljs$core$__GT_ArrayNodeSeq(meta,nodes,i,s,__hash){\nreturn (new cljs.core.ArrayNodeSeq(meta,nodes,i,s,__hash));\n});\n\n(cljs.core.ArrayNodeSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.create_array_node_seq \x3d (function cljs$core$create_array_node_seq(var_args){\nvar G__18465 \x3d arguments.length;\nswitch (G__18465) {\ncase 1:\nreturn cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 3:\nreturn cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$1 \x3d (function (nodes){\nreturn cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$3(nodes,(0),null);\n}));\n\n(cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$3 \x3d (function (nodes,i,s){\nif((s \x3d\x3d null)){\nvar len \x3d nodes.length;\nvar j \x3d i;\nwhile(true){\nif((j \x3c len)){\nvar temp__5802__auto__ \x3d (nodes[j]);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar nj \x3d temp__5802__auto__;\nvar temp__5802__auto____$1 \x3d nj.inode_seq();\nif(cljs.core.truth_(temp__5802__auto____$1)){\nvar ns \x3d temp__5802__auto____$1;\nreturn (new cljs.core.ArrayNodeSeq(null,nodes,(j + (1)),ns,null));\n} else {\nvar G__25584 \x3d (j + (1));\nj \x3d G__25584;\ncontinue;\n}\n} else {\nvar G__25585 \x3d (j + (1));\nj \x3d G__25585;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n} else {\nreturn (new cljs.core.ArrayNodeSeq(null,nodes,i,s,null));\n}\n}));\n\n(cljs.core.create_array_node_seq.cljs$lang$maxFixedArity \x3d 3);\n\n\n/**\n* @constructor\n*/\ncljs.core.HashMapIter \x3d (function (nil_val,root_iter,seen){\nthis.nil_val \x3d nil_val;\nthis.root_iter \x3d root_iter;\nthis.seen \x3d seen;\n});\n(cljs.core.HashMapIter.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (((!(self__.seen))) || (self__.root_iter.hasNext()));\n}));\n\n(cljs.core.HashMapIter.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((!(self__.seen))){\n(self__.seen \x3d true);\n\nreturn (new cljs.core.MapEntry(null,self__.nil_val,null));\n} else {\nreturn self__.root_iter.next();\n}\n}));\n\n(cljs.core.HashMapIter.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.HashMapIter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22nil-val\x22,\x22nil-val\x22,-513933559,null),new cljs.core.Symbol(null,\x22root-iter\x22,\x22root-iter\x22,1974672108,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22seen\x22,\x22seen\x22,1121531738,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.HashMapIter.cljs$lang$type \x3d true);\n\n(cljs.core.HashMapIter.cljs$lang$ctorStr \x3d \x22cljs.core/HashMapIter\x22);\n\n(cljs.core.HashMapIter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/HashMapIter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/HashMapIter.\n */\ncljs.core.__GT_HashMapIter \x3d (function cljs$core$__GT_HashMapIter(nil_val,root_iter,seen){\nreturn (new cljs.core.HashMapIter(nil_val,root_iter,seen));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEditableCollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.PersistentHashMap \x3d (function (meta,cnt,root,has_nil_QMARK_,nil_val,__hash){\nthis.meta \x3d meta;\nthis.cnt \x3d cnt;\nthis.root \x3d root;\nthis.has_nil_QMARK_ \x3d has_nil_QMARK_;\nthis.nil_val \x3d nil_val;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 16123663;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139268;\n});\n(cljs.core.PersistentHashMap.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((k \x3d\x3d null)){\nif(self__.has_nil_QMARK_){\nreturn (new cljs.core.MapEntry(null,self__.nil_val,null));\n} else {\nreturn null;\n}\n} else {\nif((self__.root \x3d\x3d null)){\nreturn null;\n} else {\nreturn self__.root.inode_find((0),cljs.core.hash(k),k,null);\n\n}\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentHashMap.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentHashMap.prototype.keys \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator((cljs.core.keys.cljs$core$IFn$_invoke$arity$1 ? cljs.core.keys.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.keys.call(null, coll)));\n}));\n\n(cljs.core.PersistentHashMap.prototype.entries \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_entries_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentHashMap.prototype.values \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator((cljs.core.vals.cljs$core$IFn$_invoke$arity$1 ? cljs.core.vals.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.vals.call(null, coll)));\n}));\n\n(cljs.core.PersistentHashMap.prototype.has \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.contains_QMARK_(coll,k);\n}));\n\n(cljs.core.PersistentHashMap.prototype.get \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentHashMap.prototype.forEach \x3d (function (f){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar seq__18506 \x3d cljs.core.seq(coll);\nvar chunk__18507 \x3d null;\nvar count__18508 \x3d (0);\nvar i__18509 \x3d (0);\nwhile(true){\nif((i__18509 \x3c count__18508)){\nvar vec__18521 \x3d chunk__18507.cljs$core$IIndexed$_nth$arity$2(null, i__18509);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18521,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18521,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__25603 \x3d seq__18506;\nvar G__25604 \x3d chunk__18507;\nvar G__25605 \x3d count__18508;\nvar G__25606 \x3d (i__18509 + (1));\nseq__18506 \x3d G__25603;\nchunk__18507 \x3d G__25604;\ncount__18508 \x3d G__25605;\ni__18509 \x3d G__25606;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__18506);\nif(temp__5804__auto__){\nvar seq__18506__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__18506__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__18506__$1);\nvar G__25607 \x3d cljs.core.chunk_rest(seq__18506__$1);\nvar G__25608 \x3d c__5525__auto__;\nvar G__25609 \x3d cljs.core.count(c__5525__auto__);\nvar G__25610 \x3d (0);\nseq__18506 \x3d G__25607;\nchunk__18507 \x3d G__25608;\ncount__18508 \x3d G__25609;\ni__18509 \x3d G__25610;\ncontinue;\n} else {\nvar vec__18531 \x3d cljs.core.first(seq__18506__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18531,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18531,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__25612 \x3d cljs.core.next(seq__18506__$1);\nvar G__25613 \x3d null;\nvar G__25614 \x3d (0);\nvar G__25615 \x3d (0);\nseq__18506 \x3d G__25612;\nchunk__18507 \x3d G__25613;\ncount__18508 \x3d G__25614;\ni__18509 \x3d G__25615;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,k,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((k \x3d\x3d null)){\nif(self__.has_nil_QMARK_){\nreturn self__.nil_val;\n} else {\nreturn not_found;\n}\n} else {\nif((self__.root \x3d\x3d null)){\nreturn not_found;\n} else {\nreturn self__.root.inode_lookup((0),cljs.core.hash(k),k,not_found);\n\n}\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (coll,f,init){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar init__$1 \x3d ((self__.has_nil_QMARK_)?(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(init,null,self__.nil_val) : f.call(null, init,null,self__.nil_val)):init);\nif(cljs.core.reduced_QMARK_(init__$1)){\nreturn cljs.core.deref(init__$1);\n} else {\nif((!((self__.root \x3d\x3d null)))){\nreturn cljs.core.unreduced(self__.root.kv_reduce(f,init__$1));\n} else {\nreturn init__$1;\n\n}\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar root_iter \x3d ((self__.root)?cljs.core._iterator(self__.root):cljs.core.nil_iter());\nif(self__.has_nil_QMARK_){\nreturn (new cljs.core.HashMapIter(self__.nil_val,root_iter,false));\n} else {\nreturn root_iter;\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.PersistentHashMap(self__.meta,self__.cnt,self__.root,self__.has_nil_QMARK_,self__.nil_val,self__.__hash));\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.cnt;\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_unordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_map(coll__$1,other);\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.TransientHashMap(({}),self__.root,self__.cnt,self__.has_nil_QMARK_,self__.nil_val));\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.PersistentHashMap.EMPTY,self__.meta);\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((k \x3d\x3d null)){\nif(self__.has_nil_QMARK_){\nreturn (new cljs.core.PersistentHashMap(self__.meta,(self__.cnt - (1)),self__.root,false,null,null));\n} else {\nreturn coll__$1;\n}\n} else {\nif((self__.root \x3d\x3d null)){\nreturn coll__$1;\n} else {\nvar new_root \x3d self__.root.inode_without((0),cljs.core.hash(k),k);\nif((new_root \x3d\x3d\x3d self__.root)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentHashMap(self__.meta,(self__.cnt - (1)),new_root,self__.has_nil_QMARK_,self__.nil_val,null));\n}\n\n}\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (coll,k,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((k \x3d\x3d null)){\nif(((self__.has_nil_QMARK_) \x26\x26 ((v \x3d\x3d\x3d self__.nil_val)))){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentHashMap(self__.meta,((self__.has_nil_QMARK_)?self__.cnt:(self__.cnt + (1))),self__.root,true,v,null));\n}\n} else {\nvar added_leaf_QMARK_ \x3d (new cljs.core.Box(false));\nvar new_root \x3d (((self__.root \x3d\x3d null))?cljs.core.BitmapIndexedNode.EMPTY:self__.root).inode_assoc((0),cljs.core.hash(k),k,v,added_leaf_QMARK_);\nif((new_root \x3d\x3d\x3d self__.root)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentHashMap(self__.meta,((added_leaf_QMARK_.val)?(self__.cnt + (1)):self__.cnt),new_root,self__.has_nil_QMARK_,self__.nil_val,null));\n}\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((k \x3d\x3d null)){\nreturn self__.has_nil_QMARK_;\n} else {\nif((self__.root \x3d\x3d null)){\nreturn false;\n} else {\nreturn (!((self__.root.inode_lookup((0),cljs.core.hash(k),k,cljs.core.lookup_sentinel) \x3d\x3d\x3d cljs.core.lookup_sentinel)));\n\n}\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3e (0))){\nvar s \x3d (((!((self__.root \x3d\x3d null))))?self__.root.inode_seq():null);\nif(self__.has_nil_QMARK_){\nreturn cljs.core.cons((new cljs.core.MapEntry(null,self__.nil_val,null)),s);\n} else {\nreturn s;\n}\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentHashMap(new_meta,self__.cnt,self__.root,self__.has_nil_QMARK_,self__.nil_val,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,entry){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry)){\nreturn coll__$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry,(0)),cljs.core._nth(entry,(1)));\n} else {\nvar ret \x3d coll__$1;\nvar es \x3d cljs.core.seq(entry);\nwhile(true){\nif((es \x3d\x3d null)){\nreturn ret;\n} else {\nvar e \x3d cljs.core.first(es);\nif(cljs.core.vector_QMARK_(e)){\nvar G__25638 \x3d cljs.core._assoc(ret,cljs.core._nth(e,(0)),cljs.core._nth(e,(1)));\nvar G__25639 \x3d cljs.core.next(es);\nret \x3d G__25638;\nes \x3d G__25639;\ncontinue;\n} else {\nthrow (new Error(\x22conj on a map takes map entries or seqables of map entries\x22));\n}\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18551 \x3d (arguments.length - (1));\nswitch (G__18551) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.PersistentHashMap.prototype.apply \x3d (function (self__,args18500){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18500)));\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$2(null, k);\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentHashMap.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.Symbol(null,\x22root\x22,\x22root\x22,1191874074,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22has-nil?\x22,\x22has-nil?\x22,825886722,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22boolean\x22,\x22boolean\x22,-278886877,null)], null)),new cljs.core.Symbol(null,\x22nil-val\x22,\x22nil-val\x22,-513933559,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentHashMap.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentHashMap.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentHashMap\x22);\n\n(cljs.core.PersistentHashMap.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentHashMap\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentHashMap.\n */\ncljs.core.__GT_PersistentHashMap \x3d (function cljs$core$__GT_PersistentHashMap(meta,cnt,root,has_nil_QMARK_,nil_val,__hash){\nreturn (new cljs.core.PersistentHashMap(meta,cnt,root,has_nil_QMARK_,nil_val,__hash));\n});\n\n(cljs.core.PersistentHashMap.EMPTY \x3d (new cljs.core.PersistentHashMap(null,(0),null,false,null,cljs.core.empty_unordered_hash)));\n(cljs.core.PersistentHashMap.fromArray \x3d (function (arr,no_clone){\nvar arr__$1 \x3d ((no_clone)?arr:cljs.core.aclone(arr));\nvar len \x3d arr__$1.length;\nvar i \x3d (0);\nvar ret \x3d cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY);\nwhile(true){\nif((i \x3c len)){\nvar G__25651 \x3d (i + (2));\nvar G__25652 \x3d cljs.core._assoc_BANG_(ret,(arr__$1[i]),(arr__$1[(i + (1))]));\ni \x3d G__25651;\nret \x3d G__25652;\ncontinue;\n} else {\nreturn cljs.core._persistent_BANG_(ret);\n}\nbreak;\n}\n}));\n(cljs.core.PersistentHashMap.fromArrays \x3d (function (ks,vs){\nvar len \x3d ks.length;\nvar i \x3d (0);\nvar out \x3d cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY);\nwhile(true){\nif((i \x3c len)){\nif((vs.length \x3c\x3d i)){\nthrow (new Error([\x22No value supplied for key: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((ks[i]))].join(\x27\x27)));\n} else {\nvar G__25653 \x3d (i + (1));\nvar G__25654 \x3d cljs.core._assoc_BANG_(out,(ks[i]),(vs[i]));\ni \x3d G__25653;\nout \x3d G__25654;\ncontinue;\n}\n} else {\nreturn cljs.core.persistent_BANG_(out);\n}\nbreak;\n}\n}));\n(cljs.core.PersistentHashMap.createWithCheck \x3d (function (arr){\nvar len \x3d arr.length;\nvar ret \x3d cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY);\nvar i_25657 \x3d (0);\nwhile(true){\nif((i_25657 \x3c len)){\ncljs.core._assoc_BANG_(ret,(arr[i_25657]),(arr[(i_25657 + (1))]));\n\nif(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core._count(ret),((i_25657 / (2)) + (1)))){\nthrow (new Error([\x22Duplicate key: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arr[i_25657]))].join(\x27\x27)));\n} else {\nvar G__25660 \x3d (i_25657 + (2));\ni_25657 \x3d G__25660;\ncontinue;\n}\n} else {\n}\nbreak;\n}\n\nreturn cljs.core._persistent_BANG_(ret);\n}));\n(cljs.core.PersistentHashMap.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ITransientMap}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ITransientCollection}\n * @implements {cljs.core.ITransientAssociative}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.TransientHashMap \x3d (function (edit,root,count,has_nil_QMARK_,nil_val){\nthis.edit \x3d edit;\nthis.root \x3d root;\nthis.count \x3d count;\nthis.has_nil_QMARK_ \x3d has_nil_QMARK_;\nthis.nil_val \x3d nil_val;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 259;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 56;\n});\n(cljs.core.TransientHashMap.prototype.conj_BANG_ \x3d (function (o){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nif(self__.edit){\nif(cljs.core.map_entry_QMARK_(o)){\nreturn tcoll.assoc_BANG_((cljs.core.key.cljs$core$IFn$_invoke$arity$1 ? cljs.core.key.cljs$core$IFn$_invoke$arity$1(o) : cljs.core.key.call(null, o)),(cljs.core.val.cljs$core$IFn$_invoke$arity$1 ? cljs.core.val.cljs$core$IFn$_invoke$arity$1(o) : cljs.core.val.call(null, o)));\n} else {\nif(cljs.core.vector_QMARK_(o)){\nreturn tcoll.assoc_BANG_((o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((0)) : o.call(null, (0))),(o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((1)) : o.call(null, (1))));\n} else {\nvar es \x3d cljs.core.seq(o);\nvar tcoll__$1 \x3d tcoll;\nwhile(true){\nvar temp__5802__auto__ \x3d cljs.core.first(es);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar e \x3d temp__5802__auto__;\nvar G__25690 \x3d cljs.core.next(es);\nvar G__25691 \x3d tcoll__$1.assoc_BANG_((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.val.cljs$core$IFn$_invoke$arity$1 ? cljs.core.val.cljs$core$IFn$_invoke$arity$1(e) : cljs.core.val.call(null, e)));\nes \x3d G__25690;\ntcoll__$1 \x3d G__25691;\ncontinue;\n} else {\nreturn tcoll__$1;\n}\nbreak;\n}\n\n}\n}\n} else {\nthrow (new Error(\x22conj! after persistent\x22));\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.assoc_BANG_ \x3d (function (k,v){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nif(self__.edit){\nif((k \x3d\x3d null)){\nif((self__.nil_val \x3d\x3d\x3d v)){\n} else {\n(self__.nil_val \x3d v);\n}\n\nif(self__.has_nil_QMARK_){\n} else {\n(self__.count \x3d (self__.count + (1)));\n\n(self__.has_nil_QMARK_ \x3d true);\n}\n\nreturn tcoll;\n} else {\nvar added_leaf_QMARK_ \x3d (new cljs.core.Box(false));\nvar node \x3d (((self__.root \x3d\x3d null))?cljs.core.BitmapIndexedNode.EMPTY:self__.root).inode_assoc_BANG_(self__.edit,(0),cljs.core.hash(k),k,v,added_leaf_QMARK_);\nif((node \x3d\x3d\x3d self__.root)){\n} else {\n(self__.root \x3d node);\n}\n\nif(added_leaf_QMARK_.val){\n(self__.count \x3d (self__.count + (1)));\n} else {\n}\n\nreturn tcoll;\n}\n} else {\nthrow (new Error(\x22assoc! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.without_BANG_ \x3d (function (k){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nif(self__.edit){\nif((k \x3d\x3d null)){\nif(self__.has_nil_QMARK_){\n(self__.has_nil_QMARK_ \x3d false);\n\n(self__.nil_val \x3d null);\n\n(self__.count \x3d (self__.count - (1)));\n\nreturn tcoll;\n} else {\nreturn tcoll;\n}\n} else {\nif((self__.root \x3d\x3d null)){\nreturn tcoll;\n} else {\nvar removed_leaf_QMARK_ \x3d (new cljs.core.Box(false));\nvar node \x3d self__.root.inode_without_BANG_(self__.edit,(0),cljs.core.hash(k),k,removed_leaf_QMARK_);\nif((node \x3d\x3d\x3d self__.root)){\n} else {\n(self__.root \x3d node);\n}\n\nif(removed_leaf_QMARK_.val){\n(self__.count \x3d (self__.count - (1)));\n} else {\n}\n\nreturn tcoll;\n}\n}\n} else {\nthrow (new Error(\x22dissoc! after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.persistent_BANG_ \x3d (function (){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nif(self__.edit){\n(self__.edit \x3d null);\n\nreturn (new cljs.core.PersistentHashMap(null,self__.count,self__.root,self__.has_nil_QMARK_,self__.nil_val,null));\n} else {\nthrow (new Error(\x22persistent! called twice\x22));\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(self__.edit){\nreturn self__.count;\n} else {\nthrow (new Error(\x22count after persistent!\x22));\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (tcoll,k){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif((k \x3d\x3d null)){\nif(self__.has_nil_QMARK_){\nreturn self__.nil_val;\n} else {\nreturn null;\n}\n} else {\nif((self__.root \x3d\x3d null)){\nreturn null;\n} else {\nreturn self__.root.inode_lookup((0),cljs.core.hash(k),k);\n}\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (tcoll,k,not_found){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif((k \x3d\x3d null)){\nif(self__.has_nil_QMARK_){\nreturn self__.nil_val;\n} else {\nreturn not_found;\n}\n} else {\nif((self__.root \x3d\x3d null)){\nreturn not_found;\n} else {\nreturn self__.root.inode_lookup((0),cljs.core.hash(k),k,not_found);\n}\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 \x3d (function (tcoll,val){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn tcoll__$1.conj_BANG_(val);\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 \x3d (function (tcoll){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn tcoll__$1.persistent_BANG_();\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 \x3d (function (tcoll,key,val){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn tcoll__$1.assoc_BANG_(key,val);\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 \x3d (function (tcoll,key){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn tcoll__$1.without_BANG_(key);\n}));\n\n(cljs.core.TransientHashMap.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18643 \x3d (arguments.length - (1));\nswitch (G__18643) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.TransientHashMap.prototype.apply \x3d (function (self__,args18599){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18599)));\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (key){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nreturn tcoll.cljs$core$ILookup$_lookup$arity$2(null, key);\n}));\n\n(cljs.core.TransientHashMap.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (key,not_found){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nreturn tcoll.cljs$core$ILookup$_lookup$arity$3(null, key,not_found);\n}));\n\n(cljs.core.TransientHashMap.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22edit\x22,\x22edit\x22,-1302639,null),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22boolean\x22,\x22boolean\x22,-278886877,null),new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22root\x22,\x22root\x22,1191874074,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22count\x22,\x22count\x22,-514511684,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22has-nil?\x22,\x22has-nil?\x22,825886722,null),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22boolean\x22,\x22boolean\x22,-278886877,null),new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22nil-val\x22,\x22nil-val\x22,-513933559,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.TransientHashMap.cljs$lang$type \x3d true);\n\n(cljs.core.TransientHashMap.cljs$lang$ctorStr \x3d \x22cljs.core/TransientHashMap\x22);\n\n(cljs.core.TransientHashMap.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/TransientHashMap\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/TransientHashMap.\n */\ncljs.core.__GT_TransientHashMap \x3d (function cljs$core$__GT_TransientHashMap(edit,root,count,has_nil_QMARK_,nil_val){\nreturn (new cljs.core.TransientHashMap(edit,root,count,has_nil_QMARK_,nil_val));\n});\n\ncljs.core.tree_map_seq_push \x3d (function cljs$core$tree_map_seq_push(node,stack,ascending_QMARK_){\nvar t \x3d node;\nvar stack__$1 \x3d stack;\nwhile(true){\nif((!((t \x3d\x3d null)))){\nvar G__25716 \x3d ((ascending_QMARK_)?t.left:t.right);\nvar G__25717 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack__$1,t);\nt \x3d G__25716;\nstack__$1 \x3d G__25717;\ncontinue;\n} else {\nreturn stack__$1;\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.PersistentTreeMapSeq \x3d (function (meta,stack,ascending_QMARK_,cnt,__hash){\nthis.meta \x3d meta;\nthis.stack \x3d stack;\nthis.ascending_QMARK_ \x3d ascending_QMARK_;\nthis.cnt \x3d cnt;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374990;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.PersistentTreeMapSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.indexOf \x3d (function() {\nvar G__25721 \x3d null;\nvar G__25721__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25721__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25721 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25721__1.call(this,x);\ncase 2:\nreturn G__25721__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25721.cljs$core$IFn$_invoke$arity$1 \x3d G__25721__1;\nG__25721.cljs$core$IFn$_invoke$arity$2 \x3d G__25721__2;\nreturn G__25721;\n})()\n);\n\n(cljs.core.PersistentTreeMapSeq.prototype.lastIndexOf \x3d (function() {\nvar G__25729 \x3d null;\nvar G__25729__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25729__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25729 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25729__1.call(this,x);\ncase 2:\nreturn G__25729__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25729.cljs$core$IFn$_invoke$arity$1 \x3d G__25729__1;\nG__25729.cljs$core$IFn$_invoke$arity$2 \x3d G__25729__2;\nreturn G__25729;\n})()\n);\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar t \x3d cljs.core.first(self__.stack);\nvar next_stack \x3d cljs.core.tree_map_seq_push(((self__.ascending_QMARK_)?t.right:t.left),cljs.core.next(self__.stack),self__.ascending_QMARK_);\nif((next_stack \x3d\x3d null)){\nreturn null;\n} else {\nreturn (new cljs.core.PersistentTreeMapSeq(null,next_stack,self__.ascending_QMARK_,(self__.cnt - (1)),null));\n}\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3c (0))){\nreturn (cljs.core.count(cljs.core.next(coll__$1)) + (1));\n} else {\nreturn self__.cnt;\n}\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core.peek(self__.stack);\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar t \x3d cljs.core.first(self__.stack);\nvar next_stack \x3d cljs.core.tree_map_seq_push(((self__.ascending_QMARK_)?t.right:t.left),cljs.core.next(self__.stack),self__.ascending_QMARK_);\nif((!((next_stack \x3d\x3d null)))){\nreturn (new cljs.core.PersistentTreeMapSeq(null,next_stack,self__.ascending_QMARK_,(self__.cnt - (1)),null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn this$__$1;\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentTreeMapSeq(new_meta,self__.stack,self__.ascending_QMARK_,self__.cnt,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.PersistentTreeMapSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22stack\x22,\x22stack\x22,847125597,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22ascending?\x22,\x22ascending?\x22,-1938452653,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22boolean\x22,\x22boolean\x22,-278886877,null)], null)),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentTreeMapSeq.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentTreeMapSeq.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentTreeMapSeq\x22);\n\n(cljs.core.PersistentTreeMapSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentTreeMapSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentTreeMapSeq.\n */\ncljs.core.__GT_PersistentTreeMapSeq \x3d (function cljs$core$__GT_PersistentTreeMapSeq(meta,stack,ascending_QMARK_,cnt,__hash){\nreturn (new cljs.core.PersistentTreeMapSeq(meta,stack,ascending_QMARK_,cnt,__hash));\n});\n\n(cljs.core.PersistentTreeMapSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.create_tree_map_seq \x3d (function cljs$core$create_tree_map_seq(tree,ascending_QMARK_,cnt){\nreturn (new cljs.core.PersistentTreeMapSeq(null,cljs.core.tree_map_seq_push(tree,null,ascending_QMARK_),ascending_QMARK_,cnt,null));\n});\n\ncljs.core.balance_left \x3d (function cljs$core$balance_left(key,val,ins,right){\nif((ins instanceof cljs.core.RedNode)){\nif((ins.left instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(ins.key,ins.val,ins.left.blacken(),(new cljs.core.BlackNode(key,val,ins.right,right,null)),null));\n} else {\nif((ins.right instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(ins.right.key,ins.right.val,(new cljs.core.BlackNode(ins.key,ins.val,ins.left,ins.right.left,null)),(new cljs.core.BlackNode(key,val,ins.right.right,right,null)),null));\n} else {\nreturn (new cljs.core.BlackNode(key,val,ins,right,null));\n\n}\n}\n} else {\nreturn (new cljs.core.BlackNode(key,val,ins,right,null));\n}\n});\ncljs.core.balance_right \x3d (function cljs$core$balance_right(key,val,left,ins){\nif((ins instanceof cljs.core.RedNode)){\nif((ins.right instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(ins.key,ins.val,(new cljs.core.BlackNode(key,val,left,ins.left,null)),ins.right.blacken(),null));\n} else {\nif((ins.left instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(ins.left.key,ins.left.val,(new cljs.core.BlackNode(key,val,left,ins.left.left,null)),(new cljs.core.BlackNode(ins.key,ins.val,ins.left.right,ins.right,null)),null));\n} else {\nreturn (new cljs.core.BlackNode(key,val,left,ins,null));\n\n}\n}\n} else {\nreturn (new cljs.core.BlackNode(key,val,left,ins,null));\n}\n});\ncljs.core.balance_left_del \x3d (function cljs$core$balance_left_del(key,val,del,right){\nif((del instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(key,val,del.blacken(),right,null));\n} else {\nif((right instanceof cljs.core.BlackNode)){\nreturn cljs.core.balance_right(key,val,del,right.redden());\n} else {\nif((((right instanceof cljs.core.RedNode)) \x26\x26 ((right.left instanceof cljs.core.BlackNode)))){\nreturn (new cljs.core.RedNode(right.left.key,right.left.val,(new cljs.core.BlackNode(key,val,del,right.left.left,null)),cljs.core.balance_right(right.key,right.val,right.left.right,right.right.redden()),null));\n} else {\nthrow (new Error(\x22red-black tree invariant violation\x22));\n\n}\n}\n}\n});\ncljs.core.balance_right_del \x3d (function cljs$core$balance_right_del(key,val,left,del){\nif((del instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(key,val,left,del.blacken(),null));\n} else {\nif((left instanceof cljs.core.BlackNode)){\nreturn cljs.core.balance_left(key,val,left.redden(),del);\n} else {\nif((((left instanceof cljs.core.RedNode)) \x26\x26 ((left.right instanceof cljs.core.BlackNode)))){\nreturn (new cljs.core.RedNode(left.right.key,left.right.val,cljs.core.balance_left(left.key,left.val,left.left.redden(),left.right.left),(new cljs.core.BlackNode(key,val,left.right.right,del,null)),null));\n} else {\nthrow (new Error(\x22red-black tree invariant violation\x22));\n\n}\n}\n}\n});\ncljs.core.tree_map_kv_reduce \x3d (function cljs$core$tree_map_kv_reduce(node,f,init){\nvar init__$1 \x3d (((!((node.left \x3d\x3d null))))?(function (){var G__18687 \x3d node.left;\nvar G__18688 \x3d f;\nvar G__18689 \x3d init;\nreturn (cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3 ? cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3(G__18687,G__18688,G__18689) : cljs.core.tree_map_kv_reduce.call(null, G__18687,G__18688,G__18689));\n})():init);\nif(cljs.core.reduced_QMARK_(init__$1)){\nreturn init__$1;\n} else {\nvar init__$2 \x3d (function (){var G__18690 \x3d init__$1;\nvar G__18691 \x3d node.key;\nvar G__18692 \x3d node.val;\nreturn (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__18690,G__18691,G__18692) : f.call(null, G__18690,G__18691,G__18692));\n})();\nif(cljs.core.reduced_QMARK_(init__$2)){\nreturn init__$2;\n} else {\nif((!((node.right \x3d\x3d null)))){\nvar G__18693 \x3d node.right;\nvar G__18694 \x3d f;\nvar G__18695 \x3d init__$2;\nreturn (cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3 ? cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3(G__18693,G__18694,G__18695) : cljs.core.tree_map_kv_reduce.call(null, G__18693,G__18694,G__18695));\n} else {\nreturn init__$2;\n}\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IVector}\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.IMapEntry}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.ILookup}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.BlackNode \x3d (function (key,val,left,right,__hash){\nthis.key \x3d key;\nthis.val \x3d val;\nthis.left \x3d left;\nthis.right \x3d right;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 166619935;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.BlackNode.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.BlackNode.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nvar G__18702 \x3d k;\nswitch (G__18702) {\ncase (0):\nreturn (new cljs.core.MapEntry((0),self__.key,null));\n\nbreak;\ncase (1):\nreturn (new cljs.core.MapEntry((1),self__.val,null));\n\nbreak;\ndefault:\nreturn null;\n\n}\n}));\n\n(cljs.core.BlackNode.prototype.lastIndexOf \x3d (function() {\nvar G__25769 \x3d null;\nvar G__25769__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25769__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25769 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25769__1.call(this,x);\ncase 2:\nreturn G__25769__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25769.cljs$core$IFn$_invoke$arity$1 \x3d G__25769__1;\nG__25769.cljs$core$IFn$_invoke$arity$2 \x3d G__25769__2;\nreturn G__25769;\n})()\n);\n\n(cljs.core.BlackNode.prototype.indexOf \x3d (function() {\nvar G__25770 \x3d null;\nvar G__25770__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25770__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25770 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25770__1.call(this,x);\ncase 2:\nreturn G__25770__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25770.cljs$core$IFn$_invoke$arity$1 \x3d G__25770__1;\nG__25770.cljs$core$IFn$_invoke$arity$2 \x3d G__25770__2;\nreturn G__25770;\n})()\n);\n\n(cljs.core.BlackNode.prototype.add_right \x3d (function (ins){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn ins.balance_right(node);\n}));\n\n(cljs.core.BlackNode.prototype.redden \x3d (function (){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.RedNode(self__.key,self__.val,self__.left,self__.right,null));\n}));\n\n(cljs.core.BlackNode.prototype.blacken \x3d (function (){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn node;\n}));\n\n(cljs.core.BlackNode.prototype.add_left \x3d (function (ins){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn ins.balance_left(node);\n}));\n\n(cljs.core.BlackNode.prototype.replace \x3d (function (key__$1,val__$1,left__$1,right__$1){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.BlackNode(key__$1,val__$1,left__$1,right__$1,null));\n}));\n\n(cljs.core.BlackNode.prototype.balance_left \x3d (function (parent){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.BlackNode(parent.key,parent.val,node,parent.right,null));\n}));\n\n(cljs.core.BlackNode.prototype.balance_right \x3d (function (parent){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.BlackNode(parent.key,parent.val,parent.left,node,null));\n}));\n\n(cljs.core.BlackNode.prototype.remove_left \x3d (function (del){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn cljs.core.balance_left_del(self__.key,self__.val,del,self__.right);\n}));\n\n(cljs.core.BlackNode.prototype.kv_reduce \x3d (function (f,init){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn cljs.core.tree_map_kv_reduce(node,f,init);\n}));\n\n(cljs.core.BlackNode.prototype.remove_right \x3d (function (del){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn cljs.core.balance_right_del(self__.key,self__.val,self__.left,del);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn node__$1.cljs$core$IIndexed$_nth$arity$3(null, k,null);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (node,k,not_found){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn node__$1.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (node,n){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nif((n \x3d\x3d\x3d (0))){\nreturn self__.key;\n} else {\nif((n \x3d\x3d\x3d (1))){\nreturn self__.val;\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n\n}\n}\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (node,n,not_found){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nif((n \x3d\x3d\x3d (0))){\nreturn self__.key;\n} else {\nif((n \x3d\x3d\x3d (1))){\nreturn self__.val;\n} else {\nreturn not_found;\n\n}\n}\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IVector$_assoc_n$arity$3 \x3d (function (node,n,v){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null).cljs$core$IVector$_assoc_n$arity$3(null, n,v);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (2);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_key$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.key;\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_val$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (new cljs.core.IndexedSeq([self__.val,self__.key],(0),null));\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (node,f){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(node__$1,f);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (node,f,start){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(node__$1,f,start);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (node,k,v){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),k,v);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (((k \x3d\x3d\x3d (0))) || ((k \x3d\x3d\x3d (1))));\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (new cljs.core.IndexedSeq([self__.key,self__.val],(0),null));\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (node,meta){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core._with_meta(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),meta);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (node,o){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val,o], null);\n}));\n\n(cljs.core.BlackNode.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18768 \x3d (arguments.length - (1));\nswitch (G__18768) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.BlackNode.prototype.apply \x3d (function (self__,args18699){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18699)));\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn node.cljs$core$IIndexed$_nth$arity$2(null, k);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn node.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n}));\n\n(cljs.core.BlackNode.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22key\x22,\x22key\x22,124488940,null),new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.Symbol(null,\x22left\x22,\x22left\x22,1241415590,null),new cljs.core.Symbol(null,\x22right\x22,\x22right\x22,1187949694,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.BlackNode.cljs$lang$type \x3d true);\n\n(cljs.core.BlackNode.cljs$lang$ctorStr \x3d \x22cljs.core/BlackNode\x22);\n\n(cljs.core.BlackNode.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/BlackNode\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/BlackNode.\n */\ncljs.core.__GT_BlackNode \x3d (function cljs$core$__GT_BlackNode(key,val,left,right,__hash){\nreturn (new cljs.core.BlackNode(key,val,left,right,__hash));\n});\n\n(cljs.core.BlackNode.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IVector}\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IStack}\n * @implements {cljs.core.IMapEntry}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.ILookup}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.RedNode \x3d (function (key,val,left,right,__hash){\nthis.key \x3d key;\nthis.val \x3d val;\nthis.left \x3d left;\nthis.right \x3d right;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 166619935;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.RedNode.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.RedNode.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nvar G__18788 \x3d k;\nswitch (G__18788) {\ncase (0):\nreturn (new cljs.core.MapEntry((0),self__.key,null));\n\nbreak;\ncase (1):\nreturn (new cljs.core.MapEntry((1),self__.val,null));\n\nbreak;\ndefault:\nreturn null;\n\n}\n}));\n\n(cljs.core.RedNode.prototype.lastIndexOf \x3d (function() {\nvar G__25786 \x3d null;\nvar G__25786__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25786__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25786 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25786__1.call(this,x);\ncase 2:\nreturn G__25786__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25786.cljs$core$IFn$_invoke$arity$1 \x3d G__25786__1;\nG__25786.cljs$core$IFn$_invoke$arity$2 \x3d G__25786__2;\nreturn G__25786;\n})()\n);\n\n(cljs.core.RedNode.prototype.indexOf \x3d (function() {\nvar G__25787 \x3d null;\nvar G__25787__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25787__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25787 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25787__1.call(this,x);\ncase 2:\nreturn G__25787__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25787.cljs$core$IFn$_invoke$arity$1 \x3d G__25787__1;\nG__25787.cljs$core$IFn$_invoke$arity$2 \x3d G__25787__2;\nreturn G__25787;\n})()\n);\n\n(cljs.core.RedNode.prototype.add_right \x3d (function (ins){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.RedNode(self__.key,self__.val,self__.left,ins,null));\n}));\n\n(cljs.core.RedNode.prototype.redden \x3d (function (){\nvar self__ \x3d this;\nvar node \x3d this;\nthrow (new Error(\x22red-black tree invariant violation\x22));\n}));\n\n(cljs.core.RedNode.prototype.blacken \x3d (function (){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.BlackNode(self__.key,self__.val,self__.left,self__.right,null));\n}));\n\n(cljs.core.RedNode.prototype.add_left \x3d (function (ins){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.RedNode(self__.key,self__.val,ins,self__.right,null));\n}));\n\n(cljs.core.RedNode.prototype.replace \x3d (function (key__$1,val__$1,left__$1,right__$1){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.RedNode(key__$1,val__$1,left__$1,right__$1,null));\n}));\n\n(cljs.core.RedNode.prototype.balance_left \x3d (function (parent){\nvar self__ \x3d this;\nvar node \x3d this;\nif((self__.left instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(self__.key,self__.val,self__.left.blacken(),(new cljs.core.BlackNode(parent.key,parent.val,self__.right,parent.right,null)),null));\n} else {\nif((self__.right instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(self__.right.key,self__.right.val,(new cljs.core.BlackNode(self__.key,self__.val,self__.left,self__.right.left,null)),(new cljs.core.BlackNode(parent.key,parent.val,self__.right.right,parent.right,null)),null));\n} else {\nreturn (new cljs.core.BlackNode(parent.key,parent.val,node,parent.right,null));\n\n}\n}\n}));\n\n(cljs.core.RedNode.prototype.balance_right \x3d (function (parent){\nvar self__ \x3d this;\nvar node \x3d this;\nif((self__.right instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(self__.key,self__.val,(new cljs.core.BlackNode(parent.key,parent.val,parent.left,self__.left,null)),self__.right.blacken(),null));\n} else {\nif((self__.left instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(self__.left.key,self__.left.val,(new cljs.core.BlackNode(parent.key,parent.val,parent.left,self__.left.left,null)),(new cljs.core.BlackNode(self__.key,self__.val,self__.left.right,self__.right,null)),null));\n} else {\nreturn (new cljs.core.BlackNode(parent.key,parent.val,parent.left,node,null));\n\n}\n}\n}));\n\n(cljs.core.RedNode.prototype.remove_left \x3d (function (del){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.RedNode(self__.key,self__.val,del,self__.right,null));\n}));\n\n(cljs.core.RedNode.prototype.kv_reduce \x3d (function (f,init){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn cljs.core.tree_map_kv_reduce(node,f,init);\n}));\n\n(cljs.core.RedNode.prototype.remove_right \x3d (function (del){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn (new cljs.core.RedNode(self__.key,self__.val,self__.left,del,null));\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn node__$1.cljs$core$IIndexed$_nth$arity$3(null, k,null);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (node,k,not_found){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn node__$1.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (node,n){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nif((n \x3d\x3d\x3d (0))){\nreturn self__.key;\n} else {\nif((n \x3d\x3d\x3d (1))){\nreturn self__.val;\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n\n}\n}\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (node,n,not_found){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nif((n \x3d\x3d\x3d (0))){\nreturn self__.key;\n} else {\nif((n \x3d\x3d\x3d (1))){\nreturn self__.val;\n} else {\nreturn not_found;\n\n}\n}\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IVector$_assoc_n$arity$3 \x3d (function (node,n,v){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null).cljs$core$IVector$_assoc_n$arity$3(null, n,v);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (2);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IMapEntry$_key$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.key;\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IMapEntry$_val$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IStack$_peek$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IStack$_pop$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (new cljs.core.IndexedSeq([self__.val,self__.key],(0),null));\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (node,f){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(node__$1,f);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (node,f,start){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(node__$1,f,start);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (node,k,v){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),k,v);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (node,k){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (((k \x3d\x3d\x3d (0))) || ((k \x3d\x3d\x3d (1))));\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (node){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn (new cljs.core.IndexedSeq([self__.key,self__.val],(0),null));\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (node,meta){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn cljs.core._with_meta(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),meta);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (node,o){\nvar self__ \x3d this;\nvar node__$1 \x3d this;\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val,o], null);\n}));\n\n(cljs.core.RedNode.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__18821 \x3d (arguments.length - (1));\nswitch (G__18821) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.RedNode.prototype.apply \x3d (function (self__,args18784){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18784)));\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn node.cljs$core$IIndexed$_nth$arity$2(null, k);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar node \x3d this;\nreturn node.cljs$core$IIndexed$_nth$arity$3(null, k,not_found);\n}));\n\n(cljs.core.RedNode.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22key\x22,\x22key\x22,124488940,null),new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.Symbol(null,\x22left\x22,\x22left\x22,1241415590,null),new cljs.core.Symbol(null,\x22right\x22,\x22right\x22,1187949694,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.RedNode.cljs$lang$type \x3d true);\n\n(cljs.core.RedNode.cljs$lang$ctorStr \x3d \x22cljs.core/RedNode\x22);\n\n(cljs.core.RedNode.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/RedNode\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/RedNode.\n */\ncljs.core.__GT_RedNode \x3d (function cljs$core$__GT_RedNode(key,val,left,right,__hash){\nreturn (new cljs.core.RedNode(key,val,left,right,__hash));\n});\n\n(cljs.core.RedNode.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.tree_map_add \x3d (function cljs$core$tree_map_add(comp,tree,k,v,found){\nif((tree \x3d\x3d null)){\nreturn (new cljs.core.RedNode(k,v,null,null,null));\n} else {\nvar c \x3d (function (){var G__18833 \x3d k;\nvar G__18834 \x3d tree.key;\nreturn (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(G__18833,G__18834) : comp.call(null, G__18833,G__18834));\n})();\nif((c \x3d\x3d\x3d (0))){\n(found[(0)] \x3d tree);\n\nreturn null;\n} else {\nif((c \x3c (0))){\nvar ins \x3d (function (){var G__18836 \x3d comp;\nvar G__18837 \x3d tree.left;\nvar G__18838 \x3d k;\nvar G__18839 \x3d v;\nvar G__18840 \x3d found;\nreturn (cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5 ? cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5(G__18836,G__18837,G__18838,G__18839,G__18840) : cljs.core.tree_map_add.call(null, G__18836,G__18837,G__18838,G__18839,G__18840));\n})();\nif((!((ins \x3d\x3d null)))){\nreturn tree.add_left(ins);\n} else {\nreturn null;\n}\n} else {\nvar ins \x3d (function (){var G__18845 \x3d comp;\nvar G__18846 \x3d tree.right;\nvar G__18847 \x3d k;\nvar G__18848 \x3d v;\nvar G__18849 \x3d found;\nreturn (cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5 ? cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5(G__18845,G__18846,G__18847,G__18848,G__18849) : cljs.core.tree_map_add.call(null, G__18845,G__18846,G__18847,G__18848,G__18849));\n})();\nif((!((ins \x3d\x3d null)))){\nreturn tree.add_right(ins);\n} else {\nreturn null;\n}\n\n}\n}\n}\n});\ncljs.core.tree_map_append \x3d (function cljs$core$tree_map_append(left,right){\nif((left \x3d\x3d null)){\nreturn right;\n} else {\nif((right \x3d\x3d null)){\nreturn left;\n} else {\nif((left instanceof cljs.core.RedNode)){\nif((right instanceof cljs.core.RedNode)){\nvar app \x3d (function (){var G__18856 \x3d left.right;\nvar G__18857 \x3d right.left;\nreturn (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__18856,G__18857) : cljs.core.tree_map_append.call(null, G__18856,G__18857));\n})();\nif((app instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(app.key,app.val,(new cljs.core.RedNode(left.key,left.val,left.left,app.left,null)),(new cljs.core.RedNode(right.key,right.val,app.right,right.right,null)),null));\n} else {\nreturn (new cljs.core.RedNode(left.key,left.val,left.left,(new cljs.core.RedNode(right.key,right.val,app,right.right,null)),null));\n}\n} else {\nreturn (new cljs.core.RedNode(left.key,left.val,left.left,(function (){var G__18861 \x3d left.right;\nvar G__18862 \x3d right;\nreturn (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__18861,G__18862) : cljs.core.tree_map_append.call(null, G__18861,G__18862));\n})(),null));\n}\n} else {\nif((right instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(right.key,right.val,(function (){var G__18863 \x3d left;\nvar G__18864 \x3d right.left;\nreturn (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__18863,G__18864) : cljs.core.tree_map_append.call(null, G__18863,G__18864));\n})(),right.right,null));\n} else {\nvar app \x3d (function (){var G__18865 \x3d left.right;\nvar G__18866 \x3d right.left;\nreturn (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__18865,G__18866) : cljs.core.tree_map_append.call(null, G__18865,G__18866));\n})();\nif((app instanceof cljs.core.RedNode)){\nreturn (new cljs.core.RedNode(app.key,app.val,(new cljs.core.BlackNode(left.key,left.val,left.left,app.left,null)),(new cljs.core.BlackNode(right.key,right.val,app.right,right.right,null)),null));\n} else {\nreturn cljs.core.balance_left_del(left.key,left.val,left.left,(new cljs.core.BlackNode(right.key,right.val,app,right.right,null)));\n}\n\n}\n}\n}\n}\n});\ncljs.core.tree_map_remove \x3d (function cljs$core$tree_map_remove(comp,tree,k,found){\nif((!((tree \x3d\x3d null)))){\nvar c \x3d (function (){var G__18874 \x3d k;\nvar G__18875 \x3d tree.key;\nreturn (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(G__18874,G__18875) : comp.call(null, G__18874,G__18875));\n})();\nif((c \x3d\x3d\x3d (0))){\n(found[(0)] \x3d tree);\n\nreturn cljs.core.tree_map_append(tree.left,tree.right);\n} else {\nif((c \x3c (0))){\nvar del \x3d (function (){var G__18877 \x3d comp;\nvar G__18878 \x3d tree.left;\nvar G__18879 \x3d k;\nvar G__18880 \x3d found;\nreturn (cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4(G__18877,G__18878,G__18879,G__18880) : cljs.core.tree_map_remove.call(null, G__18877,G__18878,G__18879,G__18880));\n})();\nif((((!((del \x3d\x3d null)))) || ((!(((found[(0)]) \x3d\x3d null)))))){\nif((tree.left instanceof cljs.core.BlackNode)){\nreturn cljs.core.balance_left_del(tree.key,tree.val,del,tree.right);\n} else {\nreturn (new cljs.core.RedNode(tree.key,tree.val,del,tree.right,null));\n}\n} else {\nreturn null;\n}\n} else {\nvar del \x3d (function (){var G__18887 \x3d comp;\nvar G__18888 \x3d tree.right;\nvar G__18889 \x3d k;\nvar G__18890 \x3d found;\nreturn (cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4(G__18887,G__18888,G__18889,G__18890) : cljs.core.tree_map_remove.call(null, G__18887,G__18888,G__18889,G__18890));\n})();\nif((((!((del \x3d\x3d null)))) || ((!(((found[(0)]) \x3d\x3d null)))))){\nif((tree.right instanceof cljs.core.BlackNode)){\nreturn cljs.core.balance_right_del(tree.key,tree.val,tree.left,del);\n} else {\nreturn (new cljs.core.RedNode(tree.key,tree.val,tree.left,del,null));\n}\n} else {\nreturn null;\n}\n\n}\n}\n} else {\nreturn null;\n}\n});\ncljs.core.tree_map_replace \x3d (function cljs$core$tree_map_replace(comp,tree,k,v){\nvar tk \x3d tree.key;\nvar c \x3d (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(k,tk) : comp.call(null, k,tk));\nif((c \x3d\x3d\x3d (0))){\nreturn tree.replace(tk,v,tree.left,tree.right);\n} else {\nif((c \x3c (0))){\nreturn tree.replace(tk,tree.val,(function (){var G__18898 \x3d comp;\nvar G__18899 \x3d tree.left;\nvar G__18900 \x3d k;\nvar G__18901 \x3d v;\nreturn (cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4(G__18898,G__18899,G__18900,G__18901) : cljs.core.tree_map_replace.call(null, G__18898,G__18899,G__18900,G__18901));\n})(),tree.right);\n} else {\nreturn tree.replace(tk,tree.val,tree.left,(function (){var G__18902 \x3d comp;\nvar G__18903 \x3d tree.right;\nvar G__18904 \x3d k;\nvar G__18905 \x3d v;\nreturn (cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4(G__18902,G__18903,G__18904,G__18905) : cljs.core.tree_map_replace.call(null, G__18902,G__18903,G__18904,G__18905));\n})());\n\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IFind}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISorted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.PersistentTreeMap \x3d (function (comp,tree,cnt,meta,__hash){\nthis.comp \x3d comp;\nthis.tree \x3d tree;\nthis.cnt \x3d cnt;\nthis.meta \x3d meta;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 418776847;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 8192;\n});\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IFind$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IFind$_find$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.entry_at(k);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.forEach \x3d (function (f){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar seq__18925 \x3d cljs.core.seq(coll);\nvar chunk__18926 \x3d null;\nvar count__18927 \x3d (0);\nvar i__18928 \x3d (0);\nwhile(true){\nif((i__18928 \x3c count__18927)){\nvar vec__18945 \x3d chunk__18926.cljs$core$IIndexed$_nth$arity$2(null, i__18928);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18945,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18945,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__25812 \x3d seq__18925;\nvar G__25813 \x3d chunk__18926;\nvar G__25814 \x3d count__18927;\nvar G__25815 \x3d (i__18928 + (1));\nseq__18925 \x3d G__25812;\nchunk__18926 \x3d G__25813;\ncount__18927 \x3d G__25814;\ni__18928 \x3d G__25815;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__18925);\nif(temp__5804__auto__){\nvar seq__18925__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__18925__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__18925__$1);\nvar G__25816 \x3d cljs.core.chunk_rest(seq__18925__$1);\nvar G__25817 \x3d c__5525__auto__;\nvar G__25818 \x3d cljs.core.count(c__5525__auto__);\nvar G__25819 \x3d (0);\nseq__18925 \x3d G__25816;\nchunk__18926 \x3d G__25817;\ncount__18927 \x3d G__25818;\ni__18928 \x3d G__25819;\ncontinue;\n} else {\nvar vec__18955 \x3d cljs.core.first(seq__18925__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18955,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__18955,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__25823 \x3d cljs.core.next(seq__18925__$1);\nvar G__25824 \x3d null;\nvar G__25825 \x3d (0);\nvar G__25826 \x3d (0);\nseq__18925 \x3d G__25823;\nchunk__18926 \x3d G__25824;\ncount__18927 \x3d G__25825;\ni__18928 \x3d G__25826;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.get \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.entries \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_entries_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.keys \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator((cljs.core.keys.cljs$core$IFn$_invoke$arity$1 ? cljs.core.keys.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.keys.call(null, coll)));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.values \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator((cljs.core.vals.cljs$core$IFn$_invoke$arity$1 ? cljs.core.vals.cljs$core$IFn$_invoke$arity$1(coll) : cljs.core.vals.call(null, coll)));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.entry_at \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar t \x3d self__.tree;\nwhile(true){\nif((!((t \x3d\x3d null)))){\nvar c \x3d (function (){var G__18976 \x3d k;\nvar G__18977 \x3d t.key;\nreturn (self__.comp.cljs$core$IFn$_invoke$arity$2 ? self__.comp.cljs$core$IFn$_invoke$arity$2(G__18976,G__18977) : self__.comp.call(null, G__18976,G__18977));\n})();\nif((c \x3d\x3d\x3d (0))){\nreturn t;\n} else {\nif((c \x3c (0))){\nvar G__25827 \x3d t.left;\nt \x3d G__25827;\ncontinue;\n} else {\nvar G__25828 \x3d t.right;\nt \x3d G__25828;\ncontinue;\n\n}\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.has \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.contains_QMARK_(coll,k);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k,null);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,k,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar n \x3d coll__$1.entry_at(k);\nif((!((n \x3d\x3d null)))){\nreturn n.val;\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (coll,f,init){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((!((self__.tree \x3d\x3d null)))){\nreturn cljs.core.unreduced(cljs.core.tree_map_kv_reduce(self__.tree,f,init));\n} else {\nreturn init;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.PersistentTreeMap(self__.comp,self__.tree,self__.cnt,self__.meta,self__.__hash));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.cnt;\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3e (0))){\nreturn cljs.core.create_tree_map_seq(self__.tree,false,self__.cnt);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_unordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_map(coll__$1,other);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentTreeMap(self__.comp,null,(0),self__.meta,(0)));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar found \x3d [null];\nvar t \x3d cljs.core.tree_map_remove(self__.comp,self__.tree,k,found);\nif((t \x3d\x3d null)){\nif((cljs.core.nth.cljs$core$IFn$_invoke$arity$2(found,(0)) \x3d\x3d null)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentTreeMap(self__.comp,null,(0),self__.meta,null));\n}\n} else {\nreturn (new cljs.core.PersistentTreeMap(self__.comp,t.blacken(),(self__.cnt - (1)),self__.meta,null));\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (coll,k,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar found \x3d [null];\nvar t \x3d cljs.core.tree_map_add(self__.comp,self__.tree,k,v,found);\nif((t \x3d\x3d null)){\nvar found_node \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(found,(0));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(v,found_node.val)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentTreeMap(self__.comp,cljs.core.tree_map_replace(self__.comp,self__.tree,k,v),self__.cnt,self__.meta,null));\n}\n} else {\nreturn (new cljs.core.PersistentTreeMap(self__.comp,t.blacken(),(self__.cnt + (1)),self__.meta,null));\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (coll,k){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (!((coll__$1.entry_at(k) \x3d\x3d null)));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3e (0))){\nreturn cljs.core.create_tree_map_seq(self__.tree,true,self__.cnt);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentTreeMap(self__.comp,self__.tree,self__.cnt,new_meta,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,entry){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry)){\nreturn coll__$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry,(0)),cljs.core._nth(entry,(1)));\n} else {\nvar ret \x3d coll__$1;\nvar es \x3d cljs.core.seq(entry);\nwhile(true){\nif((es \x3d\x3d null)){\nreturn ret;\n} else {\nvar e \x3d cljs.core.first(es);\nif(cljs.core.vector_QMARK_(e)){\nvar G__25834 \x3d cljs.core._assoc(ret,cljs.core._nth(e,(0)),cljs.core._nth(e,(1)));\nvar G__25835 \x3d cljs.core.next(es);\nret \x3d G__25834;\nes \x3d G__25835;\ncontinue;\n} else {\nthrow (new Error(\x22conj on a map takes map entries or seqables of map entries\x22));\n}\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__19004 \x3d (arguments.length - (1));\nswitch (G__19004) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.apply \x3d (function (self__,args18920){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args18920)));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$2(null, k);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_sorted_seq$arity$2 \x3d (function (coll,ascending_QMARK_){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3e (0))){\nreturn cljs.core.create_tree_map_seq(self__.tree,ascending_QMARK_,self__.cnt);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_sorted_seq_from$arity$3 \x3d (function (coll,k,ascending_QMARK_){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.cnt \x3e (0))){\nvar stack \x3d null;\nvar t \x3d self__.tree;\nwhile(true){\nif((!((t \x3d\x3d null)))){\nvar c \x3d (function (){var G__19025 \x3d k;\nvar G__19026 \x3d t.key;\nreturn (self__.comp.cljs$core$IFn$_invoke$arity$2 ? self__.comp.cljs$core$IFn$_invoke$arity$2(G__19025,G__19026) : self__.comp.call(null, G__19025,G__19026));\n})();\nif((c \x3d\x3d\x3d (0))){\nreturn (new cljs.core.PersistentTreeMapSeq(null,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack,t),ascending_QMARK_,(-1),null));\n} else {\nif(cljs.core.truth_(ascending_QMARK_)){\nif((c \x3c (0))){\nvar G__25845 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack,t);\nvar G__25846 \x3d t.left;\nstack \x3d G__25845;\nt \x3d G__25846;\ncontinue;\n} else {\nvar G__25847 \x3d stack;\nvar G__25848 \x3d t.right;\nstack \x3d G__25847;\nt \x3d G__25848;\ncontinue;\n}\n} else {\nif((c \x3e (0))){\nvar G__25849 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack,t);\nvar G__25850 \x3d t.right;\nstack \x3d G__25849;\nt \x3d G__25850;\ncontinue;\n} else {\nvar G__25855 \x3d stack;\nvar G__25856 \x3d t.left;\nstack \x3d G__25855;\nt \x3d G__25856;\ncontinue;\n}\n\n}\n}\n} else {\nif((stack \x3d\x3d null)){\nreturn null;\n} else {\nreturn (new cljs.core.PersistentTreeMapSeq(null,stack,ascending_QMARK_,(-1),null));\n}\n}\nbreak;\n}\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_entry_key$arity$2 \x3d (function (coll,entry){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (cljs.core.key.cljs$core$IFn$_invoke$arity$1 ? cljs.core.key.cljs$core$IFn$_invoke$arity$1(entry) : cljs.core.key.call(null, entry));\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_comparator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.comp;\n}));\n\n(cljs.core.PersistentTreeMap.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22comp\x22,\x22comp\x22,-1462482139,null),new cljs.core.Symbol(null,\x22tree\x22,\x22tree\x22,1444219499,null),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentTreeMap.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentTreeMap.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentTreeMap\x22);\n\n(cljs.core.PersistentTreeMap.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentTreeMap\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentTreeMap.\n */\ncljs.core.__GT_PersistentTreeMap \x3d (function cljs$core$__GT_PersistentTreeMap(comp,tree,cnt,meta,__hash){\nreturn (new cljs.core.PersistentTreeMap(comp,tree,cnt,meta,__hash));\n});\n\n(cljs.core.PersistentTreeMap.EMPTY \x3d (new cljs.core.PersistentTreeMap(cljs.core.compare,null,(0),null,cljs.core.empty_unordered_hash)));\n(cljs.core.PersistentTreeMap.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * keyval \x3d\x3e key val\n *   Returns a new hash map with supplied mappings.\n */\ncljs.core.hash_map \x3d (function cljs$core$hash_map(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___25866 \x3d arguments.length;\nvar i__5727__auto___25869 \x3d (0);\nwhile(true){\nif((i__5727__auto___25869 \x3c len__5726__auto___25866)){\nargs__5732__auto__.push((arguments[i__5727__auto___25869]));\n\nvar G__25876 \x3d (i__5727__auto___25869 + (1));\ni__5727__auto___25869 \x3d G__25876;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.hash_map.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.hash_map.cljs$core$IFn$_invoke$arity$variadic \x3d (function (keyvals){\nvar in$ \x3d cljs.core.seq(keyvals);\nvar out \x3d cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY);\nwhile(true){\nif(in$){\nvar in_SINGLEQUOTE_ \x3d cljs.core.next(in$);\nif((in_SINGLEQUOTE_ \x3d\x3d null)){\nthrow (new Error([\x22No value supplied for key: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(in$))].join(\x27\x27)));\n} else {\nvar G__25882 \x3d cljs.core.next(in_SINGLEQUOTE_);\nvar G__25883 \x3d cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,cljs.core.first(in$),cljs.core.first(in_SINGLEQUOTE_));\nin$ \x3d G__25882;\nout \x3d G__25883;\ncontinue;\n}\n} else {\nreturn cljs.core.persistent_BANG_(out);\n}\nbreak;\n}\n}));\n\n(cljs.core.hash_map.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.hash_map.cljs$lang$applyTo \x3d (function (seq19034){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19034));\n}));\n\n/**\n * keyval \x3d\x3e key val\n *   Returns a new array map with supplied mappings.\n */\ncljs.core.array_map \x3d (function cljs$core$array_map(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___25884 \x3d arguments.length;\nvar i__5727__auto___25885 \x3d (0);\nwhile(true){\nif((i__5727__auto___25885 \x3c len__5726__auto___25884)){\nargs__5732__auto__.push((arguments[i__5727__auto___25885]));\n\nvar G__25886 \x3d (i__5727__auto___25885 + (1));\ni__5727__auto___25885 \x3d G__25886;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.array_map.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.array_map.cljs$core$IFn$_invoke$arity$variadic \x3d (function (keyvals){\nvar arr \x3d (((((keyvals instanceof cljs.core.IndexedSeq)) \x26\x26 ((keyvals.i \x3d\x3d\x3d (0)))))?keyvals.arr:cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(keyvals));\nif(cljs.core.odd_QMARK_(arr.length)){\nthrow (new Error([\x22No value supplied for key: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.last(arr))].join(\x27\x27)));\n} else {\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc(arr);\n}\n}));\n\n(cljs.core.array_map.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.array_map.cljs$lang$applyTo \x3d (function (seq19041){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19041));\n}));\n\n/**\n * Builds a map from a seq as described in\n *   https://clojure.org/reference/special_forms#keyword-arguments\n */\ncljs.core.seq_to_map_for_destructuring \x3d (function cljs$core$seq_to_map_for_destructuring(s){\nif(cljs.core.next(s)){\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc(cljs.core.to_array(s));\n} else {\nif(cljs.core.seq(s)){\nreturn cljs.core.first(s);\n} else {\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}\n}\n});\n/**\n * keyval \x3d\x3e key val\n *   Returns a new object map with supplied mappings.\n */\ncljs.core.obj_map \x3d (function cljs$core$obj_map(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___25889 \x3d arguments.length;\nvar i__5727__auto___25890 \x3d (0);\nwhile(true){\nif((i__5727__auto___25890 \x3c len__5726__auto___25889)){\nargs__5732__auto__.push((arguments[i__5727__auto___25890]));\n\nvar G__25891 \x3d (i__5727__auto___25890 + (1));\ni__5727__auto___25890 \x3d G__25891;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.obj_map.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.obj_map.cljs$core$IFn$_invoke$arity$variadic \x3d (function (keyvals){\nvar ks \x3d [];\nvar obj \x3d ({});\nvar kvs \x3d cljs.core.seq(keyvals);\nwhile(true){\nif(kvs){\nks.push(cljs.core.first(kvs));\n\ncljs.core.goog$module$goog$object.set(obj,cljs.core.first(kvs),cljs.core.second(kvs));\n\nvar G__25894 \x3d cljs.core.nnext(kvs);\nkvs \x3d G__25894;\ncontinue;\n} else {\nreturn cljs.core.ObjMap.fromObject(ks,obj);\n}\nbreak;\n}\n}));\n\n(cljs.core.obj_map.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.obj_map.cljs$lang$applyTo \x3d (function (seq19054){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19054));\n}));\n\n/**\n * keyval \x3d\x3e key val\n *   Returns a new sorted map with supplied mappings.\n */\ncljs.core.sorted_map \x3d (function cljs$core$sorted_map(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___25896 \x3d arguments.length;\nvar i__5727__auto___25897 \x3d (0);\nwhile(true){\nif((i__5727__auto___25897 \x3c len__5726__auto___25896)){\nargs__5732__auto__.push((arguments[i__5727__auto___25897]));\n\nvar G__25898 \x3d (i__5727__auto___25897 + (1));\ni__5727__auto___25897 \x3d G__25898;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.sorted_map.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.sorted_map.cljs$core$IFn$_invoke$arity$variadic \x3d (function (keyvals){\nvar in$ \x3d cljs.core.seq(keyvals);\nvar out \x3d cljs.core.PersistentTreeMap.EMPTY;\nwhile(true){\nif(in$){\nvar G__25903 \x3d cljs.core.nnext(in$);\nvar G__25904 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(out,cljs.core.first(in$),cljs.core.second(in$));\nin$ \x3d G__25903;\nout \x3d G__25904;\ncontinue;\n} else {\nreturn out;\n}\nbreak;\n}\n}));\n\n(cljs.core.sorted_map.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.sorted_map.cljs$lang$applyTo \x3d (function (seq19062){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19062));\n}));\n\n/**\n * keyval \x3d\x3e key val\n *   Returns a new sorted map with supplied mappings, using the supplied comparator.\n */\ncljs.core.sorted_map_by \x3d (function cljs$core$sorted_map_by(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___25905 \x3d arguments.length;\nvar i__5727__auto___25906 \x3d (0);\nwhile(true){\nif((i__5727__auto___25906 \x3c len__5726__auto___25905)){\nargs__5732__auto__.push((arguments[i__5727__auto___25906]));\n\nvar G__25907 \x3d (i__5727__auto___25906 + (1));\ni__5727__auto___25906 \x3d G__25907;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.sorted_map_by.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.sorted_map_by.cljs$core$IFn$_invoke$arity$variadic \x3d (function (comparator,keyvals){\nvar in$ \x3d cljs.core.seq(keyvals);\nvar out \x3d (new cljs.core.PersistentTreeMap(cljs.core.fn__GT_comparator(comparator),null,(0),null,(0)));\nwhile(true){\nif(in$){\nvar G__25909 \x3d cljs.core.nnext(in$);\nvar G__25910 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(out,cljs.core.first(in$),cljs.core.second(in$));\nin$ \x3d G__25909;\nout \x3d G__25910;\ncontinue;\n} else {\nreturn out;\n}\nbreak;\n}\n}));\n\n(cljs.core.sorted_map_by.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.sorted_map_by.cljs$lang$applyTo \x3d (function (seq19071){\nvar G__19072 \x3d cljs.core.first(seq19071);\nvar seq19071__$1 \x3d cljs.core.next(seq19071);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19072,seq19071__$1);\n}));\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.KeySeq \x3d (function (mseq,_meta){\nthis.mseq \x3d mseq;\nthis._meta \x3d _meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374988;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.KeySeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.KeySeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.KeySeq.prototype.indexOf \x3d (function() {\nvar G__25915 \x3d null;\nvar G__25915__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25915__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25915 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25915__1.call(this,x);\ncase 2:\nreturn G__25915__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25915.cljs$core$IFn$_invoke$arity$1 \x3d G__25915__1;\nG__25915.cljs$core$IFn$_invoke$arity$2 \x3d G__25915__2;\nreturn G__25915;\n})()\n);\n\n(cljs.core.KeySeq.prototype.lastIndexOf \x3d (function() {\nvar G__25918 \x3d null;\nvar G__25918__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25918__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25918 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25918__1.call(this,x);\ncase 2:\nreturn G__25918__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25918.cljs$core$IFn$_invoke$arity$1 \x3d G__25918__1;\nG__25918.cljs$core$IFn$_invoke$arity$2 \x3d G__25918__2;\nreturn G__25918;\n})()\n);\n\n(cljs.core.KeySeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__._meta;\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar nseq \x3d (((((!((self__.mseq \x3d\x3d null))))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ \x26 (128))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null, ):cljs.core.next(self__.mseq));\nif((nseq \x3d\x3d null)){\nreturn null;\n} else {\nreturn (new cljs.core.KeySeq(nseq,null));\n}\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.hash_ordered_coll(coll__$1);\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar me \x3d self__.mseq.cljs$core$ISeq$_first$arity$1(null, );\nreturn me.cljs$core$IMapEntry$_key$arity$1(null, );\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar nseq \x3d (((((!((self__.mseq \x3d\x3d null))))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ \x26 (128))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null, ):cljs.core.next(self__.mseq));\nif((!((nseq \x3d\x3d null)))){\nreturn (new cljs.core.KeySeq(nseq,null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__._meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.KeySeq(self__.mseq,new_meta));\n}\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.KeySeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22mseq\x22,\x22mseq\x22,1602647196,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22not-native\x22,\x22not-native\x22,-236392494,null)], null)),new cljs.core.Symbol(null,\x22_meta\x22,\x22_meta\x22,-1716892533,null)], null);\n}));\n\n(cljs.core.KeySeq.cljs$lang$type \x3d true);\n\n(cljs.core.KeySeq.cljs$lang$ctorStr \x3d \x22cljs.core/KeySeq\x22);\n\n(cljs.core.KeySeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/KeySeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/KeySeq.\n */\ncljs.core.__GT_KeySeq \x3d (function cljs$core$__GT_KeySeq(mseq,_meta){\nreturn (new cljs.core.KeySeq(mseq,_meta));\n});\n\n(cljs.core.KeySeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Returns a sequence of the map\x27s keys, in the same order as (seq map).\n */\ncljs.core.keys \x3d (function cljs$core$keys(map){\nvar temp__5804__auto__ \x3d cljs.core.seq(map);\nif(temp__5804__auto__){\nvar mseq \x3d temp__5804__auto__;\nreturn (new cljs.core.KeySeq(mseq,null));\n} else {\nreturn null;\n}\n});\n/**\n * Returns the key of the map entry.\n */\ncljs.core.key \x3d (function cljs$core$key(map_entry){\nreturn cljs.core._key(map_entry);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.ValSeq \x3d (function (mseq,_meta){\nthis.mseq \x3d mseq;\nthis._meta \x3d _meta;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374988;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.ValSeq.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.ValSeq.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.ValSeq.prototype.indexOf \x3d (function() {\nvar G__25927 \x3d null;\nvar G__25927__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__25927__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25927 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25927__1.call(this,x);\ncase 2:\nreturn G__25927__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25927.cljs$core$IFn$_invoke$arity$1 \x3d G__25927__1;\nG__25927.cljs$core$IFn$_invoke$arity$2 \x3d G__25927__2;\nreturn G__25927;\n})()\n);\n\n(cljs.core.ValSeq.prototype.lastIndexOf \x3d (function() {\nvar G__25929 \x3d null;\nvar G__25929__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__25929__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start);\n});\nG__25929 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__25929__1.call(this,x);\ncase 2:\nreturn G__25929__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__25929.cljs$core$IFn$_invoke$arity$1 \x3d G__25929__1;\nG__25929.cljs$core$IFn$_invoke$arity$2 \x3d G__25929__2;\nreturn G__25929;\n})()\n);\n\n(cljs.core.ValSeq.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__._meta;\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$INext$_next$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar nseq \x3d (((((!((self__.mseq \x3d\x3d null))))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ \x26 (128))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null, ):cljs.core.next(self__.mseq));\nif((nseq \x3d\x3d null)){\nreturn null;\n} else {\nreturn (new cljs.core.ValSeq(nseq,null));\n}\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.hash_ordered_coll(coll__$1);\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.equiv_sequential(coll__$1,other);\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (coll,f){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1);\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (coll,f,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1);\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar me \x3d self__.mseq.cljs$core$ISeq$_first$arity$1(null, );\nreturn me.cljs$core$IMapEntry$_val$arity$1(null, );\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar nseq \x3d (((((!((self__.mseq \x3d\x3d null))))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ \x26 (128))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null, ):cljs.core.next(self__.mseq));\nif((!((nseq \x3d\x3d null)))){\nreturn (new cljs.core.ValSeq(nseq,null));\n} else {\nreturn cljs.core.List.EMPTY;\n}\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1;\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__._meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.ValSeq(self__.mseq,new_meta));\n}\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.cons(o,coll__$1);\n}));\n\n(cljs.core.ValSeq.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22mseq\x22,\x22mseq\x22,1602647196,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22not-native\x22,\x22not-native\x22,-236392494,null)], null)),new cljs.core.Symbol(null,\x22_meta\x22,\x22_meta\x22,-1716892533,null)], null);\n}));\n\n(cljs.core.ValSeq.cljs$lang$type \x3d true);\n\n(cljs.core.ValSeq.cljs$lang$ctorStr \x3d \x22cljs.core/ValSeq\x22);\n\n(cljs.core.ValSeq.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ValSeq\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ValSeq.\n */\ncljs.core.__GT_ValSeq \x3d (function cljs$core$__GT_ValSeq(mseq,_meta){\nreturn (new cljs.core.ValSeq(mseq,_meta));\n});\n\n(cljs.core.ValSeq.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Returns a sequence of the map\x27s values, in the same order as (seq map).\n */\ncljs.core.vals \x3d (function cljs$core$vals(map){\nvar temp__5804__auto__ \x3d cljs.core.seq(map);\nif(temp__5804__auto__){\nvar mseq \x3d temp__5804__auto__;\nreturn (new cljs.core.ValSeq(mseq,null));\n} else {\nreturn null;\n}\n});\n/**\n * Returns the value in the map entry.\n */\ncljs.core.val \x3d (function cljs$core$val(map_entry){\nreturn cljs.core._val(map_entry);\n});\n/**\n * Returns a map that consists of the rest of the maps conj-ed onto\n *   the first.  If a key occurs in more than one map, the mapping from\n *   the latter (left-to-right) will be the mapping in the result.\n */\ncljs.core.merge \x3d (function cljs$core$merge(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___25965 \x3d arguments.length;\nvar i__5727__auto___25968 \x3d (0);\nwhile(true){\nif((i__5727__auto___25968 \x3c len__5726__auto___25965)){\nargs__5732__auto__.push((arguments[i__5727__auto___25968]));\n\nvar G__25970 \x3d (i__5727__auto___25968 + (1));\ni__5727__auto___25968 \x3d G__25970;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic \x3d (function (maps){\nif(cljs.core.truth_(cljs.core.some(cljs.core.identity,maps))){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$2((function (p1__19170_SHARP_,p2__19171_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2((function (){var or__5002__auto__ \x3d p1__19170_SHARP_;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}\n})(),p2__19171_SHARP_);\n}),maps);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.merge.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.merge.cljs$lang$applyTo \x3d (function (seq19173){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19173));\n}));\n\n/**\n * Returns a map that consists of the rest of the maps conj-ed onto\n *   the first.  If a key occurs in more than one map, the mapping(s)\n *   from the latter (left-to-right) will be combined with the mapping in\n *   the result by calling (f val-in-result val-in-latter).\n */\ncljs.core.merge_with \x3d (function cljs$core$merge_with(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___25990 \x3d arguments.length;\nvar i__5727__auto___25993 \x3d (0);\nwhile(true){\nif((i__5727__auto___25993 \x3c len__5726__auto___25990)){\nargs__5732__auto__.push((arguments[i__5727__auto___25993]));\n\nvar G__25999 \x3d (i__5727__auto___25993 + (1));\ni__5727__auto___25993 \x3d G__25999;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,maps){\nif(cljs.core.truth_(cljs.core.some(cljs.core.identity,maps))){\nvar merge_entry \x3d (function (m,e){\nvar k \x3d cljs.core.key(e);\nvar v \x3d cljs.core.val(e);\nif(cljs.core.contains_QMARK_(m,k)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__19192 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nvar G__19193 \x3d v;\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__19192,G__19193) : f.call(null, G__19192,G__19193));\n})());\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,v);\n}\n});\nvar merge2 \x3d (function (m1,m2){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(merge_entry,(function (){var or__5002__auto__ \x3d m1;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}\n})(),cljs.core.seq(m2));\n});\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$2(merge2,maps);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.merge_with.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.merge_with.cljs$lang$applyTo \x3d (function (seq19185){\nvar G__19186 \x3d cljs.core.first(seq19185);\nvar seq19185__$1 \x3d cljs.core.next(seq19185);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19186,seq19185__$1);\n}));\n\n/**\n * Returns a map containing only those entries in map whose key is in keys\n */\ncljs.core.select_keys \x3d (function cljs$core$select_keys(map,keyseq){\nvar ret \x3d cljs.core.PersistentArrayMap.EMPTY;\nvar keys \x3d cljs.core.seq(keyseq);\nwhile(true){\nif(keys){\nvar key \x3d cljs.core.first(keys);\nvar entry \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map,key,new cljs.core.Keyword(\x22cljs.core\x22,\x22not-found\x22,\x22cljs.core/not-found\x22,-1572889185));\nvar G__26009 \x3d ((cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(entry,new cljs.core.Keyword(\x22cljs.core\x22,\x22not-found\x22,\x22cljs.core/not-found\x22,-1572889185)))?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,key,entry):ret);\nvar G__26010 \x3d cljs.core.next(keys);\nret \x3d G__26009;\nkeys \x3d G__26010;\ncontinue;\n} else {\nreturn cljs.core._with_meta(ret,cljs.core.meta(map));\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n*/\ncljs.core.HashSetIter \x3d (function (iter){\nthis.iter \x3d iter;\n});\n(cljs.core.HashSetIter.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn self__.iter.hasNext();\n}));\n\n(cljs.core.HashSetIter.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif(self__.iter.hasNext()){\nreturn self__.iter.next().key;\n} else {\nthrow (new Error(\x22No such element\x22));\n}\n}));\n\n(cljs.core.HashSetIter.prototype.remove \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (new Error(\x22Unsupported operation\x22));\n}));\n\n(cljs.core.HashSetIter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22iter\x22,\x22iter\x22,-1346195486,null)], null);\n}));\n\n(cljs.core.HashSetIter.cljs$lang$type \x3d true);\n\n(cljs.core.HashSetIter.cljs$lang$ctorStr \x3d \x22cljs.core/HashSetIter\x22);\n\n(cljs.core.HashSetIter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/HashSetIter\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/HashSetIter.\n */\ncljs.core.__GT_HashSetIter \x3d (function cljs$core$__GT_HashSetIter(iter){\nreturn (new cljs.core.HashSetIter(iter));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IEditableCollection}\n * @implements {cljs.core.ISet}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.PersistentHashSet \x3d (function (meta,hash_map,__hash){\nthis.meta \x3d meta;\nthis.hash_map \x3d hash_map;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 15077647;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139268;\n});\n(cljs.core.PersistentHashSet.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentHashSet.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentHashSet.prototype.keys \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentHashSet.prototype.entries \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_set_entries_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentHashSet.prototype.values \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentHashSet.prototype.has \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.contains_QMARK_(coll,k);\n}));\n\n(cljs.core.PersistentHashSet.prototype.forEach \x3d (function (f){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar seq__19241 \x3d cljs.core.seq(coll);\nvar chunk__19242 \x3d null;\nvar count__19243 \x3d (0);\nvar i__19244 \x3d (0);\nwhile(true){\nif((i__19244 \x3c count__19243)){\nvar vec__19261 \x3d chunk__19242.cljs$core$IIndexed$_nth$arity$2(null, i__19244);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19261,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19261,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__26019 \x3d seq__19241;\nvar G__26020 \x3d chunk__19242;\nvar G__26021 \x3d count__19243;\nvar G__26022 \x3d (i__19244 + (1));\nseq__19241 \x3d G__26019;\nchunk__19242 \x3d G__26020;\ncount__19243 \x3d G__26021;\ni__19244 \x3d G__26022;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__19241);\nif(temp__5804__auto__){\nvar seq__19241__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__19241__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__19241__$1);\nvar G__26023 \x3d cljs.core.chunk_rest(seq__19241__$1);\nvar G__26024 \x3d c__5525__auto__;\nvar G__26025 \x3d cljs.core.count(c__5525__auto__);\nvar G__26026 \x3d (0);\nseq__19241 \x3d G__26023;\nchunk__19242 \x3d G__26024;\ncount__19243 \x3d G__26025;\ni__19244 \x3d G__26026;\ncontinue;\n} else {\nvar vec__19265 \x3d cljs.core.first(seq__19241__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19265,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19265,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__26028 \x3d cljs.core.next(seq__19241__$1);\nvar G__26029 \x3d null;\nvar G__26030 \x3d (0);\nvar G__26031 \x3d (0);\nseq__19241 \x3d G__26028;\nchunk__19242 \x3d G__26029;\ncount__19243 \x3d G__26030;\ni__19244 \x3d G__26031;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, v,null);\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,v,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar temp__5802__auto__ \x3d cljs.core._find(self__.hash_map,v);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar entry \x3d temp__5802__auto__;\nreturn cljs.core.key(entry);\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.HashSetIter(cljs.core._iterator(self__.hash_map)));\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.PersistentHashSet(self__.meta,self__.hash_map,self__.__hash));\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._count(self__.hash_map);\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_unordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar and__5000__auto__ \x3d cljs.core.set_QMARK_(other);\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d (cljs.core.count(coll__$1) \x3d\x3d\x3d cljs.core.count(other));\nif(and__5000__auto____$1){\ntry{return cljs.core.reduce_kv((function (p1__19217_SHARP_,p2__19216_SHARP_){\nvar or__5002__auto__ \x3d cljs.core.contains_QMARK_(other,p2__19216_SHARP_);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.reduced(false);\n}\n}),true,self__.hash_map);\n}catch (e19280){if((e19280 instanceof Error)){\nvar ex \x3d e19280;\nreturn false;\n} else {\nthrow e19280;\n\n}\n}} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.TransientHashSet(cljs.core._as_transient(self__.hash_map)));\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._with_meta(cljs.core.PersistentHashSet.EMPTY,self__.meta);\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$ISet$_disjoin$arity$2 \x3d (function (coll,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentHashSet(self__.meta,cljs.core._dissoc(self__.hash_map,v),null));\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.keys(self__.hash_map);\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentHashSet(new_meta,self__.hash_map,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentHashSet(self__.meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.hash_map,o,null),null));\n}));\n\n(cljs.core.PersistentHashSet.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__19303 \x3d (arguments.length - (1));\nswitch (G__19303) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.PersistentHashSet.prototype.apply \x3d (function (self__,args19224){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args19224)));\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$2(null, k);\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentHashSet.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22hash-map\x22,\x22hash-map\x22,-439030950,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentHashSet.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentHashSet.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentHashSet\x22);\n\n(cljs.core.PersistentHashSet.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentHashSet\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentHashSet.\n */\ncljs.core.__GT_PersistentHashSet \x3d (function cljs$core$__GT_PersistentHashSet(meta,hash_map,__hash){\nreturn (new cljs.core.PersistentHashSet(meta,hash_map,__hash));\n});\n\n(cljs.core.PersistentHashSet.EMPTY \x3d (new cljs.core.PersistentHashSet(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.empty_unordered_hash)));\n(cljs.core.PersistentHashSet.fromArray \x3d (function (items,no_clone){\nvar len \x3d items.length;\nif((len \x3c\x3d cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD)){\nvar arr \x3d ((no_clone)?items:cljs.core.aclone(items));\nvar i \x3d (0);\nvar out \x3d cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY);\nwhile(true){\nif((i \x3c len)){\nvar G__26080 \x3d (i + (1));\nvar G__26081 \x3d cljs.core._assoc_BANG_(out,(items[i]),null);\ni \x3d G__26080;\nout \x3d G__26081;\ncontinue;\n} else {\nreturn (new cljs.core.PersistentHashSet(null,cljs.core._persistent_BANG_(out),null));\n}\nbreak;\n}\n} else {\nvar i \x3d (0);\nvar out \x3d cljs.core.transient$(cljs.core.PersistentHashSet.EMPTY);\nwhile(true){\nif((i \x3c len)){\nvar G__26083 \x3d (i + (1));\nvar G__26084 \x3d cljs.core._conj_BANG_(out,(items[i]));\ni \x3d G__26083;\nout \x3d G__26084;\ncontinue;\n} else {\nreturn cljs.core._persistent_BANG_(out);\n}\nbreak;\n}\n}\n}));\n(cljs.core.PersistentHashSet.createWithCheck \x3d (function (items){\nvar len \x3d items.length;\nvar t \x3d cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY);\nvar n__5593__auto___26091 \x3d len;\nvar i_26092 \x3d (0);\nwhile(true){\nif((i_26092 \x3c n__5593__auto___26091)){\ncljs.core._conj_BANG_(t,(items[i_26092]));\n\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(t),(i_26092 + (1)))){\n} else {\nthrow (new Error([\x22Duplicate key: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((items[i_26092]))].join(\x27\x27)));\n}\n\nvar G__26093 \x3d (i_26092 + (1));\ni_26092 \x3d G__26093;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core._persistent_BANG_(t);\n}));\n(cljs.core.PersistentHashSet.createAsIfByAssoc \x3d (function (items){\nvar len \x3d items.length;\nvar t \x3d cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY);\nvar n__5593__auto___26098 \x3d len;\nvar i_26099 \x3d (0);\nwhile(true){\nif((i_26099 \x3c n__5593__auto___26098)){\ncljs.core._conj_BANG_(t,(items[i_26099]));\n\nvar G__26101 \x3d (i_26099 + (1));\ni_26099 \x3d G__26101;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn cljs.core._persistent_BANG_(t);\n}));\n(cljs.core.PersistentHashSet.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.ITransientSet}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ITransientCollection}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.TransientHashSet \x3d (function (transient_map){\nthis.transient_map \x3d transient_map;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 136;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 259;\n});\n(cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 \x3d (function (tcoll,o){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\n(self__.transient_map \x3d cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(self__.transient_map,o,null));\n\nreturn tcoll__$1;\n}));\n\n(cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 \x3d (function (tcoll){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn (new cljs.core.PersistentHashSet(null,cljs.core.persistent_BANG_(self__.transient_map),null));\n}));\n\n(cljs.core.TransientHashSet.prototype.cljs$core$ITransientSet$_disjoin_BANG_$arity$2 \x3d (function (tcoll,v){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\n(self__.transient_map \x3d cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2(self__.transient_map,v));\n\nreturn tcoll__$1;\n}));\n\n(cljs.core.TransientHashSet.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (tcoll){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn cljs.core.count(self__.transient_map);\n}));\n\n(cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (tcoll,v){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nreturn tcoll__$1.cljs$core$ILookup$_lookup$arity$3(null, v,null);\n}));\n\n(cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (tcoll,v,not_found){\nvar self__ \x3d this;\nvar tcoll__$1 \x3d this;\nif((cljs.core._lookup(self__.transient_map,v,cljs.core.lookup_sentinel) \x3d\x3d\x3d cljs.core.lookup_sentinel)){\nreturn not_found;\n} else {\nreturn v;\n}\n}));\n\n(cljs.core.TransientHashSet.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__19309 \x3d (arguments.length - (1));\nswitch (G__19309) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.TransientHashSet.prototype.apply \x3d (function (self__,args19308){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args19308)));\n}));\n\n(cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nif((cljs.core._lookup(self__.transient_map,k,cljs.core.lookup_sentinel) \x3d\x3d\x3d cljs.core.lookup_sentinel)){\nreturn null;\n} else {\nreturn k;\n}\n}));\n\n(cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar tcoll \x3d this;\nif((cljs.core._lookup(self__.transient_map,k,cljs.core.lookup_sentinel) \x3d\x3d\x3d cljs.core.lookup_sentinel)){\nreturn not_found;\n} else {\nreturn k;\n}\n}));\n\n(cljs.core.TransientHashSet.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22transient-map\x22,\x22transient-map\x22,351764893,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.TransientHashSet.cljs$lang$type \x3d true);\n\n(cljs.core.TransientHashSet.cljs$lang$ctorStr \x3d \x22cljs.core/TransientHashSet\x22);\n\n(cljs.core.TransientHashSet.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/TransientHashSet\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/TransientHashSet.\n */\ncljs.core.__GT_TransientHashSet \x3d (function cljs$core$__GT_TransientHashSet(transient_map){\nreturn (new cljs.core.TransientHashSet(transient_map));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IReversible}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ISet}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISorted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.PersistentTreeSet \x3d (function (meta,tree_map,__hash){\nthis.meta \x3d meta;\nthis.tree_map \x3d tree_map;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 417730831;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 8192;\n});\n(cljs.core.PersistentTreeSet.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.keys \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.entries \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_set_entries_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.values \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.es6_iterator(cljs.core.seq(coll));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.has \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.contains_QMARK_(coll,k);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.forEach \x3d (function (f){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar seq__19313 \x3d cljs.core.seq(coll);\nvar chunk__19314 \x3d null;\nvar count__19315 \x3d (0);\nvar i__19316 \x3d (0);\nwhile(true){\nif((i__19316 \x3c count__19315)){\nvar vec__19323 \x3d chunk__19314.cljs$core$IIndexed$_nth$arity$2(null, i__19316);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19323,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19323,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__26106 \x3d seq__19313;\nvar G__26107 \x3d chunk__19314;\nvar G__26108 \x3d count__19315;\nvar G__26109 \x3d (i__19316 + (1));\nseq__19313 \x3d G__26106;\nchunk__19314 \x3d G__26107;\ncount__19315 \x3d G__26108;\ni__19316 \x3d G__26109;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__19313);\nif(temp__5804__auto__){\nvar seq__19313__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__19313__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__19313__$1);\nvar G__26111 \x3d cljs.core.chunk_rest(seq__19313__$1);\nvar G__26112 \x3d c__5525__auto__;\nvar G__26113 \x3d cljs.core.count(c__5525__auto__);\nvar G__26114 \x3d (0);\nseq__19313 \x3d G__26111;\nchunk__19314 \x3d G__26112;\ncount__19315 \x3d G__26113;\ni__19316 \x3d G__26114;\ncontinue;\n} else {\nvar vec__19326 \x3d cljs.core.first(seq__19313__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19326,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19326,(1),null);\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n\n\nvar G__26118 \x3d cljs.core.next(seq__19313__$1);\nvar G__26119 \x3d null;\nvar G__26120 \x3d (0);\nvar G__26121 \x3d (0);\nseq__19313 \x3d G__26118;\nchunk__19314 \x3d G__26119;\ncount__19315 \x3d G__26120;\ni__19316 \x3d G__26121;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (coll,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn coll__$1.cljs$core$ILookup$_lookup$arity$3(null, v,null);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (coll,v,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar n \x3d self__.tree_map.entry_at(v);\nif((!((n \x3d\x3d null)))){\nreturn n.key;\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.PersistentTreeSet(self__.meta,self__.tree_map,self__.__hash));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.count(self__.tree_map);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IReversible$_rseq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((cljs.core.count(self__.tree_map) \x3e (0))){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.key,cljs.core.rseq(self__.tree_map));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_unordered_coll(coll__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (coll,other){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar and__5000__auto__ \x3d cljs.core.set_QMARK_(other);\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d (cljs.core.count(coll__$1) \x3d\x3d\x3d cljs.core.count(other));\nif(and__5000__auto____$1){\ntry{return cljs.core.reduce_kv((function (p1__19311_SHARP_,p2__19310_SHARP_){\nvar or__5002__auto__ \x3d cljs.core.contains_QMARK_(other,p2__19310_SHARP_);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.reduced(false);\n}\n}),true,self__.tree_map);\n}catch (e19329){if((e19329 instanceof Error)){\nvar ex \x3d e19329;\nreturn false;\n} else {\nthrow e19329;\n\n}\n}} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentTreeSet(self__.meta,cljs.core._empty(self__.tree_map),(0)));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ISet$_disjoin$arity$2 \x3d (function (coll,v){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentTreeSet(self__.meta,cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.tree_map,v),null));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.keys(self__.tree_map);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (coll,new_meta){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn coll__$1;\n} else {\nreturn (new cljs.core.PersistentTreeSet(new_meta,self__.tree_map,self__.__hash));\n}\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (coll,o){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.PersistentTreeSet(self__.meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.tree_map,o,null),null));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__19330 \x3d (arguments.length - (1));\nswitch (G__19330) {\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.PersistentTreeSet.prototype.apply \x3d (function (self__,args19312){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args19312)));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$2(null, k);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,not_found){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn coll.cljs$core$ILookup$_lookup$arity$3(null, k,not_found);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_sorted_seq$arity$2 \x3d (function (coll,ascending_QMARK_){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.key,cljs.core._sorted_seq(self__.tree_map,ascending_QMARK_));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_sorted_seq_from$arity$3 \x3d (function (coll,k,ascending_QMARK_){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.key,cljs.core._sorted_seq_from(self__.tree_map,k,ascending_QMARK_));\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_entry_key$arity$2 \x3d (function (coll,entry){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn entry;\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_comparator$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._comparator(self__.tree_map);\n}));\n\n(cljs.core.PersistentTreeSet.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22tree-map\x22,\x22tree-map\x22,1373073049,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.PersistentTreeSet.cljs$lang$type \x3d true);\n\n(cljs.core.PersistentTreeSet.cljs$lang$ctorStr \x3d \x22cljs.core/PersistentTreeSet\x22);\n\n(cljs.core.PersistentTreeSet.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/PersistentTreeSet\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/PersistentTreeSet.\n */\ncljs.core.__GT_PersistentTreeSet \x3d (function cljs$core$__GT_PersistentTreeSet(meta,tree_map,__hash){\nreturn (new cljs.core.PersistentTreeSet(meta,tree_map,__hash));\n});\n\n(cljs.core.PersistentTreeSet.EMPTY \x3d (new cljs.core.PersistentTreeSet(null,cljs.core.PersistentTreeMap.EMPTY,cljs.core.empty_unordered_hash)));\n(cljs.core.PersistentTreeSet.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\ncljs.core.set_from_indexed_seq \x3d (function cljs$core$set_from_indexed_seq(iseq){\nvar arr \x3d iseq.arr;\nvar ret \x3d (function (){var a__5590__auto__ \x3d arr;\nvar l__5591__auto__ \x3d a__5590__auto__.length;\nvar i \x3d (0);\nvar res \x3d cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY);\nwhile(true){\nif((i \x3c l__5591__auto__)){\nvar G__26135 \x3d (i + (1));\nvar G__26136 \x3d cljs.core._conj_BANG_(res,(arr[i]));\ni \x3d G__26135;\nres \x3d G__26136;\ncontinue;\n} else {\nreturn res;\n}\nbreak;\n}\n})();\nreturn ret.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(null, );\n});\n/**\n * Returns a set of the distinct elements of coll.\n */\ncljs.core.set \x3d (function cljs$core$set(coll){\nif(cljs.core.set_QMARK_(coll)){\nreturn cljs.core.with_meta(coll,null);\n} else {\nvar in$ \x3d cljs.core.seq(coll);\nif((in$ \x3d\x3d null)){\nreturn cljs.core.PersistentHashSet.EMPTY;\n} else {\nif((((in$ instanceof cljs.core.IndexedSeq)) \x26\x26 ((in$.i \x3d\x3d\x3d (0))))){\nreturn cljs.core.PersistentHashSet.createAsIfByAssoc(in$.arr);\n} else {\nvar in$__$1 \x3d in$;\nvar out \x3d cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY);\nwhile(true){\nif((!((in$__$1 \x3d\x3d null)))){\nvar G__26143 \x3d cljs.core.next(in$__$1);\nvar G__26144 \x3d cljs.core._conj_BANG_(out,cljs.core._first(in$__$1));\nin$__$1 \x3d G__26143;\nout \x3d G__26144;\ncontinue;\n} else {\nreturn cljs.core.persistent_BANG_(out);\n}\nbreak;\n}\n\n}\n}\n}\n});\n/**\n * Returns a new hash set with supplied keys.  Any equal keys are\n *   handled as if by repeated uses of conj.\n */\ncljs.core.hash_set \x3d (function cljs$core$hash_set(var_args){\nvar G__19333 \x3d arguments.length;\nswitch (G__19333) {\ncase 0:\nreturn cljs.core.hash_set.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___26146 \x3d arguments.length;\nvar i__5727__auto___26147 \x3d (0);\nwhile(true){\nif((i__5727__auto___26147 \x3c len__5726__auto___26146)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___26147]));\n\nvar G__26148 \x3d (i__5727__auto___26147 + (1));\ni__5727__auto___26147 \x3d G__26148;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((0) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.hash_set.cljs$core$IFn$_invoke$arity$variadic(argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.hash_set.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.PersistentHashSet.EMPTY;\n}));\n\n(cljs.core.hash_set.cljs$core$IFn$_invoke$arity$variadic \x3d (function (keys){\nreturn cljs.core.set(keys);\n}));\n\n/** @this {Function} */\n(cljs.core.hash_set.cljs$lang$applyTo \x3d (function (seq19332){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19332));\n}));\n\n(cljs.core.hash_set.cljs$lang$maxFixedArity \x3d (0));\n\n/**\n * Returns a new sorted set with supplied keys.\n */\ncljs.core.sorted_set \x3d (function cljs$core$sorted_set(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26150 \x3d arguments.length;\nvar i__5727__auto___26151 \x3d (0);\nwhile(true){\nif((i__5727__auto___26151 \x3c len__5726__auto___26150)){\nargs__5732__auto__.push((arguments[i__5727__auto___26151]));\n\nvar G__26152 \x3d (i__5727__auto___26151 + (1));\ni__5727__auto___26151 \x3d G__26152;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.sorted_set.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.sorted_set.cljs$core$IFn$_invoke$arity$variadic \x3d (function (keys){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,cljs.core.PersistentTreeSet.EMPTY,keys);\n}));\n\n(cljs.core.sorted_set.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.sorted_set.cljs$lang$applyTo \x3d (function (seq19334){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19334));\n}));\n\n/**\n * Returns a new sorted set with supplied keys, using the supplied comparator.\n */\ncljs.core.sorted_set_by \x3d (function cljs$core$sorted_set_by(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26153 \x3d arguments.length;\nvar i__5727__auto___26154 \x3d (0);\nwhile(true){\nif((i__5727__auto___26154 \x3c len__5726__auto___26153)){\nargs__5732__auto__.push((arguments[i__5727__auto___26154]));\n\nvar G__26156 \x3d (i__5727__auto___26154 + (1));\ni__5727__auto___26154 \x3d G__26156;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.sorted_set_by.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.sorted_set_by.cljs$core$IFn$_invoke$arity$variadic \x3d (function (comparator,keys){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,(new cljs.core.PersistentTreeSet(null,cljs.core.sorted_map_by(comparator),(0))),keys);\n}));\n\n(cljs.core.sorted_set_by.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.sorted_set_by.cljs$lang$applyTo \x3d (function (seq19335){\nvar G__19336 \x3d cljs.core.first(seq19335);\nvar seq19335__$1 \x3d cljs.core.next(seq19335);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19336,seq19335__$1);\n}));\n\n/**\n * Given a map of replacement pairs and a vector/collection, returns a\n *   vector/seq with any elements \x3d a key in smap replaced with the\n *   corresponding val in smap.  Returns a transducer when no collection\n *   is provided.\n */\ncljs.core.replace \x3d (function cljs$core$replace(var_args){\nvar G__19340 \x3d arguments.length;\nswitch (G__19340) {\ncase 1:\nreturn cljs.core.replace.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.replace.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.replace.cljs$core$IFn$_invoke$arity$1 \x3d (function (smap){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$1((function (p1__19337_SHARP_){\nvar temp__5802__auto__ \x3d cljs.core.find(smap,p1__19337_SHARP_);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar e \x3d temp__5802__auto__;\nreturn cljs.core.val(e);\n} else {\nreturn p1__19337_SHARP_;\n}\n}));\n}));\n\n(cljs.core.replace.cljs$core$IFn$_invoke$arity$2 \x3d (function (smap,coll){\nif(cljs.core.vector_QMARK_(coll)){\nvar n \x3d cljs.core.count(coll);\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (v,i){\nvar temp__5802__auto__ \x3d cljs.core.find(smap,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,i));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar e \x3d temp__5802__auto__;\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(v,i,cljs.core.second(e));\n} else {\nreturn v;\n}\n}),coll,cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.iterate(cljs.core.inc,(0))));\n} else {\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__19338_SHARP_){\nvar temp__5802__auto__ \x3d cljs.core.find(smap,p1__19338_SHARP_);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar e \x3d temp__5802__auto__;\nreturn cljs.core.second(e);\n} else {\nreturn p1__19338_SHARP_;\n}\n}),coll);\n}\n}));\n\n(cljs.core.replace.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a lazy sequence of the elements of coll with duplicates removed.\n *   Returns a stateful transducer when no collection is provided.\n */\ncljs.core.distinct \x3d (function cljs$core$distinct(var_args){\nvar G__19342 \x3d arguments.length;\nswitch (G__19342) {\ncase 0:\nreturn cljs.core.distinct.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.distinct.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.distinct.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (function (rf){\nvar seen \x3d cljs.core.volatile_BANG_(cljs.core.PersistentHashSet.EMPTY);\nreturn (function() {\nvar G__26164 \x3d null;\nvar G__26164__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26164__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__26164__2 \x3d (function (result,input){\nif(cljs.core.contains_QMARK_(cljs.core.deref(seen),input)){\nreturn result;\n} else {\nseen.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, cljs.core.conj.cljs$core$IFn$_invoke$arity$2(seen.cljs$core$IDeref$_deref$arity$1(null, ),input));\n\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n}\n});\nG__26164 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26164__0.call(this);\ncase 1:\nreturn G__26164__1.call(this,result);\ncase 2:\nreturn G__26164__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26164.cljs$core$IFn$_invoke$arity$0 \x3d G__26164__0;\nG__26164.cljs$core$IFn$_invoke$arity$1 \x3d G__26164__1;\nG__26164.cljs$core$IFn$_invoke$arity$2 \x3d G__26164__2;\nreturn G__26164;\n})()\n});\n}));\n\n(cljs.core.distinct.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nvar step \x3d (function cljs$core$step(xs,seen){\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn (function (p__19343,seen__$1){\nwhile(true){\nvar vec__19344 \x3d p__19343;\nvar f \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19344,(0),null);\nvar xs__$1 \x3d vec__19344;\nvar temp__5804__auto__ \x3d cljs.core.seq(xs__$1);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nif(cljs.core.contains_QMARK_(seen__$1,f)){\nvar G__26171 \x3d cljs.core.rest(s);\nvar G__26172 \x3d seen__$1;\np__19343 \x3d G__26171;\nseen__$1 \x3d G__26172;\ncontinue;\n} else {\nreturn cljs.core.cons(f,cljs$core$step(cljs.core.rest(s),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(seen__$1,f)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n})(xs,seen);\n}),null,null));\n});\nreturn step(coll,cljs.core.PersistentHashSet.EMPTY);\n}));\n\n(cljs.core.distinct.cljs$lang$maxFixedArity \x3d 1);\n\n/**\n * Return a seq of all but the last item in coll, in linear time\n */\ncljs.core.butlast \x3d (function cljs$core$butlast(s){\nvar ret \x3d cljs.core.PersistentVector.EMPTY;\nvar s__$1 \x3d s;\nwhile(true){\nif(cljs.core.next(s__$1)){\nvar G__26173 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ret,cljs.core.first(s__$1));\nvar G__26174 \x3d cljs.core.next(s__$1);\nret \x3d G__26173;\ns__$1 \x3d G__26174;\ncontinue;\n} else {\nreturn cljs.core.seq(ret);\n}\nbreak;\n}\n});\n/**\n * Returns the name String of a string, symbol or keyword.\n */\ncljs.core.name \x3d (function cljs$core$name(x){\nif((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition1$ \x26 (4096))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$INamed$))))?true:false):false)){\nreturn x.cljs$core$INamed$_name$arity$1(null, );\n} else {\nif(typeof x \x3d\x3d\x3d \x27string\x27){\nreturn x;\n} else {\nthrow (new Error([\x22Doesn\x27t support name: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)].join(\x27\x27)));\n}\n}\n});\n/**\n * Returns a map with the keys mapped to the corresponding vals.\n */\ncljs.core.zipmap \x3d (function cljs$core$zipmap(keys,vals){\nvar map \x3d cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY);\nvar ks \x3d cljs.core.seq(keys);\nvar vs \x3d cljs.core.seq(vals);\nwhile(true){\nif(((ks) \x26\x26 (vs))){\nvar G__26175 \x3d cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(map,cljs.core.first(ks),cljs.core.first(vs));\nvar G__26176 \x3d cljs.core.next(ks);\nvar G__26177 \x3d cljs.core.next(vs);\nmap \x3d G__26175;\nks \x3d G__26176;\nvs \x3d G__26177;\ncontinue;\n} else {\nreturn cljs.core.persistent_BANG_(map);\n}\nbreak;\n}\n});\n/**\n * Returns the x for which (k x), a number, is greatest.\n * \n *   If there are multiple such xs, the last one is returned.\n */\ncljs.core.max_key \x3d (function cljs$core$max_key(var_args){\nvar G__19355 \x3d arguments.length;\nswitch (G__19355) {\ncase 2:\nreturn cljs.core.max_key.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.max_key.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___26179 \x3d arguments.length;\nvar i__5727__auto___26180 \x3d (0);\nwhile(true){\nif((i__5727__auto___26180 \x3c len__5726__auto___26179)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___26180]));\n\nvar G__26181 \x3d (i__5727__auto___26180 + (1));\ni__5727__auto___26180 \x3d G__26181;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.max_key.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.max_key.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,x){\nreturn x;\n}));\n\n(cljs.core.max_key.cljs$core$IFn$_invoke$arity$3 \x3d (function (k,x,y){\nif(((k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(x) : k.call(null, x)) \x3e (k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(y) : k.call(null, y)))){\nreturn x;\n} else {\nreturn y;\n}\n}));\n\n(cljs.core.max_key.cljs$core$IFn$_invoke$arity$variadic \x3d (function (k,x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19348_SHARP_,p2__19349_SHARP_){\nreturn cljs.core.max_key.cljs$core$IFn$_invoke$arity$3(k,p1__19348_SHARP_,p2__19349_SHARP_);\n}),cljs.core.max_key.cljs$core$IFn$_invoke$arity$3(k,x,y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.max_key.cljs$lang$applyTo \x3d (function (seq19351){\nvar G__19352 \x3d cljs.core.first(seq19351);\nvar seq19351__$1 \x3d cljs.core.next(seq19351);\nvar G__19353 \x3d cljs.core.first(seq19351__$1);\nvar seq19351__$2 \x3d cljs.core.next(seq19351__$1);\nvar G__19354 \x3d cljs.core.first(seq19351__$2);\nvar seq19351__$3 \x3d cljs.core.next(seq19351__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19352,G__19353,G__19354,seq19351__$3);\n}));\n\n(cljs.core.max_key.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * Returns the x for which (k x), a number, is least.\n * \n *   If there are multiple such xs, the last one is returned.\n */\ncljs.core.min_key \x3d (function cljs$core$min_key(var_args){\nvar G__19363 \x3d arguments.length;\nswitch (G__19363) {\ncase 2:\nreturn cljs.core.min_key.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.min_key.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___26185 \x3d arguments.length;\nvar i__5727__auto___26186 \x3d (0);\nwhile(true){\nif((i__5727__auto___26186 \x3c len__5726__auto___26185)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___26186]));\n\nvar G__26187 \x3d (i__5727__auto___26186 + (1));\ni__5727__auto___26186 \x3d G__26187;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.min_key.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.min_key.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,x){\nreturn x;\n}));\n\n(cljs.core.min_key.cljs$core$IFn$_invoke$arity$3 \x3d (function (k,x,y){\nif(((k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(x) : k.call(null, x)) \x3c (k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(y) : k.call(null, y)))){\nreturn x;\n} else {\nreturn y;\n}\n}));\n\n(cljs.core.min_key.cljs$core$IFn$_invoke$arity$variadic \x3d (function (k,x,y,more){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19356_SHARP_,p2__19357_SHARP_){\nreturn cljs.core.min_key.cljs$core$IFn$_invoke$arity$3(k,p1__19356_SHARP_,p2__19357_SHARP_);\n}),cljs.core.min_key.cljs$core$IFn$_invoke$arity$3(k,x,y),more);\n}));\n\n/** @this {Function} */\n(cljs.core.min_key.cljs$lang$applyTo \x3d (function (seq19359){\nvar G__19360 \x3d cljs.core.first(seq19359);\nvar seq19359__$1 \x3d cljs.core.next(seq19359);\nvar G__19361 \x3d cljs.core.first(seq19359__$1);\nvar seq19359__$2 \x3d cljs.core.next(seq19359__$1);\nvar G__19362 \x3d cljs.core.first(seq19359__$2);\nvar seq19359__$3 \x3d cljs.core.next(seq19359__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19360,G__19361,G__19362,seq19359__$3);\n}));\n\n(cljs.core.min_key.cljs$lang$maxFixedArity \x3d (3));\n\n\n/**\n* @constructor\n*/\ncljs.core.ArrayList \x3d (function (arr){\nthis.arr \x3d arr;\n});\n(cljs.core.ArrayList.prototype.add \x3d (function (x){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn self__.arr.push(x);\n}));\n\n(cljs.core.ArrayList.prototype.size \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn self__.arr.length;\n}));\n\n(cljs.core.ArrayList.prototype.clear \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.arr \x3d []);\n}));\n\n(cljs.core.ArrayList.prototype.isEmpty \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.arr.length \x3d\x3d\x3d (0));\n}));\n\n(cljs.core.ArrayList.prototype.toArray \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn self__.arr;\n}));\n\n(cljs.core.ArrayList.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.ArrayList.cljs$lang$type \x3d true);\n\n(cljs.core.ArrayList.cljs$lang$ctorStr \x3d \x22cljs.core/ArrayList\x22);\n\n(cljs.core.ArrayList.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/ArrayList\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/ArrayList.\n */\ncljs.core.__GT_ArrayList \x3d (function cljs$core$__GT_ArrayList(arr){\nreturn (new cljs.core.ArrayList(arr));\n});\n\ncljs.core.array_list \x3d (function cljs$core$array_list(){\nreturn (new cljs.core.ArrayList([]));\n});\n/**\n * Returns a lazy sequence of lists like partition, but may include\n *   partitions with fewer than n items at the end.  Returns a stateful\n *   transducer when no collection is provided.\n */\ncljs.core.partition_all \x3d (function cljs$core$partition_all(var_args){\nvar G__19365 \x3d arguments.length;\nswitch (G__19365) {\ncase 1:\nreturn cljs.core.partition_all.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.partition_all.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.partition_all.cljs$core$IFn$_invoke$arity$1 \x3d (function (n){\nreturn (function (rf){\nvar a \x3d cljs.core.array_list();\nreturn (function() {\nvar G__26223 \x3d null;\nvar G__26223__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26223__1 \x3d (function (result){\nvar result__$1 \x3d (cljs.core.truth_(a.isEmpty())?result:(function (){var v \x3d cljs.core.vec(a.toArray());\na.clear();\n\nreturn cljs.core.unreduced((rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null, result,v)));\n})());\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result__$1) : rf.call(null, result__$1));\n});\nvar G__26223__2 \x3d (function (result,input){\na.add(input);\n\nif((n \x3d\x3d\x3d a.size())){\nvar v \x3d cljs.core.vec(a.toArray());\na.clear();\n\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null, result,v));\n} else {\nreturn result;\n}\n});\nG__26223 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26223__0.call(this);\ncase 1:\nreturn G__26223__1.call(this,result);\ncase 2:\nreturn G__26223__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26223.cljs$core$IFn$_invoke$arity$0 \x3d G__26223__0;\nG__26223.cljs$core$IFn$_invoke$arity$1 \x3d G__26223__1;\nG__26223.cljs$core$IFn$_invoke$arity$2 \x3d G__26223__2;\nreturn G__26223;\n})()\n});\n}));\n\n(cljs.core.partition_all.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nreturn cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3(n,n,coll);\n}));\n\n(cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3 \x3d (function (n,step,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nreturn cljs.core.cons(cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,s),cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3(n,step,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(step,s)));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.partition_all.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns a vector of [(into [] (take n) coll) (drop n coll)]\n */\ncljs.core.splitv_at \x3d (function cljs$core$splitv_at(n,coll){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.take.cljs$core$IFn$_invoke$arity$1(n),coll),cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,coll)], null);\n});\n/**\n * Returns a lazy sequence of vectors of n items each, at offsets step\n *   apart. If step is not supplied, defaults to n, i.e. the partitions\n *   do not overlap. If a pad collection is supplied, use its elements as\n *   necessary to complete last partition upto n items. In case there are\n *   not enough padding elements, return a partition with less than n items.\n */\ncljs.core.partitionv \x3d (function cljs$core$partitionv(var_args){\nvar G__19367 \x3d arguments.length;\nswitch (G__19367) {\ncase 2:\nreturn cljs.core.partitionv.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.partitionv.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.partitionv.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.partitionv.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nreturn cljs.core.partitionv.cljs$core$IFn$_invoke$arity$3(n,n,coll);\n}));\n\n(cljs.core.partitionv.cljs$core$IFn$_invoke$arity$3 \x3d (function (n,step,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar p \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.take.cljs$core$IFn$_invoke$arity$1(n),s);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(n,cljs.core.count(p))){\nreturn cljs.core.cons(p,cljs.core.partitionv.cljs$core$IFn$_invoke$arity$3(n,step,cljs.core.nthrest(s,step)));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.partitionv.cljs$core$IFn$_invoke$arity$4 \x3d (function (n,step,pad,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar p \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.take.cljs$core$IFn$_invoke$arity$1(n),s);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(n,cljs.core.count(p))){\nreturn cljs.core.cons(p,cljs.core.partitionv.cljs$core$IFn$_invoke$arity$4(n,step,pad,cljs.core.nthrest(s,step)));\n} else {\nreturn (new cljs.core.List(null,cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.take.cljs$core$IFn$_invoke$arity$1(n),cljs.core.concat.cljs$core$IFn$_invoke$arity$2(p,pad)),null,(1),null));\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.partitionv.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Returns a lazy sequence of vector partitions, but may include\n *   partitions with fewer than n items at the end.\n *   Returns a stateful transducer when no collection is provided.\n */\ncljs.core.partitionv_all \x3d (function cljs$core$partitionv_all(var_args){\nvar G__19369 \x3d arguments.length;\nswitch (G__19369) {\ncase 1:\nreturn cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$1 \x3d (function (n){\nreturn cljs.core.partition_all.cljs$core$IFn$_invoke$arity$1(n);\n}));\n\n(cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nreturn cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$3(n,n,coll);\n}));\n\n(cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$3 \x3d (function (n,step,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar seg \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.take.cljs$core$IFn$_invoke$arity$1(n),coll);\nreturn cljs.core.cons(seg,cljs.core.partitionv_all.cljs$core$IFn$_invoke$arity$3(n,step,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(step,s)));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.partitionv_all.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns a lazy sequence of successive items from coll while\n *   (pred item) returns logical true. pred must be free of side-effects.\n *   Returns a transducer when no collection is provided.\n */\ncljs.core.take_while \x3d (function cljs$core$take_while(var_args){\nvar G__19371 \x3d arguments.length;\nswitch (G__19371) {\ncase 1:\nreturn cljs.core.take_while.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.take_while.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.take_while.cljs$core$IFn$_invoke$arity$1 \x3d (function (pred){\nreturn (function (rf){\nreturn (function() {\nvar G__26240 \x3d null;\nvar G__26240__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26240__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__26240__2 \x3d (function (result,input){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null, input)))){\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n} else {\nreturn cljs.core.reduced(result);\n}\n});\nG__26240 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26240__0.call(this);\ncase 1:\nreturn G__26240__1.call(this,result);\ncase 2:\nreturn G__26240__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26240.cljs$core$IFn$_invoke$arity$0 \x3d G__26240__0;\nG__26240.cljs$core$IFn$_invoke$arity$1 \x3d G__26240__1;\nG__26240.cljs$core$IFn$_invoke$arity$2 \x3d G__26240__2;\nreturn G__26240;\n})()\n});\n}));\n\n(cljs.core.take_while.cljs$core$IFn$_invoke$arity$2 \x3d (function (pred,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nif(cljs.core.truth_((function (){var G__19372 \x3d cljs.core.first(s);\nreturn (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__19372) : pred.call(null, G__19372));\n})())){\nreturn cljs.core.cons(cljs.core.first(s),cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(pred,cljs.core.rest(s)));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.take_while.cljs$lang$maxFixedArity \x3d 2);\n\ncljs.core.mk_bound_fn \x3d (function cljs$core$mk_bound_fn(sc,test,key){\nreturn (function (e){\nvar comp \x3d cljs.core._comparator(sc);\nvar G__19373 \x3d (function (){var G__19375 \x3d cljs.core._entry_key(sc,e);\nvar G__19376 \x3d key;\nreturn (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(G__19375,G__19376) : comp.call(null, G__19375,G__19376));\n})();\nvar G__19374 \x3d (0);\nreturn (test.cljs$core$IFn$_invoke$arity$2 ? test.cljs$core$IFn$_invoke$arity$2(G__19373,G__19374) : test.call(null, G__19373,G__19374));\n});\n});\n/**\n * sc must be a sorted collection, test(s) one of \x3c, \x3c\x3d, \x3e or\n *   \x3e\x3d. Returns a seq of those entries with keys ek for\n *   which (test (.. sc comparator (compare ek key)) 0) is true\n */\ncljs.core.subseq \x3d (function cljs$core$subseq(var_args){\nvar G__19378 \x3d arguments.length;\nswitch (G__19378) {\ncase 3:\nreturn cljs.core.subseq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 5:\nreturn cljs.core.subseq.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.subseq.cljs$core$IFn$_invoke$arity$3 \x3d (function (sc,test,key){\nvar include \x3d cljs.core.mk_bound_fn(sc,test,key);\nif(cljs.core.truth_((function (){var fexpr__19379 \x3d cljs.core.PersistentHashSet.createAsIfByAssoc([cljs.core._GT_,cljs.core._GT__EQ_]);\nreturn (fexpr__19379.cljs$core$IFn$_invoke$arity$1 ? fexpr__19379.cljs$core$IFn$_invoke$arity$1(test) : fexpr__19379.call(null, test));\n})())){\nvar temp__5804__auto__ \x3d cljs.core._sorted_seq_from(sc,key,true);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar vec__19380 \x3d temp__5804__auto__;\nvar e \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19380,(0),null);\nvar s \x3d vec__19380;\nif(cljs.core.truth_(include(e))){\nreturn s;\n} else {\nreturn cljs.core.next(s);\n}\n} else {\nreturn null;\n}\n} else {\nreturn cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(include,cljs.core._sorted_seq(sc,true));\n}\n}));\n\n(cljs.core.subseq.cljs$core$IFn$_invoke$arity$5 \x3d (function (sc,start_test,start_key,end_test,end_key){\nvar temp__5804__auto__ \x3d cljs.core._sorted_seq_from(sc,start_key,true);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar vec__19383 \x3d temp__5804__auto__;\nvar e \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19383,(0),null);\nvar s \x3d vec__19383;\nreturn cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(cljs.core.mk_bound_fn(sc,end_test,end_key),(cljs.core.truth_(cljs.core.mk_bound_fn(sc,start_test,start_key)(e))?s:cljs.core.next(s)));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.subseq.cljs$lang$maxFixedArity \x3d 5);\n\n/**\n * sc must be a sorted collection, test(s) one of \x3c, \x3c\x3d, \x3e or\n *   \x3e\x3d. Returns a reverse seq of those entries with keys ek for\n *   which (test (.. sc comparator (compare ek key)) 0) is true\n */\ncljs.core.rsubseq \x3d (function cljs$core$rsubseq(var_args){\nvar G__19387 \x3d arguments.length;\nswitch (G__19387) {\ncase 3:\nreturn cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 5:\nreturn cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$3 \x3d (function (sc,test,key){\nvar include \x3d cljs.core.mk_bound_fn(sc,test,key);\nif(cljs.core.truth_((function (){var fexpr__19388 \x3d cljs.core.PersistentHashSet.createAsIfByAssoc([cljs.core._LT_,cljs.core._LT__EQ_]);\nreturn (fexpr__19388.cljs$core$IFn$_invoke$arity$1 ? fexpr__19388.cljs$core$IFn$_invoke$arity$1(test) : fexpr__19388.call(null, test));\n})())){\nvar temp__5804__auto__ \x3d cljs.core._sorted_seq_from(sc,key,false);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar vec__19389 \x3d temp__5804__auto__;\nvar e \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19389,(0),null);\nvar s \x3d vec__19389;\nif(cljs.core.truth_(include(e))){\nreturn s;\n} else {\nreturn cljs.core.next(s);\n}\n} else {\nreturn null;\n}\n} else {\nreturn cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(include,cljs.core._sorted_seq(sc,false));\n}\n}));\n\n(cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$5 \x3d (function (sc,start_test,start_key,end_test,end_key){\nvar temp__5804__auto__ \x3d cljs.core._sorted_seq_from(sc,end_key,false);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar vec__19392 \x3d temp__5804__auto__;\nvar e \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19392,(0),null);\nvar s \x3d vec__19392;\nreturn cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(cljs.core.mk_bound_fn(sc,start_test,start_key),(cljs.core.truth_(cljs.core.mk_bound_fn(sc,end_test,end_key)(e))?s:cljs.core.next(s)));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.rsubseq.cljs$lang$maxFixedArity \x3d 5);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.IChunk}\n*/\ncljs.core.IntegerRangeChunk \x3d (function (start,step,count){\nthis.start \x3d start;\nthis.step \x3d step;\nthis.count \x3d count;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 82;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.IntegerRangeChunk.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.count;\n}));\n\n(cljs.core.IntegerRangeChunk.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn self__.start;\n}));\n\n(cljs.core.IntegerRangeChunk.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (coll,i){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (self__.start + (i * self__.step));\n}));\n\n(cljs.core.IntegerRangeChunk.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (coll,i,not_found){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((((i \x3e\x3d (0))) \x26\x26 ((i \x3c self__.count)))){\nreturn (self__.start + (i * self__.step));\n} else {\nreturn not_found;\n}\n}));\n\n(cljs.core.IntegerRangeChunk.prototype.cljs$core$IChunk$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.IntegerRangeChunk.prototype.cljs$core$IChunk$_drop_first$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nif((self__.count \x3c\x3d (1))){\nthrow (new Error(\x22-drop-first of empty chunk\x22));\n} else {\nreturn (new cljs.core.IntegerRangeChunk((self__.start + self__.step),self__.step,(self__.count - (1))));\n}\n}));\n\n(cljs.core.IntegerRangeChunk.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22start\x22,\x22start\x22,1285322546,null),new cljs.core.Symbol(null,\x22step\x22,\x22step\x22,-1365547645,null),new cljs.core.Symbol(null,\x22count\x22,\x22count\x22,-514511684,null)], null);\n}));\n\n(cljs.core.IntegerRangeChunk.cljs$lang$type \x3d true);\n\n(cljs.core.IntegerRangeChunk.cljs$lang$ctorStr \x3d \x22cljs.core/IntegerRangeChunk\x22);\n\n(cljs.core.IntegerRangeChunk.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/IntegerRangeChunk\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/IntegerRangeChunk.\n */\ncljs.core.__GT_IntegerRangeChunk \x3d (function cljs$core$__GT_IntegerRangeChunk(start,step,count){\nreturn (new cljs.core.IntegerRangeChunk(start,step,count));\n});\n\n\n/**\n* @constructor\n*/\ncljs.core.RangeIterator \x3d (function (i,end,step){\nthis.i \x3d i;\nthis.end \x3d end;\nthis.step \x3d step;\n});\n(cljs.core.RangeIterator.prototype.hasNext \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((self__.step \x3e (0))){\nreturn (self__.i \x3c self__.end);\n} else {\nreturn (self__.i \x3e self__.end);\n}\n}));\n\n(cljs.core.RangeIterator.prototype.next \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d self__.i;\n(self__.i \x3d (self__.i + self__.step));\n\nreturn ret;\n}));\n\n(cljs.core.RangeIterator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22i\x22,\x22i\x22,253690212,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22end\x22,\x22end\x22,1372345569,null),new cljs.core.Symbol(null,\x22step\x22,\x22step\x22,-1365547645,null)], null);\n}));\n\n(cljs.core.RangeIterator.cljs$lang$type \x3d true);\n\n(cljs.core.RangeIterator.cljs$lang$ctorStr \x3d \x22cljs.core/RangeIterator\x22);\n\n(cljs.core.RangeIterator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/RangeIterator\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/RangeIterator.\n */\ncljs.core.__GT_RangeIterator \x3d (function cljs$core$__GT_RangeIterator(i,end,step){\nreturn (new cljs.core.RangeIterator(i,end,step));\n});\n\n/**\n * Returns exact size of remaining items in an IntegerRange.\n */\ncljs.core.range_count \x3d (function cljs$core$range_count(start,end,step){\nreturn Math.ceil(((end - start) / step));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IDrop}\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IChunkedNext}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IChunkedSeq}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.IntegerRange \x3d (function (meta,start,end,step,cnt,__hash){\nthis.meta \x3d meta;\nthis.start \x3d start;\nthis.end \x3d end;\nthis.step \x3d step;\nthis.cnt \x3d cnt;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32375006;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 402944;\n});\n(cljs.core.IntegerRange.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.IntegerRange.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.IntegerRange.prototype.indexOf \x3d (function() {\nvar G__26289 \x3d null;\nvar G__26289__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__26289__2 \x3d (function (x,start__$1){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1);\n});\nG__26289 \x3d function(x,start__$1){\nswitch(arguments.length){\ncase 1:\nreturn G__26289__1.call(this,x);\ncase 2:\nreturn G__26289__2.call(this,x,start__$1);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26289.cljs$core$IFn$_invoke$arity$1 \x3d G__26289__1;\nG__26289.cljs$core$IFn$_invoke$arity$2 \x3d G__26289__2;\nreturn G__26289;\n})()\n);\n\n(cljs.core.IntegerRange.prototype.lastIndexOf \x3d (function() {\nvar G__26304 \x3d null;\nvar G__26304__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__26304__2 \x3d (function (x,start__$1){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1);\n});\nG__26304 \x3d function(x,start__$1){\nswitch(arguments.length){\ncase 1:\nreturn G__26304__1.call(this,x);\ncase 2:\nreturn G__26304__2.call(this,x,start__$1);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26304.cljs$core$IFn$_invoke$arity$1 \x3d G__26304__1;\nG__26304.cljs$core$IFn$_invoke$arity$2 \x3d G__26304__2;\nreturn G__26304;\n})()\n);\n\n(cljs.core.IntegerRange.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (rng,n){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif(((((0) \x3c\x3d n)) \x26\x26 ((n \x3c rng__$1.cljs$core$ICounted$_count$arity$1(null, ))))){\nreturn (self__.start + (n * self__.step));\n} else {\nif(((((0) \x3c\x3d n)) \x26\x26 ((((self__.start \x3e self__.end)) \x26\x26 ((self__.step \x3d\x3d\x3d (0))))))){\nreturn self__.start;\n} else {\nthrow (new Error(\x22Index out of bounds\x22));\n}\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (rng,n,not_found){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif(((((0) \x3c\x3d n)) \x26\x26 ((n \x3c rng__$1.cljs$core$ICounted$_count$arity$1(null, ))))){\nreturn (self__.start + (n * self__.step));\n} else {\nif(((((0) \x3c\x3d n)) \x26\x26 ((((self__.start \x3e self__.end)) \x26\x26 ((self__.step \x3d\x3d\x3d (0))))))){\nreturn self__.start;\n} else {\nreturn not_found;\n}\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.RangeIterator(self__.start,self__.end,self__.step));\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.IntegerRange(self__.meta,self__.start,self__.end,self__.step,self__.cnt,self__.__hash));\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$INext$_next$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif((self__.step \x3e (0))){\nif(((self__.start + self__.step) \x3c self__.end)){\nreturn (new cljs.core.IntegerRange(null,(self__.start + self__.step),self__.end,self__.step,cljs.core.range_count((self__.start + self__.step),self__.end,self__.step),null));\n} else {\nreturn null;\n}\n} else {\nif(((self__.start + self__.step) \x3e self__.end)){\nreturn (new cljs.core.IntegerRange(null,(self__.start + self__.step),self__.end,self__.step,cljs.core.range_count((self__.start + self__.step),self__.end,self__.step),null));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn self__.cnt;\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(rng__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (rng,other){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.equiv_sequential(rng__$1,other);\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (rng,f){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(rng__$1,f);\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (rng,f,init){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nvar i \x3d self__.start;\nvar ret \x3d init;\nwhile(true){\nif((((self__.step \x3e (0)))?(i \x3c self__.end):(i \x3e self__.end))){\nvar ret__$1 \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,i) : f.call(null, ret,i));\nif(cljs.core.reduced_QMARK_(ret__$1)){\nreturn cljs.core.deref(ret__$1);\n} else {\nvar G__26325 \x3d (i + self__.step);\nvar G__26326 \x3d ret__$1;\ni \x3d G__26325;\nret \x3d G__26326;\ncontinue;\n}\n} else {\nreturn ret;\n}\nbreak;\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn self__.start;\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nvar s \x3d rng__$1.cljs$core$INext$_next$arity$1(null, );\nif((s \x3d\x3d null)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn s;\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn rng__$1;\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn (new cljs.core.IntegerRangeChunk(self__.start,self__.step,(function (){var x__5090__auto__ \x3d self__.cnt;\nvar y__5091__auto__ \x3d (32);\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})()));\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif((self__.cnt \x3c\x3d (32))){\nreturn cljs.core.List.EMPTY;\n} else {\nvar start__$1 \x3d (self__.start + (self__.step * (32)));\nif((self__.step \x3e (0))){\nif((self__.end \x3c\x3d start__$1)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn (new cljs.core.IntegerRange(null,start__$1,self__.end,self__.step,cljs.core.range_count(start__$1,self__.end,self__.step),null));\n}\n} else {\nif((self__.step \x3c (0))){\nif((self__.end \x3e\x3d start__$1)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn (new cljs.core.IntegerRange(null,start__$1,self__.end,self__.step,cljs.core.range_count(start__$1,self__.end,self__.step),null));\n}\n} else {\nif((self__.end \x3d\x3d\x3d start__$1)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(start__$1);\n}\n\n}\n}\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (rng,new_meta){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn rng__$1;\n} else {\nreturn (new cljs.core.IntegerRange(new_meta,self__.start,self__.end,self__.step,self__.cnt,self__.__hash));\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (rng,o){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.cons(o,rng__$1);\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IDrop$_drop$arity$2 \x3d (function (rng,n){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif((n \x3e (0))){\nif((n \x3c self__.cnt)){\nreturn (new cljs.core.IntegerRange(null,(self__.start + (self__.step * n)),self__.end,self__.step,(self__.cnt - n),null));\n} else {\nreturn null;\n}\n} else {\nreturn rng__$1;\n}\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.seq(rng__$1.cljs$core$IChunkedSeq$_chunked_rest$arity$1(null, ));\n}));\n\n(cljs.core.IntegerRange.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22start\x22,\x22start\x22,1285322546,null),new cljs.core.Symbol(null,\x22end\x22,\x22end\x22,1372345569,null),new cljs.core.Symbol(null,\x22step\x22,\x22step\x22,-1365547645,null),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.IntegerRange.cljs$lang$type \x3d true);\n\n(cljs.core.IntegerRange.cljs$lang$ctorStr \x3d \x22cljs.core/IntegerRange\x22);\n\n(cljs.core.IntegerRange.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/IntegerRange\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/IntegerRange.\n */\ncljs.core.__GT_IntegerRange \x3d (function cljs$core$__GT_IntegerRange(meta,start,end,step,cnt,__hash){\nreturn (new cljs.core.IntegerRange(meta,start,end,step,cnt,__hash));\n});\n\n(cljs.core.IntegerRange.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.IChunkedNext}\n * @implements {cljs.core.IEmptyableCollection}\n * @implements {cljs.core.ISeq}\n * @implements {cljs.core.INext}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IChunkedSeq}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.Range \x3d (function (meta,start,end,step,chunk,chunk_next,__hash){\nthis.meta \x3d meta;\nthis.start \x3d start;\nthis.end \x3d end;\nthis.step \x3d step;\nthis.chunk \x3d chunk;\nthis.chunk_next \x3d chunk_next;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 140800;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32374988;\n});\n(cljs.core.Range.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.Range.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.Range.prototype.indexOf \x3d (function() {\nvar G__26340 \x3d null;\nvar G__26340__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0));\n});\nvar G__26340__2 \x3d (function (x,start__$1){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1);\n});\nG__26340 \x3d function(x,start__$1){\nswitch(arguments.length){\ncase 1:\nreturn G__26340__1.call(this,x);\ncase 2:\nreturn G__26340__2.call(this,x,start__$1);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26340.cljs$core$IFn$_invoke$arity$1 \x3d G__26340__1;\nG__26340.cljs$core$IFn$_invoke$arity$2 \x3d G__26340__2;\nreturn G__26340;\n})()\n);\n\n(cljs.core.Range.prototype.lastIndexOf \x3d (function() {\nvar G__26341 \x3d null;\nvar G__26341__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll));\n});\nvar G__26341__2 \x3d (function (x,start__$1){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1);\n});\nG__26341 \x3d function(x,start__$1){\nswitch(arguments.length){\ncase 1:\nreturn G__26341__1.call(this,x);\ncase 2:\nreturn G__26341__2.call(this,x,start__$1);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26341.cljs$core$IFn$_invoke$arity$1 \x3d G__26341__1;\nG__26341.cljs$core$IFn$_invoke$arity$2 \x3d G__26341__2;\nreturn G__26341;\n})()\n);\n\n(cljs.core.Range.prototype.forceChunk \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nif((self__.chunk \x3d\x3d null)){\nvar arr \x3d [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];\nvar val \x3d (function (){var n \x3d (0);\nvar val \x3d self__.start;\nwhile(true){\nif((n \x3c (32))){\n(arr[n] \x3d val);\n\nvar n__$1 \x3d (n + (1));\nvar val__$1 \x3d (val + self__.step);\nif((((self__.step \x3e (0)))?(val__$1 \x3c self__.end):(val__$1 \x3e self__.end))){\nvar G__26346 \x3d n__$1;\nvar G__26348 \x3d val__$1;\nn \x3d G__26346;\nval \x3d G__26348;\ncontinue;\n} else {\nreturn (self__.chunk \x3d cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3(arr,(0),n__$1));\n}\n} else {\nreturn val;\n}\nbreak;\n}\n})();\nif((self__.chunk \x3d\x3d null)){\n(self__.chunk \x3d cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3(arr,(0),(32)));\n\nif((((self__.step \x3e (0)))?(val \x3c self__.end):(val \x3e self__.end))){\nreturn (self__.chunk_next \x3d (new cljs.core.Range(null,val,self__.end,self__.step,null,null,null)));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.Range.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.RangeIterator(self__.start,self__.end,self__.step));\n}));\n\n(cljs.core.Range.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn self__.meta;\n}));\n\n(cljs.core.Range.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (new cljs.core.Range(self__.meta,self__.start,self__.end,self__.step,self__.chunk,self__.chunk_next,self__.__hash));\n}));\n\n(cljs.core.Range.prototype.cljs$core$INext$_next$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif((self__.step \x3e (0))){\nif(((self__.start + self__.step) \x3c self__.end)){\nreturn (new cljs.core.Range(null,(self__.start + self__.step),self__.end,self__.step,null,null,null));\n} else {\nreturn null;\n}\n} else {\nif(((self__.start + self__.step) \x3e self__.end)){\nreturn (new cljs.core.Range(null,(self__.start + self__.step),self__.end,self__.step,null,null,null));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.core.Range.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d cljs.core.hash_ordered_coll(rng__$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.core.Range.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (rng,other){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.equiv_sequential(rng__$1,other);\n}));\n\n(cljs.core.Range.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.List.EMPTY;\n}));\n\n(cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (rng,f){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,rng__$1);\n}));\n\n(cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (rng,f,init){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nvar i \x3d self__.start;\nvar ret \x3d init;\nwhile(true){\nif((((self__.step \x3e (0)))?(i \x3c self__.end):(i \x3e self__.end))){\nvar ret__$1 \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,i) : f.call(null, ret,i));\nif(cljs.core.reduced_QMARK_(ret__$1)){\nreturn cljs.core.deref(ret__$1);\n} else {\nvar G__26367 \x3d (i + self__.step);\nvar G__26368 \x3d ret__$1;\ni \x3d G__26367;\nret \x3d G__26368;\ncontinue;\n}\n} else {\nreturn ret;\n}\nbreak;\n}\n}));\n\n(cljs.core.Range.prototype.cljs$core$ISeq$_first$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn self__.start;\n}));\n\n(cljs.core.Range.prototype.cljs$core$ISeq$_rest$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nvar s \x3d rng__$1.cljs$core$INext$_next$arity$1(null, );\nif((s \x3d\x3d null)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn s;\n}\n}));\n\n(cljs.core.Range.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn rng__$1;\n}));\n\n(cljs.core.Range.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nrng__$1.forceChunk();\n\nreturn self__.chunk;\n}));\n\n(cljs.core.Range.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nrng__$1.forceChunk();\n\nif((self__.chunk_next \x3d\x3d null)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn self__.chunk_next;\n}\n}));\n\n(cljs.core.Range.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (rng,new_meta){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nif((new_meta \x3d\x3d\x3d self__.meta)){\nreturn rng__$1;\n} else {\nreturn (new cljs.core.Range(new_meta,self__.start,self__.end,self__.step,self__.chunk,self__.chunk_next,self__.__hash));\n}\n}));\n\n(cljs.core.Range.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (rng,o){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.cons(o,rng__$1);\n}));\n\n(cljs.core.Range.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 \x3d (function (rng){\nvar self__ \x3d this;\nvar rng__$1 \x3d this;\nreturn cljs.core.seq(rng__$1.cljs$core$IChunkedSeq$_chunked_rest$arity$1(null, ));\n}));\n\n(cljs.core.Range.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 7, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null),new cljs.core.Symbol(null,\x22start\x22,\x22start\x22,1285322546,null),new cljs.core.Symbol(null,\x22end\x22,\x22end\x22,1372345569,null),new cljs.core.Symbol(null,\x22step\x22,\x22step\x22,-1365547645,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22chunk\x22,\x22chunk\x22,449371907,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22chunk-next\x22,\x22chunk-next\x22,-547810434,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Range.cljs$lang$type \x3d true);\n\n(cljs.core.Range.cljs$lang$ctorStr \x3d \x22cljs.core/Range\x22);\n\n(cljs.core.Range.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Range\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Range.\n */\ncljs.core.__GT_Range \x3d (function cljs$core$__GT_Range(meta,start,end,step,chunk,chunk_next,__hash){\nreturn (new cljs.core.Range(meta,start,end,step,chunk,chunk_next,__hash));\n});\n\n(cljs.core.Range.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Returns a lazy seq of nums from start (inclusive) to end\n * (exclusive), by step, where start defaults to 0, step to 1,\n * and end to infinity.\n */\ncljs.core.range \x3d (function cljs$core$range(var_args){\nvar G__19396 \x3d arguments.length;\nswitch (G__19396) {\ncase 0:\nreturn cljs.core.range.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.range.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.range.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.range.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.range.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.range.cljs$core$IFn$_invoke$arity$3((0),Number.MAX_VALUE,(1));\n}));\n\n(cljs.core.range.cljs$core$IFn$_invoke$arity$1 \x3d (function (end){\nreturn cljs.core.range.cljs$core$IFn$_invoke$arity$3((0),end,(1));\n}));\n\n(cljs.core.range.cljs$core$IFn$_invoke$arity$2 \x3d (function (start,end){\nreturn cljs.core.range.cljs$core$IFn$_invoke$arity$3(start,end,(1));\n}));\n\n(cljs.core.range.cljs$core$IFn$_invoke$arity$3 \x3d (function (start,end,step){\nif((step \x3e (0))){\nif((end \x3c\x3d start)){\nreturn cljs.core.List.EMPTY;\n} else {\nif(((cljs.core.integer_QMARK_(start)) \x26\x26 (((cljs.core.integer_QMARK_(end)) \x26\x26 (cljs.core.integer_QMARK_(step)))))){\nreturn (new cljs.core.IntegerRange(null,start,end,step,cljs.core.range_count(start,end,step),null));\n} else {\nreturn (new cljs.core.Range(null,start,end,step,null,null,null));\n}\n}\n} else {\nif((step \x3c (0))){\nif((end \x3e\x3d start)){\nreturn cljs.core.List.EMPTY;\n} else {\nif(((cljs.core.integer_QMARK_(start)) \x26\x26 (((cljs.core.integer_QMARK_(end)) \x26\x26 (cljs.core.integer_QMARK_(step)))))){\nreturn (new cljs.core.IntegerRange(null,start,end,step,cljs.core.range_count(start,end,step),null));\n} else {\nreturn (new cljs.core.Range(null,start,end,step,null,null,null));\n}\n}\n} else {\nif((end \x3d\x3d\x3d start)){\nreturn cljs.core.List.EMPTY;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(start);\n}\n\n}\n}\n}));\n\n(cljs.core.range.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns a lazy seq of every nth item in coll.  Returns a stateful\n *   transducer when no collection is provided.\n */\ncljs.core.take_nth \x3d (function cljs$core$take_nth(var_args){\nvar G__19398 \x3d arguments.length;\nswitch (G__19398) {\ncase 1:\nreturn cljs.core.take_nth.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.take_nth.cljs$core$IFn$_invoke$arity$1 \x3d (function (n){\nif(typeof n \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? n)\x22));\n}\n\nreturn (function (rf){\nvar ia \x3d cljs.core.volatile_BANG_((-1));\nreturn (function() {\nvar G__26446 \x3d null;\nvar G__26446__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26446__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__26446__2 \x3d (function (result,input){\nvar i \x3d ia.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (ia.cljs$core$IDeref$_deref$arity$1(null, ) + (1)));\nif((cljs.core.rem(i,n) \x3d\x3d\x3d (0))){\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n} else {\nreturn result;\n}\n});\nG__26446 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26446__0.call(this);\ncase 1:\nreturn G__26446__1.call(this,result);\ncase 2:\nreturn G__26446__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26446.cljs$core$IFn$_invoke$arity$0 \x3d G__26446__0;\nG__26446.cljs$core$IFn$_invoke$arity$1 \x3d G__26446__1;\nG__26446.cljs$core$IFn$_invoke$arity$2 \x3d G__26446__2;\nreturn G__26446;\n})()\n});\n}));\n\n(cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nif(typeof n \x3d\x3d\x3d \x27number\x27){\n} else {\nthrow (new Error(\x22Assert failed: (number? n)\x22));\n}\n\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nreturn cljs.core.cons(cljs.core.first(s),cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2(n,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,s)));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.take_nth.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a vector of [(take-while pred coll) (drop-while pred coll)]\n */\ncljs.core.split_with \x3d (function cljs$core$split_with(pred,coll){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(pred,coll),cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2(pred,coll)], null);\n});\n/**\n * Applies f to each value in coll, splitting it each time f returns a\n * new value.  Returns a lazy seq of partitions.  Returns a stateful\n * transducer when no collection is provided.\n */\ncljs.core.partition_by \x3d (function cljs$core$partition_by(var_args){\nvar G__19401 \x3d arguments.length;\nswitch (G__19401) {\ncase 1:\nreturn cljs.core.partition_by.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.partition_by.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.partition_by.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn (function (rf){\nvar a \x3d cljs.core.array_list();\nvar pa \x3d cljs.core.volatile_BANG_(new cljs.core.Keyword(\x22cljs.core\x22,\x22none\x22,\x22cljs.core/none\x22,926646439));\nreturn (function() {\nvar G__26492 \x3d null;\nvar G__26492__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26492__1 \x3d (function (result){\nvar result__$1 \x3d (cljs.core.truth_(a.isEmpty())?result:(function (){var v \x3d cljs.core.vec(a.toArray());\na.clear();\n\nreturn cljs.core.unreduced((rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null, result,v)));\n})());\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result__$1) : rf.call(null, result__$1));\n});\nvar G__26492__2 \x3d (function (result,input){\nvar pval \x3d cljs.core.deref(pa);\nvar val \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(input) : f.call(null, input));\ncljs.core.vreset_BANG_(pa,val);\n\nif(((cljs.core.keyword_identical_QMARK_(pval,new cljs.core.Keyword(\x22cljs.core\x22,\x22none\x22,\x22cljs.core/none\x22,926646439))) || (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(val,pval)))){\na.add(input);\n\nreturn result;\n} else {\nvar v \x3d cljs.core.vec(a.toArray());\na.clear();\n\nvar ret \x3d (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null, result,v));\nif(cljs.core.reduced_QMARK_(ret)){\n} else {\na.add(input);\n}\n\nreturn ret;\n}\n});\nG__26492 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26492__0.call(this);\ncase 1:\nreturn G__26492__1.call(this,result);\ncase 2:\nreturn G__26492__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26492.cljs$core$IFn$_invoke$arity$0 \x3d G__26492__0;\nG__26492.cljs$core$IFn$_invoke$arity$1 \x3d G__26492__1;\nG__26492.cljs$core$IFn$_invoke$arity$2 \x3d G__26492__2;\nreturn G__26492;\n})()\n});\n}));\n\n(cljs.core.partition_by.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar fst \x3d cljs.core.first(s);\nvar fv \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(fst) : f.call(null, fst));\nvar run \x3d cljs.core.cons(fst,cljs.core.take_while.cljs$core$IFn$_invoke$arity$2((function (p1__19399_SHARP_){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(fv,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(p1__19399_SHARP_) : f.call(null, p1__19399_SHARP_)));\n}),cljs.core.next(s)));\nreturn cljs.core.cons(run,cljs.core.partition_by.cljs$core$IFn$_invoke$arity$2(f,(new cljs.core.LazySeq(null,(function (){\nreturn cljs.core.drop.cljs$core$IFn$_invoke$arity$2(cljs.core.count(run),s);\n}),null,null))));\n} else {\nreturn null;\n}\n}),null,null));\n}));\n\n(cljs.core.partition_by.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a map from distinct items in coll to the number of times\n *   they appear.\n */\ncljs.core.frequencies \x3d (function cljs$core$frequencies(coll){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (counts,x){\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(counts,x,(cljs.core.get.cljs$core$IFn$_invoke$arity$3(counts,x,(0)) + (1)));\n}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),coll));\n});\n/**\n * Returns a lazy seq of the intermediate values of the reduction (as\n *   per reduce) of coll by f, starting with init.\n */\ncljs.core.reductions \x3d (function cljs$core$reductions(var_args){\nvar G__19403 \x3d arguments.length;\nswitch (G__19403) {\ncase 2:\nreturn cljs.core.reductions.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.reductions.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.reductions.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,coll){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar temp__5802__auto__ \x3d cljs.core.seq(coll);\nif(temp__5802__auto__){\nvar s \x3d temp__5802__auto__;\nreturn cljs.core.reductions.cljs$core$IFn$_invoke$arity$3(f,cljs.core.first(s),cljs.core.rest(s));\n} else {\nreturn (new cljs.core.List(null,(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, )),null,(1),null));\n}\n}),null,null));\n}));\n\n(cljs.core.reductions.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,init,coll){\nif(cljs.core.reduced_QMARK_(init)){\nreturn (new cljs.core.List(null,cljs.core.deref(init),null,(1),null));\n} else {\nreturn cljs.core.cons(init,(new cljs.core.LazySeq(null,(function (){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nreturn cljs.core.reductions.cljs$core$IFn$_invoke$arity$3(f,(function (){var G__19404 \x3d init;\nvar G__19405 \x3d cljs.core.first(s);\nreturn (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__19404,G__19405) : f.call(null, G__19404,G__19405));\n})(),cljs.core.rest(s));\n} else {\nreturn null;\n}\n}),null,null)));\n}\n}));\n\n(cljs.core.reductions.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Takes a set of functions and returns a fn that is the juxtaposition\n *   of those fns.  The returned fn takes a variable number of args, and\n *   returns a vector containing the result of applying each fn to the\n *   args (left-to-right).\n *   ((juxt a b c) x) \x3d\x3e [(a x) (b x) (c x)]\n */\ncljs.core.juxt \x3d (function cljs$core$juxt(var_args){\nvar G__19421 \x3d arguments.length;\nswitch (G__19421) {\ncase 1:\nreturn cljs.core.juxt.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.juxt.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.juxt.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___26551 \x3d arguments.length;\nvar i__5727__auto___26552 \x3d (0);\nwhile(true){\nif((i__5727__auto___26552 \x3c len__5726__auto___26551)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___26552]));\n\nvar G__26553 \x3d (i__5727__auto___26552 + (1));\ni__5727__auto___26552 \x3d G__26553;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((3) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.juxt.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.juxt.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn (function() {\nvar G__26554 \x3d null;\nvar G__26554__0 \x3d (function (){\nreturn (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ))],null));\n});\nvar G__26554__1 \x3d (function (x){\nreturn (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x))],null));\n});\nvar G__26554__2 \x3d (function (x,y){\nreturn (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null, x,y))],null));\n});\nvar G__26554__3 \x3d (function (x,y,z){\nreturn (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(x,y,z) : f.call(null, x,y,z))],null));\n});\nvar G__26554__4 \x3d (function() { \nvar G__26561__delegate \x3d function (x,y,z,args){\nreturn (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,x,y,z,args)],null));\n};\nvar G__26561 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26564__i \x3d 0, G__26564__a \x3d new Array(arguments.length -  3);\nwhile (G__26564__i \x3c G__26564__a.length) {G__26564__a[G__26564__i] \x3d arguments[G__26564__i + 3]; ++G__26564__i;}\n  args \x3d new cljs.core.IndexedSeq(G__26564__a,0,null);\n} \nreturn G__26561__delegate.call(this,x,y,z,args);};\nG__26561.cljs$lang$maxFixedArity \x3d 3;\nG__26561.cljs$lang$applyTo \x3d (function (arglist__26565){\nvar x \x3d cljs.core.first(arglist__26565);\narglist__26565 \x3d cljs.core.next(arglist__26565);\nvar y \x3d cljs.core.first(arglist__26565);\narglist__26565 \x3d cljs.core.next(arglist__26565);\nvar z \x3d cljs.core.first(arglist__26565);\nvar args \x3d cljs.core.rest(arglist__26565);\nreturn G__26561__delegate(x,y,z,args);\n});\nG__26561.cljs$core$IFn$_invoke$arity$variadic \x3d G__26561__delegate;\nreturn G__26561;\n})()\n;\nG__26554 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__26554__0.call(this);\ncase 1:\nreturn G__26554__1.call(this,x);\ncase 2:\nreturn G__26554__2.call(this,x,y);\ncase 3:\nreturn G__26554__3.call(this,x,y,z);\ndefault:\nvar G__26567 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26568__i \x3d 0, G__26568__a \x3d new Array(arguments.length -  3);\nwhile (G__26568__i \x3c G__26568__a.length) {G__26568__a[G__26568__i] \x3d arguments[G__26568__i + 3]; ++G__26568__i;}\nG__26567 \x3d new cljs.core.IndexedSeq(G__26568__a,0,null);\n}\nreturn G__26554__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__26567);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26554.cljs$lang$maxFixedArity \x3d 3;\nG__26554.cljs$lang$applyTo \x3d G__26554__4.cljs$lang$applyTo;\nG__26554.cljs$core$IFn$_invoke$arity$0 \x3d G__26554__0;\nG__26554.cljs$core$IFn$_invoke$arity$1 \x3d G__26554__1;\nG__26554.cljs$core$IFn$_invoke$arity$2 \x3d G__26554__2;\nG__26554.cljs$core$IFn$_invoke$arity$3 \x3d G__26554__3;\nG__26554.cljs$core$IFn$_invoke$arity$variadic \x3d G__26554__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__26554;\n})()\n}));\n\n(cljs.core.juxt.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,g){\nreturn (function() {\nvar G__26570 \x3d null;\nvar G__26570__0 \x3d (function (){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, )),(g.cljs$core$IFn$_invoke$arity$0 ? g.cljs$core$IFn$_invoke$arity$0() : g.call(null, ))],null));\n});\nvar G__26570__1 \x3d (function (x){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x)),(g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(x) : g.call(null, x))],null));\n});\nvar G__26570__2 \x3d (function (x,y){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null, x,y)),(g.cljs$core$IFn$_invoke$arity$2 ? g.cljs$core$IFn$_invoke$arity$2(x,y) : g.call(null, x,y))],null));\n});\nvar G__26570__3 \x3d (function (x,y,z){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(x,y,z) : f.call(null, x,y,z)),(g.cljs$core$IFn$_invoke$arity$3 ? g.cljs$core$IFn$_invoke$arity$3(x,y,z) : g.call(null, x,y,z))],null));\n});\nvar G__26570__4 \x3d (function() { \nvar G__26579__delegate \x3d function (x,y,z,args){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,x,y,z,args),cljs.core.apply.cljs$core$IFn$_invoke$arity$5(g,x,y,z,args)],null));\n};\nvar G__26579 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26581__i \x3d 0, G__26581__a \x3d new Array(arguments.length -  3);\nwhile (G__26581__i \x3c G__26581__a.length) {G__26581__a[G__26581__i] \x3d arguments[G__26581__i + 3]; ++G__26581__i;}\n  args \x3d new cljs.core.IndexedSeq(G__26581__a,0,null);\n} \nreturn G__26579__delegate.call(this,x,y,z,args);};\nG__26579.cljs$lang$maxFixedArity \x3d 3;\nG__26579.cljs$lang$applyTo \x3d (function (arglist__26582){\nvar x \x3d cljs.core.first(arglist__26582);\narglist__26582 \x3d cljs.core.next(arglist__26582);\nvar y \x3d cljs.core.first(arglist__26582);\narglist__26582 \x3d cljs.core.next(arglist__26582);\nvar z \x3d cljs.core.first(arglist__26582);\nvar args \x3d cljs.core.rest(arglist__26582);\nreturn G__26579__delegate(x,y,z,args);\n});\nG__26579.cljs$core$IFn$_invoke$arity$variadic \x3d G__26579__delegate;\nreturn G__26579;\n})()\n;\nG__26570 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__26570__0.call(this);\ncase 1:\nreturn G__26570__1.call(this,x);\ncase 2:\nreturn G__26570__2.call(this,x,y);\ncase 3:\nreturn G__26570__3.call(this,x,y,z);\ndefault:\nvar G__26583 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26584__i \x3d 0, G__26584__a \x3d new Array(arguments.length -  3);\nwhile (G__26584__i \x3c G__26584__a.length) {G__26584__a[G__26584__i] \x3d arguments[G__26584__i + 3]; ++G__26584__i;}\nG__26583 \x3d new cljs.core.IndexedSeq(G__26584__a,0,null);\n}\nreturn G__26570__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__26583);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26570.cljs$lang$maxFixedArity \x3d 3;\nG__26570.cljs$lang$applyTo \x3d G__26570__4.cljs$lang$applyTo;\nG__26570.cljs$core$IFn$_invoke$arity$0 \x3d G__26570__0;\nG__26570.cljs$core$IFn$_invoke$arity$1 \x3d G__26570__1;\nG__26570.cljs$core$IFn$_invoke$arity$2 \x3d G__26570__2;\nG__26570.cljs$core$IFn$_invoke$arity$3 \x3d G__26570__3;\nG__26570.cljs$core$IFn$_invoke$arity$variadic \x3d G__26570__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__26570;\n})()\n}));\n\n(cljs.core.juxt.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,g,h){\nreturn (function() {\nvar G__26586 \x3d null;\nvar G__26586__0 \x3d (function (){\nreturn (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, )),(g.cljs$core$IFn$_invoke$arity$0 ? g.cljs$core$IFn$_invoke$arity$0() : g.call(null, )),(h.cljs$core$IFn$_invoke$arity$0 ? h.cljs$core$IFn$_invoke$arity$0() : h.call(null, ))],null));\n});\nvar G__26586__1 \x3d (function (x){\nreturn (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x)),(g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(x) : g.call(null, x)),(h.cljs$core$IFn$_invoke$arity$1 ? h.cljs$core$IFn$_invoke$arity$1(x) : h.call(null, x))],null));\n});\nvar G__26586__2 \x3d (function (x,y){\nreturn (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null, x,y)),(g.cljs$core$IFn$_invoke$arity$2 ? g.cljs$core$IFn$_invoke$arity$2(x,y) : g.call(null, x,y)),(h.cljs$core$IFn$_invoke$arity$2 ? h.cljs$core$IFn$_invoke$arity$2(x,y) : h.call(null, x,y))],null));\n});\nvar G__26586__3 \x3d (function (x,y,z){\nreturn (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(x,y,z) : f.call(null, x,y,z)),(g.cljs$core$IFn$_invoke$arity$3 ? g.cljs$core$IFn$_invoke$arity$3(x,y,z) : g.call(null, x,y,z)),(h.cljs$core$IFn$_invoke$arity$3 ? h.cljs$core$IFn$_invoke$arity$3(x,y,z) : h.call(null, x,y,z))],null));\n});\nvar G__26586__4 \x3d (function() { \nvar G__26596__delegate \x3d function (x,y,z,args){\nreturn (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,x,y,z,args),cljs.core.apply.cljs$core$IFn$_invoke$arity$5(g,x,y,z,args),cljs.core.apply.cljs$core$IFn$_invoke$arity$5(h,x,y,z,args)],null));\n};\nvar G__26596 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26597__i \x3d 0, G__26597__a \x3d new Array(arguments.length -  3);\nwhile (G__26597__i \x3c G__26597__a.length) {G__26597__a[G__26597__i] \x3d arguments[G__26597__i + 3]; ++G__26597__i;}\n  args \x3d new cljs.core.IndexedSeq(G__26597__a,0,null);\n} \nreturn G__26596__delegate.call(this,x,y,z,args);};\nG__26596.cljs$lang$maxFixedArity \x3d 3;\nG__26596.cljs$lang$applyTo \x3d (function (arglist__26598){\nvar x \x3d cljs.core.first(arglist__26598);\narglist__26598 \x3d cljs.core.next(arglist__26598);\nvar y \x3d cljs.core.first(arglist__26598);\narglist__26598 \x3d cljs.core.next(arglist__26598);\nvar z \x3d cljs.core.first(arglist__26598);\nvar args \x3d cljs.core.rest(arglist__26598);\nreturn G__26596__delegate(x,y,z,args);\n});\nG__26596.cljs$core$IFn$_invoke$arity$variadic \x3d G__26596__delegate;\nreturn G__26596;\n})()\n;\nG__26586 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__26586__0.call(this);\ncase 1:\nreturn G__26586__1.call(this,x);\ncase 2:\nreturn G__26586__2.call(this,x,y);\ncase 3:\nreturn G__26586__3.call(this,x,y,z);\ndefault:\nvar G__26599 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26600__i \x3d 0, G__26600__a \x3d new Array(arguments.length -  3);\nwhile (G__26600__i \x3c G__26600__a.length) {G__26600__a[G__26600__i] \x3d arguments[G__26600__i + 3]; ++G__26600__i;}\nG__26599 \x3d new cljs.core.IndexedSeq(G__26600__a,0,null);\n}\nreturn G__26586__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__26599);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26586.cljs$lang$maxFixedArity \x3d 3;\nG__26586.cljs$lang$applyTo \x3d G__26586__4.cljs$lang$applyTo;\nG__26586.cljs$core$IFn$_invoke$arity$0 \x3d G__26586__0;\nG__26586.cljs$core$IFn$_invoke$arity$1 \x3d G__26586__1;\nG__26586.cljs$core$IFn$_invoke$arity$2 \x3d G__26586__2;\nG__26586.cljs$core$IFn$_invoke$arity$3 \x3d G__26586__3;\nG__26586.cljs$core$IFn$_invoke$arity$variadic \x3d G__26586__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__26586;\n})()\n}));\n\n(cljs.core.juxt.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,g,h,fs){\nvar fs__$1 \x3d cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(f,g,h,fs);\nreturn (function() {\nvar G__26602 \x3d null;\nvar G__26602__0 \x3d (function (){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19406_SHARP_,p2__19407_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__19406_SHARP_,(p2__19407_SHARP_.cljs$core$IFn$_invoke$arity$0 ? p2__19407_SHARP_.cljs$core$IFn$_invoke$arity$0() : p2__19407_SHARP_.call(null, )));\n}),cljs.core.PersistentVector.EMPTY,fs__$1);\n});\nvar G__26602__1 \x3d (function (x){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19408_SHARP_,p2__19409_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__19408_SHARP_,(p2__19409_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p2__19409_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p2__19409_SHARP_.call(null, x)));\n}),cljs.core.PersistentVector.EMPTY,fs__$1);\n});\nvar G__26602__2 \x3d (function (x,y){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19410_SHARP_,p2__19411_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__19410_SHARP_,(p2__19411_SHARP_.cljs$core$IFn$_invoke$arity$2 ? p2__19411_SHARP_.cljs$core$IFn$_invoke$arity$2(x,y) : p2__19411_SHARP_.call(null, x,y)));\n}),cljs.core.PersistentVector.EMPTY,fs__$1);\n});\nvar G__26602__3 \x3d (function (x,y,z){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19412_SHARP_,p2__19413_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__19412_SHARP_,(p2__19413_SHARP_.cljs$core$IFn$_invoke$arity$3 ? p2__19413_SHARP_.cljs$core$IFn$_invoke$arity$3(x,y,z) : p2__19413_SHARP_.call(null, x,y,z)));\n}),cljs.core.PersistentVector.EMPTY,fs__$1);\n});\nvar G__26602__4 \x3d (function() { \nvar G__26607__delegate \x3d function (x,y,z,args){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19414_SHARP_,p2__19415_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__19414_SHARP_,cljs.core.apply.cljs$core$IFn$_invoke$arity$5(p2__19415_SHARP_,x,y,z,args));\n}),cljs.core.PersistentVector.EMPTY,fs__$1);\n};\nvar G__26607 \x3d function (x,y,z,var_args){\nvar args \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26608__i \x3d 0, G__26608__a \x3d new Array(arguments.length -  3);\nwhile (G__26608__i \x3c G__26608__a.length) {G__26608__a[G__26608__i] \x3d arguments[G__26608__i + 3]; ++G__26608__i;}\n  args \x3d new cljs.core.IndexedSeq(G__26608__a,0,null);\n} \nreturn G__26607__delegate.call(this,x,y,z,args);};\nG__26607.cljs$lang$maxFixedArity \x3d 3;\nG__26607.cljs$lang$applyTo \x3d (function (arglist__26609){\nvar x \x3d cljs.core.first(arglist__26609);\narglist__26609 \x3d cljs.core.next(arglist__26609);\nvar y \x3d cljs.core.first(arglist__26609);\narglist__26609 \x3d cljs.core.next(arglist__26609);\nvar z \x3d cljs.core.first(arglist__26609);\nvar args \x3d cljs.core.rest(arglist__26609);\nreturn G__26607__delegate(x,y,z,args);\n});\nG__26607.cljs$core$IFn$_invoke$arity$variadic \x3d G__26607__delegate;\nreturn G__26607;\n})()\n;\nG__26602 \x3d function(x,y,z,var_args){\nvar args \x3d var_args;\nswitch(arguments.length){\ncase 0:\nreturn G__26602__0.call(this);\ncase 1:\nreturn G__26602__1.call(this,x);\ncase 2:\nreturn G__26602__2.call(this,x,y);\ncase 3:\nreturn G__26602__3.call(this,x,y,z);\ndefault:\nvar G__26613 \x3d null;\nif (arguments.length \x3e 3) {\nvar G__26614__i \x3d 0, G__26614__a \x3d new Array(arguments.length -  3);\nwhile (G__26614__i \x3c G__26614__a.length) {G__26614__a[G__26614__i] \x3d arguments[G__26614__i + 3]; ++G__26614__i;}\nG__26613 \x3d new cljs.core.IndexedSeq(G__26614__a,0,null);\n}\nreturn G__26602__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__26613);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26602.cljs$lang$maxFixedArity \x3d 3;\nG__26602.cljs$lang$applyTo \x3d G__26602__4.cljs$lang$applyTo;\nG__26602.cljs$core$IFn$_invoke$arity$0 \x3d G__26602__0;\nG__26602.cljs$core$IFn$_invoke$arity$1 \x3d G__26602__1;\nG__26602.cljs$core$IFn$_invoke$arity$2 \x3d G__26602__2;\nG__26602.cljs$core$IFn$_invoke$arity$3 \x3d G__26602__3;\nG__26602.cljs$core$IFn$_invoke$arity$variadic \x3d G__26602__4.cljs$core$IFn$_invoke$arity$variadic;\nreturn G__26602;\n})()\n}));\n\n/** @this {Function} */\n(cljs.core.juxt.cljs$lang$applyTo \x3d (function (seq19417){\nvar G__19418 \x3d cljs.core.first(seq19417);\nvar seq19417__$1 \x3d cljs.core.next(seq19417);\nvar G__19419 \x3d cljs.core.first(seq19417__$1);\nvar seq19417__$2 \x3d cljs.core.next(seq19417__$1);\nvar G__19420 \x3d cljs.core.first(seq19417__$2);\nvar seq19417__$3 \x3d cljs.core.next(seq19417__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19418,G__19419,G__19420,seq19417__$3);\n}));\n\n(cljs.core.juxt.cljs$lang$maxFixedArity \x3d (3));\n\n/**\n * When lazy sequences are produced via functions that have side\n *   effects, any effects other than those needed to produce the first\n *   element in the seq do not occur until the seq is consumed. dorun can\n *   be used to force any effects. Walks through the successive nexts of\n *   the seq, does not retain the head and returns nil.\n */\ncljs.core.dorun \x3d (function cljs$core$dorun(var_args){\nvar G__19440 \x3d arguments.length;\nswitch (G__19440) {\ncase 1:\nreturn cljs.core.dorun.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.dorun.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.dorun.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(coll);\nif(temp__5804__auto__){\nvar s \x3d temp__5804__auto__;\nvar G__26636 \x3d cljs.core.next(s);\ncoll \x3d G__26636;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(cljs.core.dorun.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\nwhile(true){\nif(((cljs.core.seq(coll)) \x26\x26 ((n \x3e (0))))){\nvar G__26639 \x3d (n - (1));\nvar G__26640 \x3d cljs.core.next(coll);\nn \x3d G__26639;\ncoll \x3d G__26640;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(cljs.core.dorun.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * When lazy sequences are produced via functions that have side\n *   effects, any effects other than those needed to produce the first\n *   element in the seq do not occur until the seq is consumed. doall can\n *   be used to force any effects. Walks through the successive nexts of\n *   the seq, retains the head and returns it, thus causing the entire\n *   seq to reside in memory at one time.\n */\ncljs.core.doall \x3d (function cljs$core$doall(var_args){\nvar G__19447 \x3d arguments.length;\nswitch (G__19447) {\ncase 1:\nreturn cljs.core.doall.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.doall.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.doall.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\ncljs.core.dorun.cljs$core$IFn$_invoke$arity$1(coll);\n\nreturn coll;\n}));\n\n(cljs.core.doall.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,coll){\ncljs.core.dorun.cljs$core$IFn$_invoke$arity$2(n,coll);\n\nreturn coll;\n}));\n\n(cljs.core.doall.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns true if x is a JavaScript RegExp instance.\n */\ncljs.core.regexp_QMARK_ \x3d (function cljs$core$regexp_QMARK_(x){\nreturn (x instanceof RegExp);\n});\n/**\n * Returns the result of (re-find re s) if re fully matches s.\n */\ncljs.core.re_matches \x3d (function cljs$core$re_matches(re,s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\nvar matches \x3d re.exec(s);\nif((((!((matches \x3d\x3d null)))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((matches[(0)]),s)))){\nif((((matches).length) \x3d\x3d\x3d (1))){\nreturn (matches[(0)]);\n} else {\nreturn cljs.core.vec(matches);\n}\n} else {\nreturn null;\n}\n} else {\nthrow (new TypeError(\x22re-matches must match against a string.\x22));\n}\n});\n/**\n * Returns the first regex match, if any, of s to re, using\n *   re.exec(s). Returns a vector, containing first the matching\n *   substring, then any capturing groups if the regular expression contains\n *   capturing groups.\n */\ncljs.core.re_find \x3d (function cljs$core$re_find(re,s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\nvar matches \x3d re.exec(s);\nif((matches \x3d\x3d null)){\nreturn null;\n} else {\nif((((matches).length) \x3d\x3d\x3d (1))){\nreturn (matches[(0)]);\n} else {\nreturn cljs.core.vec(matches);\n}\n}\n} else {\nthrow (new TypeError(\x22re-find must match against a string.\x22));\n}\n});\ncljs.core.re_seq_STAR_ \x3d (function cljs$core$re_seq_STAR_(re,s){\nvar temp__5808__auto__ \x3d re.exec(s);\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar matches \x3d temp__5808__auto__;\nvar match_str \x3d (matches[(0)]);\nvar match_vals \x3d (((matches.length \x3d\x3d\x3d (1)))?match_str:cljs.core.vec(matches));\nreturn cljs.core.cons(match_vals,(new cljs.core.LazySeq(null,(function (){\nvar post_idx \x3d (matches.index + (function (){var x__5087__auto__ \x3d (1);\nvar y__5088__auto__ \x3d match_str.length;\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})());\nif((post_idx \x3c\x3d s.length)){\nvar G__19460 \x3d re;\nvar G__19461 \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,post_idx);\nreturn (cljs.core.re_seq_STAR_.cljs$core$IFn$_invoke$arity$2 ? cljs.core.re_seq_STAR_.cljs$core$IFn$_invoke$arity$2(G__19460,G__19461) : cljs.core.re_seq_STAR_.call(null, G__19460,G__19461));\n} else {\nreturn null;\n}\n}),null,null)));\n}\n});\n/**\n * Returns a lazy sequence of successive matches of re in s.\n */\ncljs.core.re_seq \x3d (function cljs$core$re_seq(re,s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\nreturn cljs.core.re_seq_STAR_(re,s);\n} else {\nthrow (new TypeError(\x22re-seq must match against a string.\x22));\n}\n});\n/**\n * Returns an instance of RegExp which has compiled the provided string.\n */\ncljs.core.re_pattern \x3d (function cljs$core$re_pattern(s){\nif((s instanceof RegExp)){\nreturn s;\n} else {\nvar vec__19469 \x3d cljs.core.re_find(/^\\(\\?([idmsux]*)\\)/,s);\nvar prefix \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19469,(0),null);\nvar flags \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19469,(1),null);\nvar pattern \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(((prefix \x3d\x3d null))?(0):((prefix).length)));\nreturn (new RegExp(pattern,(function (){var or__5002__auto__ \x3d flags;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn \x22\x22;\n}\n})()));\n}\n});\ncljs.core.pr_sequential_writer \x3d (function cljs$core$pr_sequential_writer(writer,print_one,begin,sep,end,opts,coll){\nvar _STAR_print_level_STAR__orig_val__19481 \x3d cljs.core._STAR_print_level_STAR_;\nvar _STAR_print_level_STAR__temp_val__19482 \x3d (((cljs.core._STAR_print_level_STAR_ \x3d\x3d null))?null:(cljs.core._STAR_print_level_STAR_ - (1)));\n(cljs.core._STAR_print_level_STAR_ \x3d _STAR_print_level_STAR__temp_val__19482);\n\ntry{if((((!((cljs.core._STAR_print_level_STAR_ \x3d\x3d null)))) \x26\x26 ((cljs.core._STAR_print_level_STAR_ \x3c (0))))){\nreturn cljs.core._write(writer,\x22#\x22);\n} else {\ncljs.core._write(writer,begin);\n\nif((new cljs.core.Keyword(null,\x22print-length\x22,\x22print-length\x22,1931866356).cljs$core$IFn$_invoke$arity$1(opts) \x3d\x3d\x3d (0))){\nif(cljs.core.seq(coll)){\ncljs.core._write(writer,(function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22more-marker\x22,\x22more-marker\x22,-14717935).cljs$core$IFn$_invoke$arity$1(opts);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn \x22...\x22;\n}\n})());\n} else {\n}\n} else {\nif(cljs.core.seq(coll)){\nvar G__19484_26659 \x3d cljs.core.first(coll);\nvar G__19485_26660 \x3d writer;\nvar G__19486_26661 \x3d opts;\n(print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__19484_26659,G__19485_26660,G__19486_26661) : print_one.call(null, G__19484_26659,G__19485_26660,G__19486_26661));\n} else {\n}\n\nvar coll_26665__$1 \x3d cljs.core.next(coll);\nvar n_26666 \x3d (new cljs.core.Keyword(null,\x22print-length\x22,\x22print-length\x22,1931866356).cljs$core$IFn$_invoke$arity$1(opts) - (1));\nwhile(true){\nif(((coll_26665__$1) \x26\x26 ((((n_26666 \x3d\x3d null)) || ((!((n_26666 \x3d\x3d\x3d (0))))))))){\ncljs.core._write(writer,sep);\n\nvar G__19487_26667 \x3d cljs.core.first(coll_26665__$1);\nvar G__19488_26668 \x3d writer;\nvar G__19489_26669 \x3d opts;\n(print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__19487_26667,G__19488_26668,G__19489_26669) : print_one.call(null, G__19487_26667,G__19488_26668,G__19489_26669));\n\nvar G__26671 \x3d cljs.core.next(coll_26665__$1);\nvar G__26672 \x3d (n_26666 - (1));\ncoll_26665__$1 \x3d G__26671;\nn_26666 \x3d G__26672;\ncontinue;\n} else {\nif(((cljs.core.seq(coll_26665__$1)) \x26\x26 ((n_26666 \x3d\x3d\x3d (0))))){\ncljs.core._write(writer,sep);\n\ncljs.core._write(writer,(function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22more-marker\x22,\x22more-marker\x22,-14717935).cljs$core$IFn$_invoke$arity$1(opts);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn \x22...\x22;\n}\n})());\n} else {\n}\n}\nbreak;\n}\n}\n\nreturn cljs.core._write(writer,end);\n}\n}finally {(cljs.core._STAR_print_level_STAR_ \x3d _STAR_print_level_STAR__orig_val__19481);\n}});\ncljs.core.write_all \x3d (function cljs$core$write_all(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26674 \x3d arguments.length;\nvar i__5727__auto___26675 \x3d (0);\nwhile(true){\nif((i__5727__auto___26675 \x3c len__5726__auto___26674)){\nargs__5732__auto__.push((arguments[i__5727__auto___26675]));\n\nvar G__26676 \x3d (i__5727__auto___26675 + (1));\ni__5727__auto___26675 \x3d G__26676;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic \x3d (function (writer,ss){\nvar seq__19492 \x3d cljs.core.seq(ss);\nvar chunk__19493 \x3d null;\nvar count__19494 \x3d (0);\nvar i__19495 \x3d (0);\nwhile(true){\nif((i__19495 \x3c count__19494)){\nvar s \x3d chunk__19493.cljs$core$IIndexed$_nth$arity$2(null, i__19495);\ncljs.core._write(writer,s);\n\n\nvar G__26677 \x3d seq__19492;\nvar G__26678 \x3d chunk__19493;\nvar G__26679 \x3d count__19494;\nvar G__26680 \x3d (i__19495 + (1));\nseq__19492 \x3d G__26677;\nchunk__19493 \x3d G__26678;\ncount__19494 \x3d G__26679;\ni__19495 \x3d G__26680;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__19492);\nif(temp__5804__auto__){\nvar seq__19492__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__19492__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__19492__$1);\nvar G__26681 \x3d cljs.core.chunk_rest(seq__19492__$1);\nvar G__26682 \x3d c__5525__auto__;\nvar G__26683 \x3d cljs.core.count(c__5525__auto__);\nvar G__26684 \x3d (0);\nseq__19492 \x3d G__26681;\nchunk__19493 \x3d G__26682;\ncount__19494 \x3d G__26683;\ni__19495 \x3d G__26684;\ncontinue;\n} else {\nvar s \x3d cljs.core.first(seq__19492__$1);\ncljs.core._write(writer,s);\n\n\nvar G__26688 \x3d cljs.core.next(seq__19492__$1);\nvar G__26689 \x3d null;\nvar G__26690 \x3d (0);\nvar G__26691 \x3d (0);\nseq__19492 \x3d G__26688;\nchunk__19493 \x3d G__26689;\ncount__19494 \x3d G__26690;\ni__19495 \x3d G__26691;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.write_all.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.write_all.cljs$lang$applyTo \x3d (function (seq19490){\nvar G__19491 \x3d cljs.core.first(seq19490);\nvar seq19490__$1 \x3d cljs.core.next(seq19490);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19491,seq19490__$1);\n}));\n\ncljs.core.string_print \x3d (function cljs$core$string_print(x){\nif((cljs.core._STAR_print_fn_STAR_ \x3d\x3d null)){\nthrow (new Error(\x22No *print-fn* fn set for evaluation environment\x22));\n} else {\n}\n\ncljs.core._STAR_print_fn_STAR_.call(null, x);\n\nreturn null;\n});\ncljs.core.flush \x3d (function cljs$core$flush(){\nreturn null;\n});\ncljs.core.char_escapes \x3d (function (){var obj19497 \x3d ({\x22\\\x22\x22:\x22\\\\\\\x22\x22,\x22\\\\\x22:\x22\\\\\\\\\x22,\x22\\b\x22:\x22\\\\b\x22,\x22\\f\x22:\x22\\\\f\x22,\x22\\n\x22:\x22\\\\n\x22,\x22\\r\x22:\x22\\\\r\x22,\x22\\t\x22:\x22\\\\t\x22});\nreturn obj19497;\n})();\ncljs.core.quote_string \x3d (function cljs$core$quote_string(s){\nreturn [\x22\\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(s.replace(RegExp(\x22[\\\\\\\\\\\x22\\b\\f\\n\\r\\t]\x22,\x22g\x22),(function (match){\nreturn (cljs.core.char_escapes[match]);\n}))),\x22\\\x22\x22].join(\x27\x27);\n});\ncljs.core.print_meta_QMARK_ \x3d (function cljs$core$print_meta_QMARK_(opts,obj){\nvar and__5000__auto__ \x3d cljs.core.boolean$(cljs.core.get.cljs$core$IFn$_invoke$arity$2(opts,new cljs.core.Keyword(null,\x22meta\x22,\x22meta\x22,1499536964)));\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d (((!((obj \x3d\x3d null))))?(((((obj.cljs$lang$protocol_mask$partition0$ \x26 (131072))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d obj.cljs$core$IMeta$))))?true:false):false);\nif(and__5000__auto____$1){\nreturn (!((cljs.core.meta(obj) \x3d\x3d null)));\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n});\ncljs.core.pr_writer_impl \x3d (function cljs$core$pr_writer_impl(obj,writer,opts){\nif((obj \x3d\x3d null)){\nreturn cljs.core._write(writer,\x22nil\x22);\n} else {\nif(cljs.core.print_meta_QMARK_(opts,obj)){\ncljs.core._write(writer,\x22^\x22);\n\nvar G__19499_26697 \x3d cljs.core.meta(obj);\nvar G__19500_26698 \x3d writer;\nvar G__19501_26699 \x3d opts;\n(cljs.core.pr_writer.cljs$core$IFn$_invoke$arity$3 ? cljs.core.pr_writer.cljs$core$IFn$_invoke$arity$3(G__19499_26697,G__19500_26698,G__19501_26699) : cljs.core.pr_writer.call(null, G__19499_26697,G__19500_26698,G__19501_26699));\n\ncljs.core._write(writer,\x22 \x22);\n} else {\n}\n\nif(obj.cljs$lang$type){\nreturn obj.cljs$lang$ctorPrWriter(obj,writer,opts);\n} else {\nif((((!((obj \x3d\x3d null))))?(((((obj.cljs$lang$protocol_mask$partition0$ \x26 (2147483648))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d obj.cljs$core$IPrintWithWriter$))))?true:(((!obj.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IPrintWithWriter,obj):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IPrintWithWriter,obj))){\nreturn cljs.core._pr_writer(obj,writer,opts);\n} else {\nif(((obj \x3d\x3d\x3d true) || (obj \x3d\x3d\x3d false))){\nreturn cljs.core._write(writer,cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj));\n} else {\nif(typeof obj \x3d\x3d\x3d \x27number\x27){\nreturn cljs.core._write(writer,((isNaN(obj))?\x22##NaN\x22:(((obj \x3d\x3d\x3d Number.POSITIVE_INFINITY))?\x22##Inf\x22:(((obj \x3d\x3d\x3d Number.NEGATIVE_INFINITY))?\x22##-Inf\x22:cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj)\n))));\n} else {\nif(cljs.core.object_QMARK_(obj)){\ncljs.core._write(writer,\x22#js \x22);\n\nvar G__19503 \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (k){\nreturn (new cljs.core.MapEntry((function (){var G__19507 \x3d k;\nif((!((cljs.core.re_matches(/[A-Za-z_\\*\\+\\?!\\-\x27][\\w\\*\\+\\?!\\-\x27]*/,k) \x3d\x3d null)))){\nreturn cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(G__19507);\n} else {\nreturn G__19507;\n}\n})(),(obj[k]),null));\n}),cljs.core.js_keys(obj));\nvar G__19504 \x3d cljs.core.pr_writer;\nvar G__19505 \x3d writer;\nvar G__19506 \x3d opts;\nreturn (cljs.core.print_map.cljs$core$IFn$_invoke$arity$4 ? cljs.core.print_map.cljs$core$IFn$_invoke$arity$4(G__19503,G__19504,G__19505,G__19506) : cljs.core.print_map.call(null, G__19503,G__19504,G__19505,G__19506));\n} else {\nif(cljs.core.array_QMARK_(obj)){\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22#js [\x22,\x22 \x22,\x22]\x22,opts,obj);\n} else {\nif(typeof obj \x3d\x3d\x3d \x27string\x27){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22readably\x22,\x22readably\x22,1129599760).cljs$core$IFn$_invoke$arity$1(opts))){\nreturn cljs.core._write(writer,cljs.core.quote_string(obj));\n} else {\nreturn cljs.core._write(writer,obj);\n}\n} else {\nif(typeof obj \x3d\x3d\x3d \x27function\x27){\nvar name \x3d obj.name;\nvar name__$1 \x3d (cljs.core.truth_((function (){var or__5002__auto__ \x3d (name \x3d\x3d null);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn goog.string.isEmpty(name);\n}\n})())?\x22Function\x22:name);\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22#object[\x22,name__$1,(cljs.core.truth_(cljs.core._STAR_print_fn_bodies_STAR_)?[\x22 \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj),\x22\\\x22\x22].join(\x27\x27):\x22\x22),\x22]\x22], 0));\n} else {\nif((obj instanceof Date)){\nvar normalize \x3d (function (n,len){\nvar ns \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(n);\nwhile(true){\nif((((ns).length) \x3c len)){\nvar G__26701 \x3d [\x220\x22,ns].join(\x27\x27);\nns \x3d G__26701;\ncontinue;\n} else {\nreturn ns;\n}\nbreak;\n}\n});\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22#inst \\\x22\x22,normalize(obj.getUTCFullYear(),(4)),\x22-\x22,normalize((obj.getUTCMonth() + (1)),(2)),\x22-\x22,normalize(obj.getUTCDate(),(2)),\x22T\x22,normalize(obj.getUTCHours(),(2)),\x22:\x22,normalize(obj.getUTCMinutes(),(2)),\x22:\x22,normalize(obj.getUTCSeconds(),(2)),\x22.\x22,normalize(obj.getUTCMilliseconds(),(3)),\x22-\x22,\x2200:00\\\x22\x22], 0));\n} else {\nif(cljs.core.regexp_QMARK_(obj)){\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22#\\\x22\x22,obj.source,\x22\\\x22\x22], 0));\n} else {\nif(cljs.core.js_symbol_QMARK_(obj)){\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22#object[\x22,obj.toString(),\x22]\x22], 0));\n} else {\nif(cljs.core.truth_((function (){var G__19508 \x3d obj;\nvar G__19508__$1 \x3d (((G__19508 \x3d\x3d null))?null:G__19508.constructor);\nif((G__19508__$1 \x3d\x3d null)){\nreturn null;\n} else {\nreturn G__19508__$1.cljs$lang$ctorStr;\n}\n})())){\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22#object[\x22,obj.constructor.cljs$lang$ctorStr.replace((new RegExp(\x22/\x22,\x22g\x22)),\x22.\x22),\x22]\x22], 0));\n} else {\nvar name \x3d (function (){var G__19509 \x3d obj;\nvar G__19509__$1 \x3d (((G__19509 \x3d\x3d null))?null:G__19509.constructor);\nif((G__19509__$1 \x3d\x3d null)){\nreturn null;\n} else {\nreturn G__19509__$1.name;\n}\n})();\nvar name__$1 \x3d (cljs.core.truth_((function (){var or__5002__auto__ \x3d (name \x3d\x3d null);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn goog.string.isEmpty(name);\n}\n})())?\x22Object\x22:name);\nif((obj.constructor \x3d\x3d null)){\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22#object[\x22,name__$1,\x22]\x22], 0));\n} else {\nreturn cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22#object[\x22,name__$1,\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj),\x22]\x22], 0));\n}\n}\n\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n\n}\n});\n/**\n * Prefer this to pr-seq, because it makes the printing function\n * configurable, allowing efficient implementations such as appending\n * to a StringBuffer.\n */\ncljs.core.pr_writer \x3d (function cljs$core$pr_writer(obj,writer,opts){\nvar temp__5802__auto__ \x3d new cljs.core.Keyword(null,\x22alt-impl\x22,\x22alt-impl\x22,670969595).cljs$core$IFn$_invoke$arity$1(opts);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar alt_impl \x3d temp__5802__auto__;\nvar G__19510 \x3d obj;\nvar G__19511 \x3d writer;\nvar G__19512 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(opts,new cljs.core.Keyword(null,\x22fallback-impl\x22,\x22fallback-impl\x22,-1501286995),cljs.core.pr_writer_impl);\nreturn (alt_impl.cljs$core$IFn$_invoke$arity$3 ? alt_impl.cljs$core$IFn$_invoke$arity$3(G__19510,G__19511,G__19512) : alt_impl.call(null, G__19510,G__19511,G__19512));\n} else {\nreturn cljs.core.pr_writer_impl(obj,writer,opts);\n}\n});\ncljs.core.pr_seq_writer \x3d (function cljs$core$pr_seq_writer(objs,writer,opts){\ncljs.core.pr_writer(cljs.core.first(objs),writer,opts);\n\nvar seq__19513 \x3d cljs.core.seq(cljs.core.next(objs));\nvar chunk__19514 \x3d null;\nvar count__19515 \x3d (0);\nvar i__19516 \x3d (0);\nwhile(true){\nif((i__19516 \x3c count__19515)){\nvar obj \x3d chunk__19514.cljs$core$IIndexed$_nth$arity$2(null, i__19516);\ncljs.core._write(writer,\x22 \x22);\n\ncljs.core.pr_writer(obj,writer,opts);\n\n\nvar G__26706 \x3d seq__19513;\nvar G__26707 \x3d chunk__19514;\nvar G__26708 \x3d count__19515;\nvar G__26709 \x3d (i__19516 + (1));\nseq__19513 \x3d G__26706;\nchunk__19514 \x3d G__26707;\ncount__19515 \x3d G__26708;\ni__19516 \x3d G__26709;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__19513);\nif(temp__5804__auto__){\nvar seq__19513__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__19513__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__19513__$1);\nvar G__26710 \x3d cljs.core.chunk_rest(seq__19513__$1);\nvar G__26711 \x3d c__5525__auto__;\nvar G__26712 \x3d cljs.core.count(c__5525__auto__);\nvar G__26713 \x3d (0);\nseq__19513 \x3d G__26710;\nchunk__19514 \x3d G__26711;\ncount__19515 \x3d G__26712;\ni__19516 \x3d G__26713;\ncontinue;\n} else {\nvar obj \x3d cljs.core.first(seq__19513__$1);\ncljs.core._write(writer,\x22 \x22);\n\ncljs.core.pr_writer(obj,writer,opts);\n\n\nvar G__26714 \x3d cljs.core.next(seq__19513__$1);\nvar G__26715 \x3d null;\nvar G__26716 \x3d (0);\nvar G__26717 \x3d (0);\nseq__19513 \x3d G__26714;\nchunk__19514 \x3d G__26715;\ncount__19515 \x3d G__26716;\ni__19516 \x3d G__26717;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\ncljs.core.pr_sb_with_opts \x3d (function cljs$core$pr_sb_with_opts(objs,opts){\nvar sb \x3d (new goog.string.StringBuffer());\nvar writer \x3d (new cljs.core.StringBufferWriter(sb));\ncljs.core.pr_seq_writer(objs,writer,opts);\n\nwriter.cljs$core$IWriter$_flush$arity$1(null, );\n\nreturn sb;\n});\n/**\n * Prints a sequence of objects to a string, observing all the\n *   options given in opts\n */\ncljs.core.pr_str_with_opts \x3d (function cljs$core$pr_str_with_opts(objs,opts){\nif(cljs.core.empty_QMARK_(objs)){\nreturn \x22\x22;\n} else {\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_sb_with_opts(objs,opts));\n}\n});\n/**\n * Same as pr-str-with-opts followed by (newline)\n */\ncljs.core.prn_str_with_opts \x3d (function cljs$core$prn_str_with_opts(objs,opts){\nif(cljs.core.empty_QMARK_(objs)){\nreturn \x22\\n\x22;\n} else {\nvar sb \x3d cljs.core.pr_sb_with_opts(objs,opts);\nsb.append(\x22\\n\x22);\n\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb);\n}\n});\n/**\n * Prints a sequence of objects using string-print, observing all\n *   the options given in opts\n */\ncljs.core.pr_with_opts \x3d (function cljs$core$pr_with_opts(objs,opts){\nreturn cljs.core.string_print(cljs.core.pr_str_with_opts(objs,opts));\n});\n/**\n * Prints a newline using *print-fn*\n */\ncljs.core.newline \x3d (function cljs$core$newline(var_args){\nvar G__19518 \x3d arguments.length;\nswitch (G__19518) {\ncase 0:\nreturn cljs.core.newline.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.newline.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.newline.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.newline.cljs$core$IFn$_invoke$arity$1(null);\n}));\n\n(cljs.core.newline.cljs$core$IFn$_invoke$arity$1 \x3d (function (opts){\ncljs.core.string_print(\x22\\n\x22);\n\nif(cljs.core.truth_(cljs.core.get.cljs$core$IFn$_invoke$arity$2(opts,new cljs.core.Keyword(null,\x22flush-on-newline\x22,\x22flush-on-newline\x22,-151457939)))){\nreturn cljs.core.flush();\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.newline.cljs$lang$maxFixedArity \x3d 1);\n\n/**\n * pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter.\n */\ncljs.core.pr_str \x3d (function cljs$core$pr_str(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26731 \x3d arguments.length;\nvar i__5727__auto___26732 \x3d (0);\nwhile(true){\nif((i__5727__auto___26732 \x3c len__5726__auto___26731)){\nargs__5732__auto__.push((arguments[i__5727__auto___26732]));\n\nvar G__26733 \x3d (i__5727__auto___26732 + (1));\ni__5727__auto___26732 \x3d G__26733;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic \x3d (function (objs){\nreturn cljs.core.pr_str_with_opts(objs,cljs.core.pr_opts());\n}));\n\n(cljs.core.pr_str.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.pr_str.cljs$lang$applyTo \x3d (function (seq19519){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19519));\n}));\n\n/**\n * Same as pr-str followed by (newline)\n */\ncljs.core.prn_str \x3d (function cljs$core$prn_str(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26738 \x3d arguments.length;\nvar i__5727__auto___26739 \x3d (0);\nwhile(true){\nif((i__5727__auto___26739 \x3c len__5726__auto___26738)){\nargs__5732__auto__.push((arguments[i__5727__auto___26739]));\n\nvar G__26740 \x3d (i__5727__auto___26739 + (1));\ni__5727__auto___26739 \x3d G__26740;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.prn_str.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.prn_str.cljs$core$IFn$_invoke$arity$variadic \x3d (function (objs){\nreturn cljs.core.prn_str_with_opts(objs,cljs.core.pr_opts());\n}));\n\n(cljs.core.prn_str.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.prn_str.cljs$lang$applyTo \x3d (function (seq19520){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19520));\n}));\n\n/**\n * Prints the object(s) using string-print.  Prints the\n *   object(s), separated by spaces if there is more than one.\n *   By default, pr and prn print in a way that objects can be\n *   read by the reader\n */\ncljs.core.pr \x3d (function cljs$core$pr(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26745 \x3d arguments.length;\nvar i__5727__auto___26746 \x3d (0);\nwhile(true){\nif((i__5727__auto___26746 \x3c len__5726__auto___26745)){\nargs__5732__auto__.push((arguments[i__5727__auto___26746]));\n\nvar G__26747 \x3d (i__5727__auto___26746 + (1));\ni__5727__auto___26746 \x3d G__26747;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.pr.cljs$core$IFn$_invoke$arity$variadic \x3d (function (objs){\nreturn cljs.core.pr_with_opts(objs,cljs.core.pr_opts());\n}));\n\n(cljs.core.pr.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.pr.cljs$lang$applyTo \x3d (function (seq19521){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19521));\n}));\n\n/**\n * Prints the object(s) using string-print.\n *   print and println produce output for human consumption.\n * @param {...*} var_args\n */\ncljs.core.print \x3d (function() { \nvar cljs$core$cljs_core_print__delegate \x3d function (objs){\nreturn cljs.core.pr_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),new cljs.core.Keyword(null,\x22readably\x22,\x22readably\x22,1129599760),false));\n};\nvar cljs$core$cljs_core_print \x3d function (var_args){\nvar objs \x3d null;\nif (arguments.length \x3e 0) {\nvar G__26750__i \x3d 0, G__26750__a \x3d new Array(arguments.length -  0);\nwhile (G__26750__i \x3c G__26750__a.length) {G__26750__a[G__26750__i] \x3d arguments[G__26750__i + 0]; ++G__26750__i;}\n  objs \x3d new cljs.core.IndexedSeq(G__26750__a,0,null);\n} \nreturn cljs$core$cljs_core_print__delegate.call(this,objs);};\ncljs$core$cljs_core_print.cljs$lang$maxFixedArity \x3d 0;\ncljs$core$cljs_core_print.cljs$lang$applyTo \x3d (function (arglist__26751){\nvar objs \x3d cljs.core.seq(arglist__26751);\nreturn cljs$core$cljs_core_print__delegate(objs);\n});\ncljs$core$cljs_core_print.cljs$core$IFn$_invoke$arity$variadic \x3d cljs$core$cljs_core_print__delegate;\nreturn cljs$core$cljs_core_print;\n})()\n;\n/**\n * print to a string, returning it\n */\ncljs.core.print_str \x3d (function cljs$core$print_str(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26752 \x3d arguments.length;\nvar i__5727__auto___26753 \x3d (0);\nwhile(true){\nif((i__5727__auto___26753 \x3c len__5726__auto___26752)){\nargs__5732__auto__.push((arguments[i__5727__auto___26753]));\n\nvar G__26754 \x3d (i__5727__auto___26753 + (1));\ni__5727__auto___26753 \x3d G__26754;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.print_str.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.print_str.cljs$core$IFn$_invoke$arity$variadic \x3d (function (objs){\nreturn cljs.core.pr_str_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),new cljs.core.Keyword(null,\x22readably\x22,\x22readably\x22,1129599760),false));\n}));\n\n(cljs.core.print_str.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.print_str.cljs$lang$applyTo \x3d (function (seq19522){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19522));\n}));\n\n/**\n * Same as print followed by (newline)\n */\ncljs.core.println \x3d (function cljs$core$println(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26762 \x3d arguments.length;\nvar i__5727__auto___26763 \x3d (0);\nwhile(true){\nif((i__5727__auto___26763 \x3c len__5726__auto___26762)){\nargs__5732__auto__.push((arguments[i__5727__auto___26763]));\n\nvar G__26764 \x3d (i__5727__auto___26763 + (1));\ni__5727__auto___26763 \x3d G__26764;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.println.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.println.cljs$core$IFn$_invoke$arity$variadic \x3d (function (objs){\ncljs.core.pr_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),new cljs.core.Keyword(null,\x22readably\x22,\x22readably\x22,1129599760),false));\n\nif(cljs.core.truth_(cljs.core._STAR_print_newline_STAR_)){\nreturn cljs.core.newline.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_opts());\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.println.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.println.cljs$lang$applyTo \x3d (function (seq19523){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19523));\n}));\n\n/**\n * println to a string, returning it\n */\ncljs.core.println_str \x3d (function cljs$core$println_str(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26775 \x3d arguments.length;\nvar i__5727__auto___26776 \x3d (0);\nwhile(true){\nif((i__5727__auto___26776 \x3c len__5726__auto___26775)){\nargs__5732__auto__.push((arguments[i__5727__auto___26776]));\n\nvar G__26777 \x3d (i__5727__auto___26776 + (1));\ni__5727__auto___26776 \x3d G__26777;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.println_str.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.println_str.cljs$core$IFn$_invoke$arity$variadic \x3d (function (objs){\nreturn cljs.core.prn_str_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),new cljs.core.Keyword(null,\x22readably\x22,\x22readably\x22,1129599760),false));\n}));\n\n(cljs.core.println_str.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.println_str.cljs$lang$applyTo \x3d (function (seq19524){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19524));\n}));\n\n/**\n * Same as pr followed by (newline).\n */\ncljs.core.prn \x3d (function cljs$core$prn(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26782 \x3d arguments.length;\nvar i__5727__auto___26783 \x3d (0);\nwhile(true){\nif((i__5727__auto___26783 \x3c len__5726__auto___26782)){\nargs__5732__auto__.push((arguments[i__5727__auto___26783]));\n\nvar G__26784 \x3d (i__5727__auto___26783 + (1));\ni__5727__auto___26783 \x3d G__26784;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.prn.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.prn.cljs$core$IFn$_invoke$arity$variadic \x3d (function (objs){\ncljs.core.pr_with_opts(objs,cljs.core.pr_opts());\n\nif(cljs.core.truth_(cljs.core._STAR_print_newline_STAR_)){\nreturn cljs.core.newline.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_opts());\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.prn.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.prn.cljs$lang$applyTo \x3d (function (seq19525){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19525));\n}));\n\ncljs.core.strip_ns \x3d (function cljs$core$strip_ns(named){\nif((named instanceof cljs.core.Symbol)){\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(null,cljs.core.name(named));\n} else {\nreturn cljs.core.keyword.cljs$core$IFn$_invoke$arity$2(null,cljs.core.name(named));\n}\n});\n/**\n * Returns [lifted-ns lifted-map] or nil if m can\x27t be lifted.\n */\ncljs.core.lift_ns \x3d (function cljs$core$lift_ns(m){\nif(cljs.core.truth_(cljs.core._STAR_print_namespace_maps_STAR_)){\nvar ns \x3d null;\nvar G__19532 \x3d cljs.core.seq(m);\nvar vec__19533 \x3d G__19532;\nvar seq__19534 \x3d cljs.core.seq(vec__19533);\nvar first__19535 \x3d cljs.core.first(seq__19534);\nvar seq__19534__$1 \x3d cljs.core.next(seq__19534);\nvar vec__19536 \x3d first__19535;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19536,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19536,(1),null);\nvar entry \x3d vec__19536;\nvar entries \x3d seq__19534__$1;\nvar lm \x3d cljs.core.empty(m);\nvar ns__$1 \x3d ns;\nvar G__19532__$1 \x3d G__19532;\nvar lm__$1 \x3d lm;\nwhile(true){\nvar ns__$2 \x3d ns__$1;\nvar vec__19545 \x3d G__19532__$1;\nvar seq__19546 \x3d cljs.core.seq(vec__19545);\nvar first__19547 \x3d cljs.core.first(seq__19546);\nvar seq__19546__$1 \x3d cljs.core.next(seq__19546);\nvar vec__19548 \x3d first__19547;\nvar k__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19548,(0),null);\nvar v__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19548,(1),null);\nvar entry__$1 \x3d vec__19548;\nvar entries__$1 \x3d seq__19546__$1;\nvar lm__$2 \x3d lm__$1;\nif(cljs.core.truth_(entry__$1)){\nif((((k__$1 instanceof cljs.core.Keyword)) || ((k__$1 instanceof cljs.core.Symbol)))){\nif(cljs.core.truth_(ns__$2)){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ns__$2,cljs.core.namespace(k__$1))){\nvar G__26792 \x3d ns__$2;\nvar G__26793 \x3d entries__$1;\nvar G__26794 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(lm__$2,cljs.core.strip_ns(k__$1),v__$1);\nns__$1 \x3d G__26792;\nG__19532__$1 \x3d G__26793;\nlm__$1 \x3d G__26794;\ncontinue;\n} else {\nreturn null;\n}\n} else {\nvar temp__5804__auto__ \x3d cljs.core.namespace(k__$1);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar new_ns \x3d temp__5804__auto__;\nvar G__26800 \x3d new_ns;\nvar G__26801 \x3d entries__$1;\nvar G__26802 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(lm__$2,cljs.core.strip_ns(k__$1),v__$1);\nns__$1 \x3d G__26800;\nG__19532__$1 \x3d G__26801;\nlm__$1 \x3d G__26802;\ncontinue;\n} else {\nreturn null;\n}\n}\n} else {\nreturn null;\n}\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [ns__$2,lm__$2], null);\n}\nbreak;\n}\n} else {\nreturn null;\n}\n});\ncljs.core.print_prefix_map \x3d (function cljs$core$print_prefix_map(prefix,m,print_one,writer,opts){\nreturn cljs.core.pr_sequential_writer(writer,(function (e,w,opts__$1){\nvar G__19551_26807 \x3d cljs.core.key(e);\nvar G__19552_26808 \x3d w;\nvar G__19553_26809 \x3d opts__$1;\n(print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__19551_26807,G__19552_26808,G__19553_26809) : print_one.call(null, G__19551_26807,G__19552_26808,G__19553_26809));\n\ncljs.core._write(w,\x22 \x22);\n\nvar G__19554 \x3d cljs.core.val(e);\nvar G__19555 \x3d w;\nvar G__19556 \x3d opts__$1;\nreturn (print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__19554,G__19555,G__19556) : print_one.call(null, G__19554,G__19555,G__19556));\n}),[cljs.core.str.cljs$core$IFn$_invoke$arity$1(prefix),\x22{\x22].join(\x27\x27),\x22, \x22,\x22}\x22,opts,cljs.core.seq(m));\n});\ncljs.core.print_map \x3d (function cljs$core$print_map(m,print_one,writer,opts){\nvar vec__19557 \x3d ((cljs.core.map_QMARK_(m))?cljs.core.lift_ns(m):null);\nvar ns \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19557,(0),null);\nvar lift_map \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19557,(1),null);\nif(cljs.core.truth_(ns)){\nreturn cljs.core.print_prefix_map([\x22#:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns)].join(\x27\x27),lift_map,print_one,writer,opts);\n} else {\nreturn cljs.core.print_prefix_map(null,m,print_one,writer,opts);\n}\n});\n(cljs.core.Volatile.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Volatile.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (a,writer,opts){\nvar a__$1 \x3d this;\ncljs.core._write(writer,\x22#object[cljs.core.Volatile \x22);\n\ncljs.core.pr_writer(new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),a__$1.state], null),writer,opts);\n\nreturn cljs.core._write(writer,\x22]\x22);\n}));\n\n(cljs.core.Var.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Var.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (a,writer,opts){\nvar a__$1 \x3d this;\ncljs.core._write(writer,\x22#\x27\x22);\n\nreturn cljs.core.pr_writer(a__$1.sym,writer,opts);\n}));\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.MapEntry.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22[\x22,\x22 \x22,\x22]\x22,opts,coll__$1);\n}));\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.BlackNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22[\x22,\x22 \x22,\x22]\x22,opts,coll__$1);\n}));\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.ES6IteratorSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ES6IteratorSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22#{\x22,\x22 \x22,\x22}\x22,opts,coll__$1);\n}));\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts);\n}));\n\n(cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.Iterate.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Iterate.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.IntegerRange.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.IntegerRange.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts);\n}));\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22[\x22,\x22 \x22,\x22]\x22,opts,coll__$1);\n}));\n\n(cljs.core.Cycle.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Cycle.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts);\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22#{\x22,\x22 \x22,\x22}\x22,opts,coll__$1);\n}));\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.Atom.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Atom.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (a,writer,opts){\nvar a__$1 \x3d this;\ncljs.core._write(writer,\x22#object[cljs.core.Atom \x22);\n\ncljs.core.pr_writer(new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),a__$1.state], null),writer,opts);\n\nreturn cljs.core._write(writer,\x22]\x22);\n}));\n\n(cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22[\x22,\x22 \x22,\x22]\x22,opts,coll__$1);\n}));\n\n(cljs.core.Repeat.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Repeat.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22[\x22,\x22 \x22,\x22]\x22,opts,coll__$1);\n}));\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentQueueSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core._write(writer,\x22()\x22);\n}));\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22#queue [\x22,\x22 \x22,\x22]\x22,opts,cljs.core.seq(coll__$1));\n}));\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts);\n}));\n\n(cljs.core.Range.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Range.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.TransformerIterator.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.TransformerIterator.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n\n(cljs.core.List.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.List.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$1);\n}));\n(cljs.core.Symbol.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Symbol.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (x,y){\nvar x__$1 \x3d this;\nif((y instanceof cljs.core.Symbol)){\nreturn cljs.core.compare_symbols(x__$1,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n}));\n\n(cljs.core.Keyword.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Keyword.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (x,y){\nvar x__$1 \x3d this;\nif((y instanceof cljs.core.Keyword)){\nreturn cljs.core.compare_keywords(x__$1,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n}));\n\n(cljs.core.Subvec.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Subvec.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (x,y){\nvar x__$1 \x3d this;\nif(cljs.core.vector_QMARK_(y)){\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n}));\n\n(cljs.core.PersistentVector.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentVector.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (x,y){\nvar x__$1 \x3d this;\nif(cljs.core.vector_QMARK_(y)){\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n}));\n\n(cljs.core.MapEntry.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.MapEntry.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (x,y){\nvar x__$1 \x3d this;\nif(cljs.core.vector_QMARK_(y)){\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n}));\n\n(cljs.core.BlackNode.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.BlackNode.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (x,y){\nvar x__$1 \x3d this;\nif(cljs.core.vector_QMARK_(y)){\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n}));\n\n(cljs.core.RedNode.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.RedNode.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (x,y){\nvar x__$1 \x3d this;\nif(cljs.core.vector_QMARK_(y)){\nreturn cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27)));\n}\n}));\n/**\n * Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n * \n *   (apply f its-current-meta args)\n * \n *   f must be free of side-effects\n */\ncljs.core.alter_meta_BANG_ \x3d (function cljs$core$alter_meta_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26935 \x3d arguments.length;\nvar i__5727__auto___26936 \x3d (0);\nwhile(true){\nif((i__5727__auto___26936 \x3c len__5726__auto___26935)){\nargs__5732__auto__.push((arguments[i__5727__auto___26936]));\n\nvar G__26937 \x3d (i__5727__auto___26936 + (1));\ni__5727__auto___26936 \x3d G__26937;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn cljs.core.alter_meta_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(cljs.core.alter_meta_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (iref,f,args){\nreturn (iref.meta \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,iref.meta,args));\n}));\n\n(cljs.core.alter_meta_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(cljs.core.alter_meta_BANG_.cljs$lang$applyTo \x3d (function (seq19560){\nvar G__19561 \x3d cljs.core.first(seq19560);\nvar seq19560__$1 \x3d cljs.core.next(seq19560);\nvar G__19562 \x3d cljs.core.first(seq19560__$1);\nvar seq19560__$2 \x3d cljs.core.next(seq19560__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19561,G__19562,seq19560__$2);\n}));\n\n/**\n * Atomically resets the metadata for an atom\n */\ncljs.core.reset_meta_BANG_ \x3d (function cljs$core$reset_meta_BANG_(iref,m){\nreturn (iref.meta \x3d m);\n});\n/**\n * Adds a watch function to an atom reference. The watch fn must be a\n *   fn of 4 args: a key, the reference, its old-state, its\n *   new-state. Whenever the reference\x27s state might have been changed,\n *   any registered watches will have their functions called. The watch\n *   fn will be called synchronously. Note that an atom\x27s state\n *   may have changed again prior to the fn call, so use old/new-state\n *   rather than derefing the reference. Keys must be unique per\n *   reference, and can be used to remove the watch with remove-watch,\n *   but are otherwise considered opaque by the watch mechanism.  Bear in\n *   mind that regardless of the result or action of the watch fns the\n *   atom\x27s value will change.  Example:\n * \n *    (def a (atom 0))\n *    (add-watch a :inc (fn [k r o n] (assert (\x3d\x3d 0 n))))\n *    (swap! a inc)\n *    ;; Assertion Error\n *    (deref a)\n *    ;\x3d\x3e 1\n */\ncljs.core.add_watch \x3d (function cljs$core$add_watch(iref,key,f){\ncljs.core._add_watch(iref,key,f);\n\nreturn iref;\n});\n/**\n * Removes a watch (set by add-watch) from a reference\n */\ncljs.core.remove_watch \x3d (function cljs$core$remove_watch(iref,key){\ncljs.core._remove_watch(iref,key);\n\nreturn iref;\n});\n/**\n * @type {*}\n */\ncljs.core.gensym_counter \x3d null;\n/**\n * Returns a new symbol with a unique name. If a prefix string is\n *   supplied, the name is prefix# where # is some unique number. If\n *   prefix is not supplied, the prefix is \x27G__\x27.\n */\ncljs.core.gensym \x3d (function cljs$core$gensym(var_args){\nvar G__19564 \x3d arguments.length;\nswitch (G__19564) {\ncase 0:\nreturn cljs.core.gensym.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.gensym.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.gensym.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.gensym.cljs$core$IFn$_invoke$arity$1(\x22G__\x22);\n}));\n\n(cljs.core.gensym.cljs$core$IFn$_invoke$arity$1 \x3d (function (prefix_string){\nif((cljs.core.gensym_counter \x3d\x3d null)){\n(cljs.core.gensym_counter \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0)));\n} else {\n}\n\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1(prefix_string),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(cljs.core.gensym_counter,cljs.core.inc))].join(\x27\x27));\n}));\n\n(cljs.core.gensym.cljs$lang$maxFixedArity \x3d 1);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IPending}\n * @implements {cljs.core.IDeref}\n * @implements {cljs.core.IPrintWithWriter}\n*/\ncljs.core.Delay \x3d (function (f,value){\nthis.f \x3d f;\nthis.value \x3d value;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2147516416;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 1;\n});\n(cljs.core.Delay.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.f)){\n(self__.value \x3d (self__.f.cljs$core$IFn$_invoke$arity$0 ? self__.f.cljs$core$IFn$_invoke$arity$0() : self__.f.call(null, )));\n\n(self__.f \x3d null);\n} else {\n}\n\nreturn self__.value;\n}));\n\n(cljs.core.Delay.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 \x3d (function (x){\nvar self__ \x3d this;\nvar x__$1 \x3d this;\nreturn cljs.core.not(self__.f);\n}));\n\n(cljs.core.Delay.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (x,writer,opts){\nvar self__ \x3d this;\nvar x__$1 \x3d this;\ncljs.core._write(writer,\x22#object[cljs.core.Delay \x22);\n\ncljs.core.pr_writer(new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22status\x22,\x22status\x22,-1997798413),(((self__.f \x3d\x3d null))?new cljs.core.Keyword(null,\x22ready\x22,\x22ready\x22,1086465795):new cljs.core.Keyword(null,\x22pending\x22,\x22pending\x22,-220036727)),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),self__.value], null),writer,opts);\n\nreturn cljs.core._write(writer,\x22]\x22);\n}));\n\n(cljs.core.Delay.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22value\x22,\x22value\x22,1946509744,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.Delay.cljs$lang$type \x3d true);\n\n(cljs.core.Delay.cljs$lang$ctorStr \x3d \x22cljs.core/Delay\x22);\n\n(cljs.core.Delay.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Delay\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Delay.\n */\ncljs.core.__GT_Delay \x3d (function cljs$core$__GT_Delay(f,value){\nreturn (new cljs.core.Delay(f,value));\n});\n\n/**\n * returns true if x is a Delay created with delay\n */\ncljs.core.delay_QMARK_ \x3d (function cljs$core$delay_QMARK_(x){\nreturn (x instanceof cljs.core.Delay);\n});\n/**\n * If x is a Delay, returns the (possibly cached) value of its expression, else returns x\n */\ncljs.core.force \x3d (function cljs$core$force(x){\nif(cljs.core.delay_QMARK_(x)){\nreturn cljs.core.deref(x);\n} else {\nreturn x;\n}\n});\n/**\n * Returns true if a value has been produced for a delay or lazy sequence.\n */\ncljs.core.realized_QMARK_ \x3d (function cljs$core$realized_QMARK_(x){\nreturn cljs.core._realized_QMARK_(x);\n});\ncljs.core.preserving_reduced \x3d (function cljs$core$preserving_reduced(rf){\nreturn (function (p1__19565_SHARP_,p2__19566_SHARP_){\nvar ret \x3d (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(p1__19565_SHARP_,p2__19566_SHARP_) : rf.call(null, p1__19565_SHARP_,p2__19566_SHARP_));\nif(cljs.core.reduced_QMARK_(ret)){\nreturn cljs.core.reduced(ret);\n} else {\nreturn ret;\n}\n});\n});\n/**\n * A transducer which concatenates the contents of each input, which must be a\n *   collection, into the reduction.\n */\ncljs.core.cat \x3d (function cljs$core$cat(rf){\nvar rf1 \x3d cljs.core.preserving_reduced(rf);\nreturn (function() {\nvar G__26976 \x3d null;\nvar G__26976__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26976__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__26976__2 \x3d (function (result,input){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(rf1,result,input);\n});\nG__26976 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26976__0.call(this);\ncase 1:\nreturn G__26976__1.call(this,result);\ncase 2:\nreturn G__26976__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26976.cljs$core$IFn$_invoke$arity$0 \x3d G__26976__0;\nG__26976.cljs$core$IFn$_invoke$arity$1 \x3d G__26976__1;\nG__26976.cljs$core$IFn$_invoke$arity$2 \x3d G__26976__2;\nreturn G__26976;\n})()\n});\n/**\n * Returns a transducer that ends transduction when pred returns true\n *   for an input. When retf is supplied it must be a fn of 2 arguments -\n *   it will be passed the (completed) result so far and the input that\n *   triggered the predicate, and its return value (if it does not throw\n *   an exception) will be the return value of the transducer. If retf\n *   is not supplied, the input that triggered the predicate will be\n *   returned. If the predicate never returns true the transduction is\n *   unaffected.\n */\ncljs.core.halt_when \x3d (function cljs$core$halt_when(var_args){\nvar G__19568 \x3d arguments.length;\nswitch (G__19568) {\ncase 1:\nreturn cljs.core.halt_when.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.halt_when.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.halt_when.cljs$core$IFn$_invoke$arity$1 \x3d (function (pred){\nreturn cljs.core.halt_when.cljs$core$IFn$_invoke$arity$2(pred,null);\n}));\n\n(cljs.core.halt_when.cljs$core$IFn$_invoke$arity$2 \x3d (function (pred,retf){\nreturn (function (rf){\nreturn (function() {\nvar G__26983 \x3d null;\nvar G__26983__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26983__1 \x3d (function (result){\nif(((cljs.core.map_QMARK_(result)) \x26\x26 (cljs.core.contains_QMARK_(result,new cljs.core.Keyword(\x22cljs.core\x22,\x22halt\x22,\x22cljs.core/halt\x22,-1049036715))))){\nreturn new cljs.core.Keyword(\x22cljs.core\x22,\x22halt\x22,\x22cljs.core/halt\x22,-1049036715).cljs$core$IFn$_invoke$arity$1(result);\n} else {\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n}\n});\nvar G__26983__2 \x3d (function (result,input){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null, input)))){\nreturn cljs.core.reduced(new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(\x22cljs.core\x22,\x22halt\x22,\x22cljs.core/halt\x22,-1049036715),(cljs.core.truth_(retf)?(function (){var G__19569 \x3d (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\nvar G__19570 \x3d input;\nreturn (retf.cljs$core$IFn$_invoke$arity$2 ? retf.cljs$core$IFn$_invoke$arity$2(G__19569,G__19570) : retf.call(null, G__19569,G__19570));\n})():input)], null));\n} else {\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n}\n});\nG__26983 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26983__0.call(this);\ncase 1:\nreturn G__26983__1.call(this,result);\ncase 2:\nreturn G__26983__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26983.cljs$core$IFn$_invoke$arity$0 \x3d G__26983__0;\nG__26983.cljs$core$IFn$_invoke$arity$1 \x3d G__26983__1;\nG__26983.cljs$core$IFn$_invoke$arity$2 \x3d G__26983__2;\nreturn G__26983;\n})()\n});\n}));\n\n(cljs.core.halt_when.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a lazy sequence removing consecutive duplicates in coll.\n *   Returns a transducer when no collection is provided.\n */\ncljs.core.dedupe \x3d (function cljs$core$dedupe(var_args){\nvar G__19572 \x3d arguments.length;\nswitch (G__19572) {\ncase 0:\nreturn cljs.core.dedupe.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.dedupe.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.dedupe.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn (function (rf){\nvar pa \x3d cljs.core.volatile_BANG_(new cljs.core.Keyword(\x22cljs.core\x22,\x22none\x22,\x22cljs.core/none\x22,926646439));\nreturn (function() {\nvar G__26993 \x3d null;\nvar G__26993__0 \x3d (function (){\nreturn (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));\n});\nvar G__26993__1 \x3d (function (result){\nreturn (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));\n});\nvar G__26993__2 \x3d (function (result,input){\nvar prior \x3d cljs.core.deref(pa);\ncljs.core.vreset_BANG_(pa,input);\n\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(prior,input)){\nreturn result;\n} else {\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null, result,input));\n}\n});\nG__26993 \x3d function(result,input){\nswitch(arguments.length){\ncase 0:\nreturn G__26993__0.call(this);\ncase 1:\nreturn G__26993__1.call(this,result);\ncase 2:\nreturn G__26993__2.call(this,result,input);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26993.cljs$core$IFn$_invoke$arity$0 \x3d G__26993__0;\nG__26993.cljs$core$IFn$_invoke$arity$1 \x3d G__26993__1;\nG__26993.cljs$core$IFn$_invoke$arity$2 \x3d G__26993__2;\nreturn G__26993;\n})()\n});\n}));\n\n(cljs.core.dedupe.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$2(cljs.core.dedupe.cljs$core$IFn$_invoke$arity$0(),coll);\n}));\n\n(cljs.core.dedupe.cljs$lang$maxFixedArity \x3d 1);\n\n/**\n * Returns items from coll with random probability of prob (0.0 -\n *   1.0).  Returns a transducer when no collection is provided.\n */\ncljs.core.random_sample \x3d (function cljs$core$random_sample(var_args){\nvar G__19574 \x3d arguments.length;\nswitch (G__19574) {\ncase 1:\nreturn cljs.core.random_sample.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.random_sample.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.random_sample.cljs$core$IFn$_invoke$arity$1 \x3d (function (prob){\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$1((function (_){\nreturn ((cljs.core.rand.cljs$core$IFn$_invoke$arity$0 ? cljs.core.rand.cljs$core$IFn$_invoke$arity$0() : cljs.core.rand.call(null, )) \x3c prob);\n}));\n}));\n\n(cljs.core.random_sample.cljs$core$IFn$_invoke$arity$2 \x3d (function (prob,coll){\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (_){\nreturn ((cljs.core.rand.cljs$core$IFn$_invoke$arity$0 ? cljs.core.rand.cljs$core$IFn$_invoke$arity$0() : cljs.core.rand.call(null, )) \x3c prob);\n}),coll);\n}));\n\n(cljs.core.random_sample.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n* @constructor\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.ISequential}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.Eduction \x3d (function (xform,coll){\nthis.xform \x3d xform;\nthis.coll \x3d coll;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2173173760;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 131072;\n});\n(cljs.core.Eduction.prototype.indexOf \x3d (function() {\nvar G__27003 \x3d null;\nvar G__27003__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,(0));\n});\nvar G__27003__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,start);\n});\nG__27003 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__27003__1.call(this,x);\ncase 2:\nreturn G__27003__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__27003.cljs$core$IFn$_invoke$arity$1 \x3d G__27003__1;\nG__27003.cljs$core$IFn$_invoke$arity$2 \x3d G__27003__2;\nreturn G__27003;\n})()\n);\n\n(cljs.core.Eduction.prototype.lastIndexOf \x3d (function() {\nvar G__27004 \x3d null;\nvar G__27004__1 \x3d (function (x){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,cljs.core.count(coll__$1));\n});\nvar G__27004__2 \x3d (function (x,start){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,start);\n});\nG__27004 \x3d function(x,start){\nswitch(arguments.length){\ncase 1:\nreturn G__27004__1.call(this,x);\ncase 2:\nreturn G__27004__2.call(this,x,start);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__27004.cljs$core$IFn$_invoke$arity$1 \x3d G__27004__1;\nG__27004.cljs$core$IFn$_invoke$arity$2 \x3d G__27004__2;\nreturn G__27004;\n})()\n);\n\n(cljs.core.Eduction.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.TransformerIterator.create(self__.xform,cljs.core.iter(self__.coll));\n}));\n\n(cljs.core.Eduction.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.seq(cljs.core.sequence.cljs$core$IFn$_invoke$arity$2(self__.xform,self__.coll));\n}));\n\n(cljs.core.Eduction.prototype.cljs$core$IReduce$_reduce$arity$2 \x3d (function (_,f){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.transduce.cljs$core$IFn$_invoke$arity$3(self__.xform,cljs.core.completing.cljs$core$IFn$_invoke$arity$1(f),self__.coll);\n}));\n\n(cljs.core.Eduction.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (_,f,init){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(self__.xform,cljs.core.completing.cljs$core$IFn$_invoke$arity$1(f),init,self__.coll);\n}));\n\n(cljs.core.Eduction.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll__$1,writer,opts){\nvar self__ \x3d this;\nvar coll__$2 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22(\x22,\x22 \x22,\x22)\x22,opts,coll__$2);\n}));\n\n(cljs.core.Eduction.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22xform\x22,\x22xform\x22,-85179481,null),new cljs.core.Symbol(null,\x22coll\x22,\x22coll\x22,-1006698606,null)], null);\n}));\n\n(cljs.core.Eduction.cljs$lang$type \x3d true);\n\n(cljs.core.Eduction.cljs$lang$ctorStr \x3d \x22cljs.core/Eduction\x22);\n\n(cljs.core.Eduction.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Eduction\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Eduction.\n */\ncljs.core.__GT_Eduction \x3d (function cljs$core$__GT_Eduction(xform,coll){\nreturn (new cljs.core.Eduction(xform,coll));\n});\n\n(cljs.core.Eduction.prototype[cljs.core.ITER_SYMBOL] \x3d (function (){\nvar this__5655__auto__ \x3d this;\nreturn cljs.core.es6_iterator(this__5655__auto__);\n}));\n/**\n * Returns a reducible/iterable application of the transducers\n *   to the items in coll. Transducers are applied in order as if\n *   combined with comp. Note that these applications will be\n *   performed every time reduce/iterator is called.\n */\ncljs.core.eduction \x3d (function cljs$core$eduction(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27013 \x3d arguments.length;\nvar i__5727__auto___27014 \x3d (0);\nwhile(true){\nif((i__5727__auto___27014 \x3c len__5726__auto___27013)){\nargs__5732__auto__.push((arguments[i__5727__auto___27014]));\n\nvar G__27016 \x3d (i__5727__auto___27014 + (1));\ni__5727__auto___27014 \x3d G__27016;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.core.eduction.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.core.eduction.cljs$core$IFn$_invoke$arity$variadic \x3d (function (xforms){\nreturn (new cljs.core.Eduction(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.comp,cljs.core.butlast(xforms)),cljs.core.last(xforms)));\n}));\n\n(cljs.core.eduction.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.core.eduction.cljs$lang$applyTo \x3d (function (seq19575){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq19575));\n}));\n\n/**\n * Runs the supplied procedure (via reduce), for purposes of side\n *   effects, on successive items in the collection. Returns nil\n */\ncljs.core.run_BANG_ \x3d (function cljs$core$run_BANG_(proc,coll){\ncljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19577_SHARP_,p2__19576_SHARP_){\nreturn (proc.cljs$core$IFn$_invoke$arity$1 ? proc.cljs$core$IFn$_invoke$arity$1(p2__19576_SHARP_) : proc.call(null, p2__19576_SHARP_));\n}),null,coll);\n\nreturn null;\n});\n\n/**\n* @constructor\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IReduce}\n*/\ncljs.core.t_cljs$core19582 \x3d (function (step,p__19580,map__19581,somef,vf,kf,initk,meta19583){\nthis.step \x3d step;\nthis.p__19580 \x3d p__19580;\nthis.map__19581 \x3d map__19581;\nthis.somef \x3d somef;\nthis.vf \x3d vf;\nthis.kf \x3d kf;\nthis.initk \x3d initk;\nthis.meta19583 \x3d meta19583;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 9306112;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.t_cljs$core19582.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_19584,meta19583__$1){\nvar self__ \x3d this;\nvar _19584__$1 \x3d this;\nreturn (new cljs.core.t_cljs$core19582(self__.step,self__.p__19580,self__.map__19581,self__.somef,self__.vf,self__.kf,self__.initk,meta19583__$1));\n}));\n\n(cljs.core.t_cljs$core19582.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_19584){\nvar self__ \x3d this;\nvar _19584__$1 \x3d this;\nreturn self__.meta19583;\n}));\n\n(cljs.core.t_cljs$core19582.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (function cljs$core$next(ret){\nif(cljs.core.truth_((self__.somef.cljs$core$IFn$_invoke$arity$1 ? self__.somef.cljs$core$IFn$_invoke$arity$1(ret) : self__.somef.call(null, ret)))){\nreturn cljs.core.cons((self__.vf.cljs$core$IFn$_invoke$arity$1 ? self__.vf.cljs$core$IFn$_invoke$arity$1(ret) : self__.vf.call(null, ret)),(function (){var temp__5808__auto__ \x3d (self__.kf.cljs$core$IFn$_invoke$arity$1 ? self__.kf.cljs$core$IFn$_invoke$arity$1(ret) : self__.kf.call(null, ret));\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar k \x3d temp__5808__auto__;\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn cljs$core$next((self__.step.cljs$core$IFn$_invoke$arity$1 ? self__.step.cljs$core$IFn$_invoke$arity$1(k) : self__.step.call(null, k)));\n}),null,null));\n}\n})());\n} else {\nreturn null;\n}\n})((self__.step.cljs$core$IFn$_invoke$arity$1 ? self__.step.cljs$core$IFn$_invoke$arity$1(self__.initk) : self__.step.call(null, self__.initk)));\n}));\n\n(cljs.core.t_cljs$core19582.prototype.cljs$core$IReduce$_reduce$arity$3 \x3d (function (_,rf,init){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar acc \x3d init;\nvar ret \x3d (self__.step.cljs$core$IFn$_invoke$arity$1 ? self__.step.cljs$core$IFn$_invoke$arity$1(self__.initk) : self__.step.call(null, self__.initk));\nwhile(true){\nif(cljs.core.truth_((self__.somef.cljs$core$IFn$_invoke$arity$1 ? self__.somef.cljs$core$IFn$_invoke$arity$1(ret) : self__.somef.call(null, ret)))){\nvar acc__$1 \x3d (function (){var G__19585 \x3d acc;\nvar G__19586 \x3d (self__.vf.cljs$core$IFn$_invoke$arity$1 ? self__.vf.cljs$core$IFn$_invoke$arity$1(ret) : self__.vf.call(null, ret));\nreturn (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__19585,G__19586) : rf.call(null, G__19585,G__19586));\n})();\nif(cljs.core.reduced_QMARK_(acc__$1)){\nreturn cljs.core.deref(acc__$1);\n} else {\nvar temp__5806__auto__ \x3d (self__.kf.cljs$core$IFn$_invoke$arity$1 ? self__.kf.cljs$core$IFn$_invoke$arity$1(ret) : self__.kf.call(null, ret));\nif((temp__5806__auto__ \x3d\x3d null)){\nreturn acc__$1;\n} else {\nvar k \x3d temp__5806__auto__;\nvar G__27026 \x3d acc__$1;\nvar G__27027 \x3d (self__.step.cljs$core$IFn$_invoke$arity$1 ? self__.step.cljs$core$IFn$_invoke$arity$1(k) : self__.step.call(null, k));\nacc \x3d G__27026;\nret \x3d G__27027;\ncontinue;\n}\n}\n} else {\nreturn acc;\n}\nbreak;\n}\n}));\n\n(cljs.core.t_cljs$core19582.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 8, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22step\x22,\x22step\x22,-1365547645,null),new cljs.core.Symbol(null,\x22p__19580\x22,\x22p__19580\x22,1603498542,null),new cljs.core.Symbol(null,\x22map__19581\x22,\x22map__19581\x22,-773708124,null),new cljs.core.Symbol(null,\x22somef\x22,\x22somef\x22,1017941162,null),new cljs.core.Symbol(null,\x22vf\x22,\x22vf\x22,1319108258,null),new cljs.core.Symbol(null,\x22kf\x22,\x22kf\x22,-1046348180,null),new cljs.core.Symbol(null,\x22initk\x22,\x22initk\x22,-52811460,null),new cljs.core.Symbol(null,\x22meta19583\x22,\x22meta19583\x22,1264670984,null)], null);\n}));\n\n(cljs.core.t_cljs$core19582.cljs$lang$type \x3d true);\n\n(cljs.core.t_cljs$core19582.cljs$lang$ctorStr \x3d \x22cljs.core/t_cljs$core19582\x22);\n\n(cljs.core.t_cljs$core19582.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/t_cljs$core19582\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/t_cljs$core19582.\n */\ncljs.core.__GT_t_cljs$core19582 \x3d (function cljs$core$__GT_t_cljs$core19582(step,p__19580,map__19581,somef,vf,kf,initk,meta19583){\nreturn (new cljs.core.t_cljs$core19582(step,p__19580,map__19581,somef,vf,kf,initk,meta19583));\n});\n\n\n/**\n * Creates a seqable/reducible via repeated calls to step,\n *   a function of some (continuation token) \x27k\x27. The first call to step\n *   will be passed initk, returning \x27ret\x27. Iff (somef ret) is true,\n *   (vf ret) will be included in the iteration, else iteration will\n *   terminate and vf/kf will not be called. If (kf ret) is non-nil it\n *   will be passed to the next step call, else iteration will terminate.\n *   This can be used e.g. to consume APIs that return paginated or batched data.\n * step - (possibly impure) fn of \x27k\x27 -\x3e \x27ret\x27\n * :somef - fn of \x27ret\x27 -\x3e logical true/false, default \x27some?\x27\n * :vf - fn of \x27ret\x27 -\x3e \x27v\x27, a value produced by the iteration, default \x27identity\x27\n * :kf - fn of \x27ret\x27 -\x3e \x27next-k\x27 or nil (signaling \x27do not continue\x27), default \x27identity\x27\n * :initk - the first value passed to step, default \x27nil\x27\n *   It is presumed that step with non-initk is unreproducible/non-idempotent.\n *   If step with initk is unreproducible it is on the consumer to not consume twice.\n */\ncljs.core.iteration \x3d (function cljs$core$iteration(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27035 \x3d arguments.length;\nvar i__5727__auto___27036 \x3d (0);\nwhile(true){\nif((i__5727__auto___27036 \x3c len__5726__auto___27035)){\nargs__5732__auto__.push((arguments[i__5727__auto___27036]));\n\nvar G__27037 \x3d (i__5727__auto___27036 + (1));\ni__5727__auto___27036 \x3d G__27037;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.iteration.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.iteration.cljs$core$IFn$_invoke$arity$variadic \x3d (function (step,p__19580){\nvar map__19581 \x3d p__19580;\nvar map__19581__$1 \x3d cljs.core.__destructure_map(map__19581);\nvar somef \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__19581__$1,new cljs.core.Keyword(null,\x22somef\x22,\x22somef\x22,-622590365),cljs.core.some_QMARK_);\nvar vf \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__19581__$1,new cljs.core.Keyword(null,\x22vf\x22,\x22vf\x22,-321423269),cljs.core.identity);\nvar kf \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__19581__$1,new cljs.core.Keyword(null,\x22kf\x22,\x22kf\x22,1608087589),cljs.core.identity);\nvar initk \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__19581__$1,new cljs.core.Keyword(null,\x22initk\x22,\x22initk\x22,-1693342987),null);\nreturn (new cljs.core.t_cljs$core19582(step,p__19580,map__19581__$1,somef,vf,kf,initk,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(cljs.core.iteration.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.iteration.cljs$lang$applyTo \x3d (function (seq19578){\nvar G__19579 \x3d cljs.core.first(seq19578);\nvar seq19578__$1 \x3d cljs.core.next(seq19578);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19579,seq19578__$1);\n}));\n\n\n/**\n * @interface\n */\ncljs.core.IEncodeJS \x3d function(){};\n\nvar cljs$core$IEncodeJS$_clj__GT_js$dyn_27043 \x3d (function (x){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (cljs.core._clj__GT_js[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5351__auto__.call(null, x));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._clj__GT_js[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5349__auto__.call(null, x));\n} else {\nthrow cljs.core.missing_protocol(\x22IEncodeJS.-clj-\x3ejs\x22,x);\n}\n}\n});\n/**\n * Recursively transforms clj values to JavaScript\n */\ncljs.core._clj__GT_js \x3d (function cljs$core$_clj__GT_js(x){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.cljs$core$IEncodeJS$_clj__GT_js$arity$1 \x3d\x3d null)))))){\nreturn x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x);\n} else {\nreturn cljs$core$IEncodeJS$_clj__GT_js$dyn_27043(x);\n}\n});\n\nvar cljs$core$IEncodeJS$_key__GT_js$dyn_27046 \x3d (function (x){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (cljs.core._key__GT_js[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5351__auto__.call(null, x));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._key__GT_js[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5349__auto__.call(null, x));\n} else {\nthrow cljs.core.missing_protocol(\x22IEncodeJS.-key-\x3ejs\x22,x);\n}\n}\n});\n/**\n * Transforms map keys to valid JavaScript keys. Arbitrary keys are\n *   encoded to their string representation via (pr-str x)\n */\ncljs.core._key__GT_js \x3d (function cljs$core$_key__GT_js(x){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.cljs$core$IEncodeJS$_key__GT_js$arity$1 \x3d\x3d null)))))){\nreturn x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x);\n} else {\nreturn cljs$core$IEncodeJS$_key__GT_js$dyn_27046(x);\n}\n});\n\ncljs.core.key__GT_js \x3d (function cljs$core$key__GT_js(var_args){\nvar G__19588 \x3d arguments.length;\nswitch (G__19588) {\ncase 1:\nreturn cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$1 \x3d (function (k){\nreturn cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2(k,cljs.core.clj__GT_js);\n}));\n\n(cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2 \x3d (function (k,primitive_fn){\nif((((!((k \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d k.cljs$core$IEncodeJS$))))?true:(((!k.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,k):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,k))){\nreturn cljs.core._clj__GT_js(k);\n} else {\nif(((typeof k \x3d\x3d\x3d \x27string\x27) || (((typeof k \x3d\x3d\x3d \x27number\x27) || ((((k instanceof cljs.core.Keyword)) || ((k instanceof cljs.core.Symbol)))))))){\nreturn (primitive_fn.cljs$core$IFn$_invoke$arity$1 ? primitive_fn.cljs$core$IFn$_invoke$arity$1(k) : primitive_fn.call(null, k));\n} else {\nreturn cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([k], 0));\n\n}\n}\n}));\n\n(cljs.core.key__GT_js.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Recursively transforms ClojureScript values to JavaScript.\n *   sets/vectors/lists become Arrays, Keywords and Symbol become Strings,\n *   Maps become Objects. Arbitrary keys are encoded to by `key-\x3ejs`.\n *   Options is a key-value pair, where the only valid key is\n *   :keyword-fn, which should point to a single-argument function to be\n *   called on keyword keys. Default to `name`.\n */\ncljs.core.clj__GT_js \x3d (function cljs$core$clj__GT_js(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27056 \x3d arguments.length;\nvar i__5727__auto___27057 \x3d (0);\nwhile(true){\nif((i__5727__auto___27057 \x3c len__5726__auto___27056)){\nargs__5732__auto__.push((arguments[i__5727__auto___27057]));\n\nvar G__27058 \x3d (i__5727__auto___27057 + (1));\ni__5727__auto___27057 \x3d G__27058;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.clj__GT_js.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.clj__GT_js.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,p__19592){\nvar map__19593 \x3d p__19592;\nvar map__19593__$1 \x3d cljs.core.__destructure_map(map__19593);\nvar options \x3d map__19593__$1;\nvar keyword_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__19593__$1,new cljs.core.Keyword(null,\x22keyword-fn\x22,\x22keyword-fn\x22,-64566675),cljs.core.name);\nvar keyfn \x3d (function cljs$core$keyfn(k){\nreturn cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2(k,thisfn);\n});\nvar thisfn \x3d (function cljs$core$thisfn(x__$1){\nif((x__$1 \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((x__$1 \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x__$1.cljs$core$IEncodeJS$))))?true:(((!x__$1.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,x__$1):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,x__$1))){\nreturn cljs.core._clj__GT_js(x__$1);\n} else {\nif((x__$1 instanceof cljs.core.Keyword)){\nreturn (keyword_fn.cljs$core$IFn$_invoke$arity$1 ? keyword_fn.cljs$core$IFn$_invoke$arity$1(x__$1) : keyword_fn.call(null, x__$1));\n} else {\nif((x__$1 instanceof cljs.core.Symbol)){\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1);\n} else {\nif(cljs.core.map_QMARK_(x__$1)){\nvar m \x3d ({});\nvar seq__19620_27065 \x3d cljs.core.seq(x__$1);\nvar chunk__19621_27066 \x3d null;\nvar count__19622_27067 \x3d (0);\nvar i__19623_27068 \x3d (0);\nwhile(true){\nif((i__19623_27068 \x3c count__19622_27067)){\nvar vec__19630_27069 \x3d chunk__19621_27066.cljs$core$IIndexed$_nth$arity$2(null, i__19623_27068);\nvar k_27070 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19630_27069,(0),null);\nvar v_27071 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19630_27069,(1),null);\ncljs.core.goog$module$goog$object.set(m,keyfn(k_27070),cljs$core$thisfn(v_27071));\n\n\nvar G__27072 \x3d seq__19620_27065;\nvar G__27073 \x3d chunk__19621_27066;\nvar G__27074 \x3d count__19622_27067;\nvar G__27075 \x3d (i__19623_27068 + (1));\nseq__19620_27065 \x3d G__27072;\nchunk__19621_27066 \x3d G__27073;\ncount__19622_27067 \x3d G__27074;\ni__19623_27068 \x3d G__27075;\ncontinue;\n} else {\nvar temp__5804__auto___27076 \x3d cljs.core.seq(seq__19620_27065);\nif(temp__5804__auto___27076){\nvar seq__19620_27077__$1 \x3d temp__5804__auto___27076;\nif(cljs.core.chunked_seq_QMARK_(seq__19620_27077__$1)){\nvar c__5525__auto___27079 \x3d cljs.core.chunk_first(seq__19620_27077__$1);\nvar G__27080 \x3d cljs.core.chunk_rest(seq__19620_27077__$1);\nvar G__27081 \x3d c__5525__auto___27079;\nvar G__27082 \x3d cljs.core.count(c__5525__auto___27079);\nvar G__27083 \x3d (0);\nseq__19620_27065 \x3d G__27080;\nchunk__19621_27066 \x3d G__27081;\ncount__19622_27067 \x3d G__27082;\ni__19623_27068 \x3d G__27083;\ncontinue;\n} else {\nvar vec__19633_27085 \x3d cljs.core.first(seq__19620_27077__$1);\nvar k_27086 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19633_27085,(0),null);\nvar v_27087 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19633_27085,(1),null);\ncljs.core.goog$module$goog$object.set(m,keyfn(k_27086),cljs$core$thisfn(v_27087));\n\n\nvar G__27089 \x3d cljs.core.next(seq__19620_27077__$1);\nvar G__27090 \x3d null;\nvar G__27091 \x3d (0);\nvar G__27092 \x3d (0);\nseq__19620_27065 \x3d G__27089;\nchunk__19621_27066 \x3d G__27090;\ncount__19622_27067 \x3d G__27091;\ni__19623_27068 \x3d G__27092;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn m;\n} else {\nif(cljs.core.coll_QMARK_(x__$1)){\nvar arr \x3d [];\nvar seq__19636_27093 \x3d cljs.core.seq(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs$core$thisfn,x__$1));\nvar chunk__19637_27094 \x3d null;\nvar count__19638_27095 \x3d (0);\nvar i__19639_27096 \x3d (0);\nwhile(true){\nif((i__19639_27096 \x3c count__19638_27095)){\nvar x_27097__$2 \x3d chunk__19637_27094.cljs$core$IIndexed$_nth$arity$2(null, i__19639_27096);\narr.push(x_27097__$2);\n\n\nvar G__27100 \x3d seq__19636_27093;\nvar G__27101 \x3d chunk__19637_27094;\nvar G__27102 \x3d count__19638_27095;\nvar G__27103 \x3d (i__19639_27096 + (1));\nseq__19636_27093 \x3d G__27100;\nchunk__19637_27094 \x3d G__27101;\ncount__19638_27095 \x3d G__27102;\ni__19639_27096 \x3d G__27103;\ncontinue;\n} else {\nvar temp__5804__auto___27106 \x3d cljs.core.seq(seq__19636_27093);\nif(temp__5804__auto___27106){\nvar seq__19636_27108__$1 \x3d temp__5804__auto___27106;\nif(cljs.core.chunked_seq_QMARK_(seq__19636_27108__$1)){\nvar c__5525__auto___27109 \x3d cljs.core.chunk_first(seq__19636_27108__$1);\nvar G__27110 \x3d cljs.core.chunk_rest(seq__19636_27108__$1);\nvar G__27111 \x3d c__5525__auto___27109;\nvar G__27112 \x3d cljs.core.count(c__5525__auto___27109);\nvar G__27113 \x3d (0);\nseq__19636_27093 \x3d G__27110;\nchunk__19637_27094 \x3d G__27111;\ncount__19638_27095 \x3d G__27112;\ni__19639_27096 \x3d G__27113;\ncontinue;\n} else {\nvar x_27114__$2 \x3d cljs.core.first(seq__19636_27108__$1);\narr.push(x_27114__$2);\n\n\nvar G__27116 \x3d cljs.core.next(seq__19636_27108__$1);\nvar G__27117 \x3d null;\nvar G__27118 \x3d (0);\nvar G__27119 \x3d (0);\nseq__19636_27093 \x3d G__27116;\nchunk__19637_27094 \x3d G__27117;\ncount__19638_27095 \x3d G__27118;\ni__19639_27096 \x3d G__27119;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn arr;\n} else {\nreturn x__$1;\n\n}\n}\n}\n}\n}\n}\n});\nreturn thisfn(x);\n}));\n\n(cljs.core.clj__GT_js.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.clj__GT_js.cljs$lang$applyTo \x3d (function (seq19590){\nvar G__19591 \x3d cljs.core.first(seq19590);\nvar seq19590__$1 \x3d cljs.core.next(seq19590);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19591,seq19590__$1);\n}));\n\n\n/**\n * @interface\n */\ncljs.core.IEncodeClojure \x3d function(){};\n\nvar cljs$core$IEncodeClojure$_js__GT_clj$dyn_27121 \x3d (function (x,options){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (cljs.core._js__GT_clj[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(x,options) : m__5351__auto__.call(null, x,options));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._js__GT_clj[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(x,options) : m__5349__auto__.call(null, x,options));\n} else {\nthrow cljs.core.missing_protocol(\x22IEncodeClojure.-js-\x3eclj\x22,x);\n}\n}\n});\n/**\n * Transforms JavaScript values to Clojure\n */\ncljs.core._js__GT_clj \x3d (function cljs$core$_js__GT_clj(x,options){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2 \x3d\x3d null)))))){\nreturn x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x,options);\n} else {\nreturn cljs$core$IEncodeClojure$_js__GT_clj$dyn_27121(x,options);\n}\n});\n\n/**\n * Recursively transforms JavaScript arrays into ClojureScript\n *   vectors, and JavaScript objects into ClojureScript maps.  With\n *   option \x27:keywordize-keys true\x27 will convert object fields from\n *   strings to keywords.\n */\ncljs.core.js__GT_clj \x3d (function cljs$core$js__GT_clj(var_args){\nvar G__19645 \x3d arguments.length;\nswitch (G__19645) {\ncase 1:\nreturn cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___27131 \x3d arguments.length;\nvar i__5727__auto___27132 \x3d (0);\nwhile(true){\nif((i__5727__auto___27132 \x3c len__5726__auto___27131)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___27132]));\n\nvar G__27133 \x3d (i__5727__auto___27132 + (1));\ni__5727__auto___27132 \x3d G__27133;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((1) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$variadic(x,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22keywordize-keys\x22,\x22keywordize-keys\x22,1310784252),false], 0));\n}));\n\n(cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$variadic \x3d (function (x,opts){\nvar map__19646 \x3d opts;\nvar map__19646__$1 \x3d cljs.core.__destructure_map(map__19646);\nvar keywordize_keys \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19646__$1,new cljs.core.Keyword(null,\x22keywordize-keys\x22,\x22keywordize-keys\x22,1310784252));\nvar keyfn \x3d (cljs.core.truth_(keywordize_keys)?cljs.core.keyword:cljs.core.str);\nvar f \x3d (function cljs$core$thisfn(x__$1){\nif((((!((x__$1 \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x__$1.cljs$core$IEncodeClojure$))))?true:(((!x__$1.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeClojure,x__$1):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeClojure,x__$1))){\nreturn cljs.core._js__GT_clj(x__$1,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.array_map,opts));\n} else {\nif(cljs.core.seq_QMARK_(x__$1)){\nreturn cljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs$core$thisfn,x__$1));\n} else {\nif(cljs.core.map_entry_QMARK_(x__$1)){\nreturn (new cljs.core.MapEntry(cljs$core$thisfn(cljs.core.key(x__$1)),cljs$core$thisfn(cljs.core.val(x__$1)),null));\n} else {\nif(cljs.core.coll_QMARK_(x__$1)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.empty(x__$1),cljs.core.map.cljs$core$IFn$_invoke$arity$1(cljs$core$thisfn),x__$1);\n} else {\nif(cljs.core.array_QMARK_(x__$1)){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19640_SHARP_,p2__19641_SHARP_){\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(p1__19640_SHARP_,cljs$core$thisfn(p2__19641_SHARP_));\n}),cljs.core.transient$(cljs.core.PersistentVector.EMPTY),x__$1));\n} else {\nif((cljs.core.type(x__$1) \x3d\x3d\x3d Object)){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (r,k){\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(r,(keyfn.cljs$core$IFn$_invoke$arity$1 ? keyfn.cljs$core$IFn$_invoke$arity$1(k) : keyfn.call(null, k)),cljs$core$thisfn(cljs.core.goog$module$goog$object.get(x__$1,k)));\n}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),cljs.core.js_keys(x__$1)));\n} else {\nreturn x__$1;\n\n}\n}\n}\n}\n}\n}\n});\nreturn f(x);\n}));\n\n/** @this {Function} */\n(cljs.core.js__GT_clj.cljs$lang$applyTo \x3d (function (seq19643){\nvar G__19644 \x3d cljs.core.first(seq19643);\nvar seq19643__$1 \x3d cljs.core.next(seq19643);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19644,seq19643__$1);\n}));\n\n(cljs.core.js__GT_clj.cljs$lang$maxFixedArity \x3d (1));\n\n/**\n * Returns a memoized version of a referentially transparent function. The\n *   memoized version of the function keeps a cache of the mapping from arguments\n *   to results and, when calls with the same arguments are repeated often, has\n *   higher performance at the expense of higher memory use.\n */\ncljs.core.memoize \x3d (function cljs$core$memoize(f){\nvar mem \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nreturn (function() { \nvar G__27155__delegate \x3d function (args){\nvar v \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(mem),args,cljs.core.lookup_sentinel);\nif((v \x3d\x3d\x3d cljs.core.lookup_sentinel)){\nvar ret \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,args);\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(mem,cljs.core.assoc,args,ret);\n\nreturn ret;\n} else {\nreturn v;\n}\n};\nvar G__27155 \x3d function (var_args){\nvar args \x3d null;\nif (arguments.length \x3e 0) {\nvar G__27157__i \x3d 0, G__27157__a \x3d new Array(arguments.length -  0);\nwhile (G__27157__i \x3c G__27157__a.length) {G__27157__a[G__27157__i] \x3d arguments[G__27157__i + 0]; ++G__27157__i;}\n  args \x3d new cljs.core.IndexedSeq(G__27157__a,0,null);\n} \nreturn G__27155__delegate.call(this,args);};\nG__27155.cljs$lang$maxFixedArity \x3d 0;\nG__27155.cljs$lang$applyTo \x3d (function (arglist__27158){\nvar args \x3d cljs.core.seq(arglist__27158);\nreturn G__27155__delegate(args);\n});\nG__27155.cljs$core$IFn$_invoke$arity$variadic \x3d G__27155__delegate;\nreturn G__27155;\n})()\n;\n});\n/**\n * trampoline can be used to convert algorithms requiring mutual\n *   recursion without stack consumption. Calls f with supplied args, if\n *   any. If f returns a fn, calls that fn with no arguments, and\n *   continues to repeat, until the return value is not a fn, then\n *   returns that non-fn value. Note that if you want to return a fn as a\n *   final value, you must wrap it in some data structure and unpack it\n *   after trampoline returns.\n */\ncljs.core.trampoline \x3d (function cljs$core$trampoline(var_args){\nvar G__19651 \x3d arguments.length;\nswitch (G__19651) {\ncase 1:\nreturn cljs.core.trampoline.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___27161 \x3d arguments.length;\nvar i__5727__auto___27162 \x3d (0);\nwhile(true){\nif((i__5727__auto___27162 \x3c len__5726__auto___27161)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___27162]));\n\nvar G__27163 \x3d (i__5727__auto___27162 + (1));\ni__5727__auto___27162 \x3d G__27163;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((1) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.trampoline.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5752__auto__);\n\n}\n});\n\n(cljs.core.trampoline.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nwhile(true){\nvar ret \x3d (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\nif(cljs.core.fn_QMARK_(ret)){\nvar G__27165 \x3d ret;\nf \x3d G__27165;\ncontinue;\n} else {\nreturn ret;\n}\nbreak;\n}\n}));\n\n(cljs.core.trampoline.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,args){\nreturn cljs.core.trampoline.cljs$core$IFn$_invoke$arity$1((function (){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,args);\n}));\n}));\n\n/** @this {Function} */\n(cljs.core.trampoline.cljs$lang$applyTo \x3d (function (seq19649){\nvar G__19650 \x3d cljs.core.first(seq19649);\nvar seq19649__$1 \x3d cljs.core.next(seq19649);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19650,seq19649__$1);\n}));\n\n(cljs.core.trampoline.cljs$lang$maxFixedArity \x3d (1));\n\n/**\n * Returns a random floating point number between 0 (inclusive) and\n *   n (default 1) (exclusive).\n */\ncljs.core.rand \x3d (function cljs$core$rand(var_args){\nvar G__19653 \x3d arguments.length;\nswitch (G__19653) {\ncase 0:\nreturn cljs.core.rand.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.rand.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.rand.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.rand.cljs$core$IFn$_invoke$arity$1((1));\n}));\n\n(cljs.core.rand.cljs$core$IFn$_invoke$arity$1 \x3d (function (n){\nreturn (Math.random() * n);\n}));\n\n(cljs.core.rand.cljs$lang$maxFixedArity \x3d 1);\n\n/**\n * Returns a random integer between 0 (inclusive) and n (exclusive).\n */\ncljs.core.rand_int \x3d (function cljs$core$rand_int(n){\nreturn Math.floor((Math.random() * n));\n});\n/**\n * Return a random element of the (sequential) collection. Will have\n *   the same performance characteristics as nth for the given\n *   collection.\n */\ncljs.core.rand_nth \x3d (function cljs$core$rand_nth(coll){\nreturn cljs.core.nth.cljs$core$IFn$_invoke$arity$2(coll,cljs.core.rand_int(cljs.core.count(coll)));\n});\n/**\n * Returns a map of the elements of coll keyed by the result of\n *   f on each element. The value at each key will be a vector of the\n *   corresponding elements, in the order they appeared in coll.\n */\ncljs.core.group_by \x3d (function cljs$core$group_by(f,coll){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret,x){\nvar k \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x));\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(ret,k,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(ret,k,cljs.core.PersistentVector.EMPTY),x));\n}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),coll));\n});\n/**\n * Creates a hierarchy object for use with derive, isa? etc.\n */\ncljs.core.make_hierarchy \x3d (function cljs$core$make_hierarchy(){\nreturn new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22parents\x22,\x22parents\x22,-2027538891),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22descendants\x22,\x22descendants\x22,1824886031),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22ancestors\x22,\x22ancestors\x22,-776045424),cljs.core.PersistentArrayMap.EMPTY], null);\n});\n/**\n * @type {*}\n */\ncljs.core._global_hierarchy \x3d null;\ncljs.core.get_global_hierarchy \x3d (function cljs$core$get_global_hierarchy(){\nif((cljs.core._global_hierarchy \x3d\x3d null)){\n(cljs.core._global_hierarchy \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.make_hierarchy()));\n} else {\n}\n\nreturn cljs.core._global_hierarchy;\n});\ncljs.core.swap_global_hierarchy_BANG_ \x3d (function cljs$core$swap_global_hierarchy_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27185 \x3d arguments.length;\nvar i__5727__auto___27186 \x3d (0);\nwhile(true){\nif((i__5727__auto___27186 \x3c len__5726__auto___27185)){\nargs__5732__auto__.push((arguments[i__5727__auto___27186]));\n\nvar G__27187 \x3d (i__5727__auto___27186 + (1));\ni__5727__auto___27186 \x3d G__27187;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (f,args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core.swap_BANG_,cljs.core.get_global_hierarchy(),f,args);\n}));\n\n(cljs.core.swap_global_hierarchy_BANG_.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.swap_global_hierarchy_BANG_.cljs$lang$applyTo \x3d (function (seq19654){\nvar G__19655 \x3d cljs.core.first(seq19654);\nvar seq19654__$1 \x3d cljs.core.next(seq19654);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19655,seq19654__$1);\n}));\n\n/**\n * Returns true if (\x3d child parent), or child is directly or indirectly derived from\n *   parent, either via a JavaScript type inheritance relationship or a\n *   relationship established via derive. h must be a hierarchy obtained\n *   from make-hierarchy, if not supplied defaults to the global\n *   hierarchy\n */\ncljs.core.isa_QMARK_ \x3d (function cljs$core$isa_QMARK_(var_args){\nvar G__19657 \x3d arguments.length;\nswitch (G__19657) {\ncase 2:\nreturn cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$2 \x3d (function (child,parent){\nreturn cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(cljs.core.get_global_hierarchy()),child,parent);\n}));\n\n(cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3 \x3d (function (h,child,parent){\nvar or__5002__auto__ \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(child,parent);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d cljs.core.contains_QMARK_((function (){var fexpr__19658 \x3d new cljs.core.Keyword(null,\x22ancestors\x22,\x22ancestors\x22,-776045424).cljs$core$IFn$_invoke$arity$1(h);\nreturn (fexpr__19658.cljs$core$IFn$_invoke$arity$1 ? fexpr__19658.cljs$core$IFn$_invoke$arity$1(child) : fexpr__19658.call(null, child));\n})(),parent);\nif(or__5002__auto____$1){\nreturn or__5002__auto____$1;\n} else {\nvar and__5000__auto__ \x3d cljs.core.vector_QMARK_(parent);\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d cljs.core.vector_QMARK_(child);\nif(and__5000__auto____$1){\nvar and__5000__auto____$2 \x3d (cljs.core.count(parent) \x3d\x3d\x3d cljs.core.count(child));\nif(and__5000__auto____$2){\nvar ret \x3d true;\nvar i \x3d (0);\nwhile(true){\nif((((!(ret))) || ((i \x3d\x3d\x3d cljs.core.count(parent))))){\nreturn ret;\n} else {\nvar G__27196 \x3d cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(h,(child.cljs$core$IFn$_invoke$arity$1 ? child.cljs$core$IFn$_invoke$arity$1(i) : child.call(null, i)),(parent.cljs$core$IFn$_invoke$arity$1 ? parent.cljs$core$IFn$_invoke$arity$1(i) : parent.call(null, i)));\nvar G__27197 \x3d (i + (1));\nret \x3d G__27196;\ni \x3d G__27197;\ncontinue;\n}\nbreak;\n}\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n}\n}\n}));\n\n(cljs.core.isa_QMARK_.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns the immediate parents of tag, either via a JavaScript type\n *   inheritance relationship or a relationship established via derive. h\n *   must be a hierarchy obtained from make-hierarchy, if not supplied\n *   defaults to the global hierarchy\n */\ncljs.core.parents \x3d (function cljs$core$parents(var_args){\nvar G__19660 \x3d arguments.length;\nswitch (G__19660) {\ncase 1:\nreturn cljs.core.parents.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.parents.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.parents.cljs$core$IFn$_invoke$arity$1 \x3d (function (tag){\nreturn cljs.core.parents.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.get_global_hierarchy()),tag);\n}));\n\n(cljs.core.parents.cljs$core$IFn$_invoke$arity$2 \x3d (function (h,tag){\nreturn cljs.core.not_empty(cljs.core.get.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22parents\x22,\x22parents\x22,-2027538891).cljs$core$IFn$_invoke$arity$1(h),tag));\n}));\n\n(cljs.core.parents.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns the immediate and indirect parents of tag, either via a JavaScript type\n *   inheritance relationship or a relationship established via derive. h\n *   must be a hierarchy obtained from make-hierarchy, if not supplied\n *   defaults to the global hierarchy\n */\ncljs.core.ancestors \x3d (function cljs$core$ancestors(var_args){\nvar G__19662 \x3d arguments.length;\nswitch (G__19662) {\ncase 1:\nreturn cljs.core.ancestors.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.ancestors.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.ancestors.cljs$core$IFn$_invoke$arity$1 \x3d (function (tag){\nreturn cljs.core.ancestors.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.get_global_hierarchy()),tag);\n}));\n\n(cljs.core.ancestors.cljs$core$IFn$_invoke$arity$2 \x3d (function (h,tag){\nreturn cljs.core.not_empty(cljs.core.get.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22ancestors\x22,\x22ancestors\x22,-776045424).cljs$core$IFn$_invoke$arity$1(h),tag));\n}));\n\n(cljs.core.ancestors.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns the immediate and indirect children of tag, through a\n *   relationship established via derive. h must be a hierarchy obtained\n *   from make-hierarchy, if not supplied defaults to the global\n *   hierarchy. Note: does not work on JavaScript type inheritance\n *   relationships.\n */\ncljs.core.descendants \x3d (function cljs$core$descendants(var_args){\nvar G__19664 \x3d arguments.length;\nswitch (G__19664) {\ncase 1:\nreturn cljs.core.descendants.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.descendants.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.descendants.cljs$core$IFn$_invoke$arity$1 \x3d (function (tag){\nreturn cljs.core.descendants.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.get_global_hierarchy()),tag);\n}));\n\n(cljs.core.descendants.cljs$core$IFn$_invoke$arity$2 \x3d (function (h,tag){\nreturn cljs.core.not_empty(cljs.core.get.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22descendants\x22,\x22descendants\x22,1824886031).cljs$core$IFn$_invoke$arity$1(h),tag));\n}));\n\n(cljs.core.descendants.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Establishes a parent/child relationship between parent and\n *   tag. Parent must be a namespace-qualified symbol or keyword and\n *   child can be either a namespace-qualified symbol or keyword or a\n *   class. h must be a hierarchy obtained from make-hierarchy, if not\n *   supplied defaults to, and modifies, the global hierarchy.\n */\ncljs.core.derive \x3d (function cljs$core$derive(var_args){\nvar G__19666 \x3d arguments.length;\nswitch (G__19666) {\ncase 2:\nreturn cljs.core.derive.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.derive.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.derive.cljs$core$IFn$_invoke$arity$2 \x3d (function (tag,parent){\nif(cljs.core.truth_(cljs.core.namespace(parent))){\n} else {\nthrow (new Error(\x22Assert failed: (namespace parent)\x22));\n}\n\ncljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.derive,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([tag,parent], 0));\n\nreturn null;\n}));\n\n(cljs.core.derive.cljs$core$IFn$_invoke$arity$3 \x3d (function (h,tag,parent){\nif(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(tag,parent)){\n} else {\nthrow (new Error(\x22Assert failed: (not\x3d tag parent)\x22));\n}\n\nvar tp \x3d new cljs.core.Keyword(null,\x22parents\x22,\x22parents\x22,-2027538891).cljs$core$IFn$_invoke$arity$1(h);\nvar td \x3d new cljs.core.Keyword(null,\x22descendants\x22,\x22descendants\x22,1824886031).cljs$core$IFn$_invoke$arity$1(h);\nvar ta \x3d new cljs.core.Keyword(null,\x22ancestors\x22,\x22ancestors\x22,-776045424).cljs$core$IFn$_invoke$arity$1(h);\nvar tf \x3d (function (m,source,sources,target,targets){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret,k){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,k,cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,cljs.core.get.cljs$core$IFn$_invoke$arity$3(targets,k,cljs.core.PersistentHashSet.EMPTY),cljs.core.cons(target,(targets.cljs$core$IFn$_invoke$arity$1 ? targets.cljs$core$IFn$_invoke$arity$1(target) : targets.call(null, target)))));\n}),m,cljs.core.cons(source,(sources.cljs$core$IFn$_invoke$arity$1 ? sources.cljs$core$IFn$_invoke$arity$1(source) : sources.call(null, source))));\n});\nvar or__5002__auto__ \x3d ((cljs.core.contains_QMARK_((tp.cljs$core$IFn$_invoke$arity$1 ? tp.cljs$core$IFn$_invoke$arity$1(tag) : tp.call(null, tag)),parent))?null:(function (){\nif(cljs.core.contains_QMARK_((ta.cljs$core$IFn$_invoke$arity$1 ? ta.cljs$core$IFn$_invoke$arity$1(tag) : ta.call(null, tag)),parent)){\nthrow (new Error([cljs.core.str.cljs$core$IFn$_invoke$arity$1(tag),\x22already has\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(parent),\x22as ancestor\x22].join(\x27\x27)));\n} else {\n}\n\nif(cljs.core.contains_QMARK_((ta.cljs$core$IFn$_invoke$arity$1 ? ta.cljs$core$IFn$_invoke$arity$1(parent) : ta.call(null, parent)),tag)){\nthrow (new Error([\x22Cyclic derivation:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(parent),\x22has\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(tag),\x22as ancestor\x22].join(\x27\x27)));\n} else {\n}\n\nreturn new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22parents\x22,\x22parents\x22,-2027538891),cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(new cljs.core.Keyword(null,\x22parents\x22,\x22parents\x22,-2027538891).cljs$core$IFn$_invoke$arity$1(h),tag,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(tp,tag,cljs.core.PersistentHashSet.EMPTY),parent)),new cljs.core.Keyword(null,\x22ancestors\x22,\x22ancestors\x22,-776045424),tf(new cljs.core.Keyword(null,\x22ancestors\x22,\x22ancestors\x22,-776045424).cljs$core$IFn$_invoke$arity$1(h),tag,td,parent,ta),new cljs.core.Keyword(null,\x22descendants\x22,\x22descendants\x22,1824886031),tf(new cljs.core.Keyword(null,\x22descendants\x22,\x22descendants\x22,1824886031).cljs$core$IFn$_invoke$arity$1(h),parent,ta,tag,td)], null);\n})()\n);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn h;\n}\n}));\n\n(cljs.core.derive.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Removes a parent/child relationship between parent and\n *   tag. h must be a hierarchy obtained from make-hierarchy, if not\n *   supplied defaults to, and modifies, the global hierarchy.\n */\ncljs.core.underive \x3d (function cljs$core$underive(var_args){\nvar G__19671 \x3d arguments.length;\nswitch (G__19671) {\ncase 2:\nreturn cljs.core.underive.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.underive.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.underive.cljs$core$IFn$_invoke$arity$2 \x3d (function (tag,parent){\ncljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.underive,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([tag,parent], 0));\n\nreturn null;\n}));\n\n(cljs.core.underive.cljs$core$IFn$_invoke$arity$3 \x3d (function (h,tag,parent){\nvar parentMap \x3d new cljs.core.Keyword(null,\x22parents\x22,\x22parents\x22,-2027538891).cljs$core$IFn$_invoke$arity$1(h);\nvar childsParents \x3d (cljs.core.truth_((parentMap.cljs$core$IFn$_invoke$arity$1 ? parentMap.cljs$core$IFn$_invoke$arity$1(tag) : parentMap.call(null, tag)))?cljs.core.disj.cljs$core$IFn$_invoke$arity$2((parentMap.cljs$core$IFn$_invoke$arity$1 ? parentMap.cljs$core$IFn$_invoke$arity$1(tag) : parentMap.call(null, tag)),parent):cljs.core.PersistentHashSet.EMPTY);\nvar newParents \x3d (cljs.core.truth_(cljs.core.not_empty(childsParents))?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(parentMap,tag,childsParents):cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(parentMap,tag));\nvar deriv_seq \x3d cljs.core.flatten(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__19667_SHARP_){\nreturn cljs.core.cons(cljs.core.first(p1__19667_SHARP_),cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(cljs.core.first(p1__19667_SHARP_),cljs.core.second(p1__19667_SHARP_)));\n}),cljs.core.seq(newParents)));\nif(cljs.core.contains_QMARK_((parentMap.cljs$core$IFn$_invoke$arity$1 ? parentMap.cljs$core$IFn$_invoke$arity$1(tag) : parentMap.call(null, tag)),parent)){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19668_SHARP_,p2__19669_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.derive,p1__19668_SHARP_,p2__19669_SHARP_);\n}),cljs.core.make_hierarchy(),cljs.core.partition.cljs$core$IFn$_invoke$arity$2((2),deriv_seq));\n} else {\nreturn h;\n}\n}));\n\n(cljs.core.underive.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.reset_cache \x3d (function cljs$core$reset_cache(method_cache,method_table,cached_hierarchy,hierarchy){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(method_cache,(function (_){\nreturn cljs.core.deref(method_table);\n}));\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(cached_hierarchy,(function (_){\nreturn cljs.core.deref(hierarchy);\n}));\n});\ncljs.core.prefers_STAR_ \x3d (function cljs$core$prefers_STAR_(x,y,prefer_table){\nvar xprefs \x3d (function (){var fexpr__19672 \x3d cljs.core.deref(prefer_table);\nreturn (fexpr__19672.cljs$core$IFn$_invoke$arity$1 ? fexpr__19672.cljs$core$IFn$_invoke$arity$1(x) : fexpr__19672.call(null, x));\n})();\nvar or__5002__auto__ \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d xprefs;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (xprefs.cljs$core$IFn$_invoke$arity$1 ? xprefs.cljs$core$IFn$_invoke$arity$1(y) : xprefs.call(null, y));\n} else {\nreturn and__5000__auto__;\n}\n})())?true:null);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (function (){var ps \x3d cljs.core.parents.cljs$core$IFn$_invoke$arity$1(y);\nwhile(true){\nif((cljs.core.count(ps) \x3e (0))){\nif(cljs.core.truth_((function (){var G__19673 \x3d x;\nvar G__19674 \x3d cljs.core.first(ps);\nvar G__19675 \x3d prefer_table;\nreturn (cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3 ? cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3(G__19673,G__19674,G__19675) : cljs.core.prefers_STAR_.call(null, G__19673,G__19674,G__19675));\n})())){\n} else {\n}\n\nvar G__27247 \x3d cljs.core.rest(ps);\nps \x3d G__27247;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n})();\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nvar or__5002__auto____$2 \x3d (function (){var ps \x3d cljs.core.parents.cljs$core$IFn$_invoke$arity$1(x);\nwhile(true){\nif((cljs.core.count(ps) \x3e (0))){\nif(cljs.core.truth_((function (){var G__19676 \x3d cljs.core.first(ps);\nvar G__19677 \x3d y;\nvar G__19678 \x3d prefer_table;\nreturn (cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3 ? cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3(G__19676,G__19677,G__19678) : cljs.core.prefers_STAR_.call(null, G__19676,G__19677,G__19678));\n})())){\n} else {\n}\n\nvar G__27251 \x3d cljs.core.rest(ps);\nps \x3d G__27251;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n})();\nif(cljs.core.truth_(or__5002__auto____$2)){\nreturn or__5002__auto____$2;\n} else {\nreturn false;\n}\n}\n}\n});\ncljs.core.dominates \x3d (function cljs$core$dominates(x,y,prefer_table,hierarchy){\nvar or__5002__auto__ \x3d cljs.core.prefers_STAR_(x,y,prefer_table);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(hierarchy,x,y);\n}\n});\ncljs.core.find_and_cache_best_method \x3d (function cljs$core$find_and_cache_best_method(name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy,default_dispatch_val){\nvar best_entry \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (be,p__19679){\nvar vec__19680 \x3d p__19679;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19680,(0),null);\nvar _ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19680,(1),null);\nvar e \x3d vec__19680;\nif(cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(hierarchy),dispatch_val,k)){\nvar be2 \x3d (((((be \x3d\x3d null)) || (cljs.core.dominates(k,cljs.core.first(be),prefer_table,cljs.core.deref(hierarchy)))))?e:be);\nif(cljs.core.dominates(cljs.core.first(be2),k,prefer_table,cljs.core.deref(hierarchy))){\n} else {\nthrow (new Error([\x22Multiple methods in multimethod \x27\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(name),\x22\x27 match dispatch value: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val),\x22 -\x3e \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(k),\x22 and \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(be2)),\x22, and neither is preferred\x22].join(\x27\x27)));\n}\n\nreturn be2;\n} else {\nreturn be;\n}\n}),null,cljs.core.deref(method_table));\nvar best_entry__$1 \x3d (function (){var temp__5802__auto__ \x3d (function (){var and__5000__auto__ \x3d (best_entry \x3d\x3d null);\nif(and__5000__auto__){\nvar fexpr__19683 \x3d cljs.core.deref(method_table);\nreturn (fexpr__19683.cljs$core$IFn$_invoke$arity$1 ? fexpr__19683.cljs$core$IFn$_invoke$arity$1(default_dispatch_val) : fexpr__19683.call(null, default_dispatch_val));\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.truth_(temp__5802__auto__)){\nvar entry \x3d temp__5802__auto__;\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [default_dispatch_val,entry], null);\n} else {\nreturn best_entry;\n}\n})();\nif(cljs.core.truth_(best_entry__$1)){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cached_hierarchy),cljs.core.deref(hierarchy))){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(method_cache,cljs.core.assoc,dispatch_val,cljs.core.second(best_entry__$1));\n\nreturn cljs.core.second(best_entry__$1);\n} else {\ncljs.core.reset_cache(method_cache,method_table,cached_hierarchy,hierarchy);\n\nreturn (cljs.core.find_and_cache_best_method.cljs$core$IFn$_invoke$arity$8 ? cljs.core.find_and_cache_best_method.cljs$core$IFn$_invoke$arity$8(name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy,default_dispatch_val) : cljs.core.find_and_cache_best_method.call(null, name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy,default_dispatch_val));\n}\n} else {\nreturn null;\n}\n});\n\n/**\n * @interface\n */\ncljs.core.IMultiFn \x3d function(){};\n\nvar cljs$core$IMultiFn$_reset$dyn_27256 \x3d (function (mf){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._reset[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5351__auto__.call(null, mf));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._reset[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5349__auto__.call(null, mf));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-reset\x22,mf);\n}\n}\n});\ncljs.core._reset \x3d (function cljs$core$_reset(mf){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_reset$arity$1 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_reset$arity$1(mf);\n} else {\nreturn cljs$core$IMultiFn$_reset$dyn_27256(mf);\n}\n});\n\nvar cljs$core$IMultiFn$_add_method$dyn_27258 \x3d (function (mf,dispatch_val,method){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._add_method[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,method) : m__5351__auto__.call(null, mf,dispatch_val,method));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._add_method[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,method) : m__5349__auto__.call(null, mf,dispatch_val,method));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-add-method\x22,mf);\n}\n}\n});\ncljs.core._add_method \x3d (function cljs$core$_add_method(mf,dispatch_val,method){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_add_method$arity$3 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_add_method$arity$3(mf,dispatch_val,method);\n} else {\nreturn cljs$core$IMultiFn$_add_method$dyn_27258(mf,dispatch_val,method);\n}\n});\n\nvar cljs$core$IMultiFn$_remove_method$dyn_27262 \x3d (function (mf,dispatch_val){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._remove_method[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__5351__auto__.call(null, mf,dispatch_val));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._remove_method[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__5349__auto__.call(null, mf,dispatch_val));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-remove-method\x22,mf);\n}\n}\n});\ncljs.core._remove_method \x3d (function cljs$core$_remove_method(mf,dispatch_val){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_remove_method$arity$2 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_remove_method$arity$2(mf,dispatch_val);\n} else {\nreturn cljs$core$IMultiFn$_remove_method$dyn_27262(mf,dispatch_val);\n}\n});\n\nvar cljs$core$IMultiFn$_prefer_method$dyn_27267 \x3d (function (mf,dispatch_val,dispatch_val_y){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._prefer_method[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,dispatch_val_y) : m__5351__auto__.call(null, mf,dispatch_val,dispatch_val_y));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._prefer_method[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,dispatch_val_y) : m__5349__auto__.call(null, mf,dispatch_val,dispatch_val_y));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-prefer-method\x22,mf);\n}\n}\n});\ncljs.core._prefer_method \x3d (function cljs$core$_prefer_method(mf,dispatch_val,dispatch_val_y){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_prefer_method$arity$3 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf,dispatch_val,dispatch_val_y);\n} else {\nreturn cljs$core$IMultiFn$_prefer_method$dyn_27267(mf,dispatch_val,dispatch_val_y);\n}\n});\n\nvar cljs$core$IMultiFn$_get_method$dyn_27277 \x3d (function (mf,dispatch_val){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._get_method[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__5351__auto__.call(null, mf,dispatch_val));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._get_method[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__5349__auto__.call(null, mf,dispatch_val));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-get-method\x22,mf);\n}\n}\n});\ncljs.core._get_method \x3d (function cljs$core$_get_method(mf,dispatch_val){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_get_method$arity$2 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_get_method$arity$2(mf,dispatch_val);\n} else {\nreturn cljs$core$IMultiFn$_get_method$dyn_27277(mf,dispatch_val);\n}\n});\n\nvar cljs$core$IMultiFn$_methods$dyn_27284 \x3d (function (mf){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._methods[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5351__auto__.call(null, mf));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._methods[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5349__auto__.call(null, mf));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-methods\x22,mf);\n}\n}\n});\ncljs.core._methods \x3d (function cljs$core$_methods(mf){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_methods$arity$1 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_methods$arity$1(mf);\n} else {\nreturn cljs$core$IMultiFn$_methods$dyn_27284(mf);\n}\n});\n\nvar cljs$core$IMultiFn$_prefers$dyn_27288 \x3d (function (mf){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._prefers[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5351__auto__.call(null, mf));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._prefers[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5349__auto__.call(null, mf));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-prefers\x22,mf);\n}\n}\n});\ncljs.core._prefers \x3d (function cljs$core$_prefers(mf){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_prefers$arity$1 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_prefers$arity$1(mf);\n} else {\nreturn cljs$core$IMultiFn$_prefers$dyn_27288(mf);\n}\n});\n\nvar cljs$core$IMultiFn$_default_dispatch_val$dyn_27290 \x3d (function (mf){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._default_dispatch_val[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5351__auto__.call(null, mf));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._default_dispatch_val[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5349__auto__.call(null, mf));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-default-dispatch-val\x22,mf);\n}\n}\n});\ncljs.core._default_dispatch_val \x3d (function cljs$core$_default_dispatch_val(mf){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_default_dispatch_val$arity$1 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_default_dispatch_val$arity$1(mf);\n} else {\nreturn cljs$core$IMultiFn$_default_dispatch_val$dyn_27290(mf);\n}\n});\n\nvar cljs$core$IMultiFn$_dispatch_fn$dyn_27295 \x3d (function (mf){\nvar x__5350__auto__ \x3d (((mf \x3d\x3d null))?null:mf);\nvar m__5351__auto__ \x3d (cljs.core._dispatch_fn[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5351__auto__.call(null, mf));\n} else {\nvar m__5349__auto__ \x3d (cljs.core._dispatch_fn[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__5349__auto__.call(null, mf));\n} else {\nthrow cljs.core.missing_protocol(\x22IMultiFn.-dispatch-fn\x22,mf);\n}\n}\n});\ncljs.core._dispatch_fn \x3d (function cljs$core$_dispatch_fn(mf){\nif((((!((mf \x3d\x3d null)))) \x26\x26 ((!((mf.cljs$core$IMultiFn$_dispatch_fn$arity$1 \x3d\x3d null)))))){\nreturn mf.cljs$core$IMultiFn$_dispatch_fn$arity$1(mf);\n} else {\nreturn cljs$core$IMultiFn$_dispatch_fn$dyn_27295(mf);\n}\n});\n\ncljs.core.throw_no_method_error \x3d (function cljs$core$throw_no_method_error(name,dispatch_val){\nthrow (new Error([\x22No method in multimethod \x27\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(name),\x22\x27 for dispatch value: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val)].join(\x27\x27)));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IFn}\n * @implements {cljs.core.IMultiFn}\n * @implements {cljs.core.INamed}\n*/\ncljs.core.MultiFn \x3d (function (name,dispatch_fn,default_dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy){\nthis.name \x3d name;\nthis.dispatch_fn \x3d dispatch_fn;\nthis.default_dispatch_val \x3d default_dispatch_val;\nthis.hierarchy \x3d hierarchy;\nthis.method_table \x3d method_table;\nthis.prefer_table \x3d prefer_table;\nthis.method_cache \x3d method_cache;\nthis.cached_hierarchy \x3d cached_hierarchy;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 4194305;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 4352;\n});\n(cljs.core.MultiFn.prototype.call \x3d (function (unused__10318__auto__){\nvar self__ \x3d this;\nvar self__ \x3d this;\nvar G__19685 \x3d (arguments.length - (1));\nswitch (G__19685) {\ncase (0):\nreturn self__.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase (1):\nreturn self__.cljs$core$IFn$_invoke$arity$1((arguments[(1)]));\n\nbreak;\ncase (2):\nreturn self__.cljs$core$IFn$_invoke$arity$2((arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase (3):\nreturn self__.cljs$core$IFn$_invoke$arity$3((arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase (4):\nreturn self__.cljs$core$IFn$_invoke$arity$4((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase (5):\nreturn self__.cljs$core$IFn$_invoke$arity$5((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ncase (6):\nreturn self__.cljs$core$IFn$_invoke$arity$6((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]));\n\nbreak;\ncase (7):\nreturn self__.cljs$core$IFn$_invoke$arity$7((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]));\n\nbreak;\ncase (8):\nreturn self__.cljs$core$IFn$_invoke$arity$8((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]));\n\nbreak;\ncase (9):\nreturn self__.cljs$core$IFn$_invoke$arity$9((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]));\n\nbreak;\ncase (10):\nreturn self__.cljs$core$IFn$_invoke$arity$10((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]));\n\nbreak;\ncase (11):\nreturn self__.cljs$core$IFn$_invoke$arity$11((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]));\n\nbreak;\ncase (12):\nreturn self__.cljs$core$IFn$_invoke$arity$12((arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]));\n\nbreak;\ncase (13):\nreturn self__.cljs$core$IFn$_invoke$arity$13((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)]));\n\nbreak;\ncase (14):\nreturn self__.cljs$core$IFn$_invoke$arity$14((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)]));\n\nbreak;\ncase (15):\nreturn self__.cljs$core$IFn$_invoke$arity$15((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)]));\n\nbreak;\ncase (16):\nreturn self__.cljs$core$IFn$_invoke$arity$16((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)]));\n\nbreak;\ncase (17):\nreturn self__.cljs$core$IFn$_invoke$arity$17((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)]));\n\nbreak;\ncase (18):\nreturn self__.cljs$core$IFn$_invoke$arity$18((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)]));\n\nbreak;\ncase (19):\nreturn self__.cljs$core$IFn$_invoke$arity$19((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)]));\n\nbreak;\ncase (20):\nreturn self__.cljs$core$IFn$_invoke$arity$20((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)]));\n\nbreak;\ncase (21):\nreturn self__.cljs$core$IFn$_invoke$arity$21((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)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments.length - (1)))].join(\x27\x27)));\n\n}\n}));\n\n(cljs.core.MultiFn.prototype.apply \x3d (function (self__,args19684){\nvar self__ \x3d this;\nvar self____$1 \x3d this;\nreturn self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args19684)));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$0 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$0() : self__.dispatch_fn.call(null, ));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$0 ? target_fn.cljs$core$IFn$_invoke$arity$0() : target_fn.call(null, ));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$1 \x3d (function (a){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$1 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$1(a) : self__.dispatch_fn.call(null, a));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$1 ? target_fn.cljs$core$IFn$_invoke$arity$1(a) : target_fn.call(null, a));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$2 \x3d (function (a,b){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$2 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.dispatch_fn.call(null, a,b));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$2 ? target_fn.cljs$core$IFn$_invoke$arity$2(a,b) : target_fn.call(null, a,b));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$3 \x3d (function (a,b,c){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$3 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$3(a,b,c) : self__.dispatch_fn.call(null, a,b,c));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$3 ? target_fn.cljs$core$IFn$_invoke$arity$3(a,b,c) : target_fn.call(null, a,b,c));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$4 \x3d (function (a,b,c,d){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$4 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : self__.dispatch_fn.call(null, a,b,c,d));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$4 ? target_fn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : target_fn.call(null, a,b,c,d));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$5 \x3d (function (a,b,c,d,e){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$5 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : self__.dispatch_fn.call(null, a,b,c,d,e));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$5 ? target_fn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : target_fn.call(null, a,b,c,d,e));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$6 \x3d (function (a,b,c,d,e,f){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$6 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : self__.dispatch_fn.call(null, a,b,c,d,e,f));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$6 ? target_fn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : target_fn.call(null, a,b,c,d,e,f));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$7 \x3d (function (a,b,c,d,e,f,g){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$7 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$7 ? target_fn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : target_fn.call(null, a,b,c,d,e,f,g));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$8 \x3d (function (a,b,c,d,e,f,g,h){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$8 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$8 ? target_fn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : target_fn.call(null, a,b,c,d,e,f,g,h));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$9 \x3d (function (a,b,c,d,e,f,g,h,i){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$9 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$9 ? target_fn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : target_fn.call(null, a,b,c,d,e,f,g,h,i));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$10 \x3d (function (a,b,c,d,e,f,g,h,i,j){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$10 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$10 ? target_fn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$11 \x3d (function (a,b,c,d,e,f,g,h,i,j,k){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$11 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$11 ? target_fn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$12 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$12 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$12 ? target_fn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$13 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$13 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$13 ? target_fn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$14 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$14 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$14 ? target_fn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$15 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$15 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$15 ? target_fn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$16 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$16 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$16 ? target_fn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$17 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$17 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : self__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$17 ? target_fn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$18 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$18 ? self__.dispatch_fn.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__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$18 ? target_fn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$19 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$19 ? self__.dispatch_fn.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__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$19 ? target_fn.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) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$20 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$20 ? self__.dispatch_fn.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__.dispatch_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn (target_fn.cljs$core$IFn$_invoke$arity$20 ? target_fn.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) : target_fn.call(null, a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$21 \x3d (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){\nvar self__ \x3d this;\nvar mf \x3d this;\nvar dispatch_val \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(self__.dispatch_fn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0));\nvar target_fn \x3d mf.cljs$core$IMultiFn$_get_method$arity$2(null, dispatch_val);\nif(cljs.core.truth_(target_fn)){\n} else {\ncljs.core.throw_no_method_error(self__.name,dispatch_val);\n}\n\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(target_fn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0));\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_prefer_method$arity$3 \x3d (function (mf,dispatch_val_x,dispatch_val_y){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\nif(cljs.core.truth_(cljs.core.prefers_STAR_(dispatch_val_y,dispatch_val_x,self__.prefer_table))){\nthrow (new Error([\x22Preference conflict in multimethod \x27\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.name),\x22\x27: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val_y),\x22 is already preferred to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val_x)].join(\x27\x27)));\n} else {\n}\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.prefer_table,(function (old){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(old,dispatch_val_x,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(old,dispatch_val_x,cljs.core.PersistentHashSet.EMPTY),dispatch_val_y));\n}));\n\nreturn cljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy);\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_default_dispatch_val$arity$1 \x3d (function (mf){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\nreturn self__.default_dispatch_val;\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_remove_method$arity$2 \x3d (function (mf,dispatch_val){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(self__.method_table,cljs.core.dissoc,dispatch_val);\n\ncljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy);\n\nreturn mf__$1;\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_methods$arity$1 \x3d (function (mf){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\nreturn cljs.core.deref(self__.method_table);\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_prefers$arity$1 \x3d (function (mf){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\nreturn cljs.core.deref(self__.prefer_table);\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_dispatch_fn$arity$1 \x3d (function (mf){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\nreturn self__.dispatch_fn;\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_add_method$arity$3 \x3d (function (mf,dispatch_val,method){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.method_table,cljs.core.assoc,dispatch_val,method);\n\ncljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy);\n\nreturn mf__$1;\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_reset$arity$1 \x3d (function (mf){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.method_table,(function (mf__$2){\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.method_cache,(function (mf__$2){\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.prefer_table,(function (mf__$2){\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.cached_hierarchy,(function (mf__$2){\nreturn null;\n}));\n\nreturn mf__$1;\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_get_method$arity$2 \x3d (function (mf,dispatch_val){\nvar self__ \x3d this;\nvar mf__$1 \x3d this;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(self__.cached_hierarchy),cljs.core.deref(self__.hierarchy))){\n} else {\ncljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy);\n}\n\nvar temp__5802__auto__ \x3d (function (){var fexpr__19686 \x3d cljs.core.deref(self__.method_cache);\nreturn (fexpr__19686.cljs$core$IFn$_invoke$arity$1 ? fexpr__19686.cljs$core$IFn$_invoke$arity$1(dispatch_val) : fexpr__19686.call(null, dispatch_val));\n})();\nif(cljs.core.truth_(temp__5802__auto__)){\nvar target_fn \x3d temp__5802__auto__;\nreturn target_fn;\n} else {\nreturn cljs.core.find_and_cache_best_method(self__.name,dispatch_val,self__.hierarchy,self__.method_table,self__.prefer_table,self__.method_cache,self__.cached_hierarchy,self__.default_dispatch_val);\n}\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$INamed$_name$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core._name(self__.name);\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$INamed$_namespace$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core._namespace(self__.name);\n}));\n\n(cljs.core.MultiFn.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn goog.getUid(this$__$1);\n}));\n\n(cljs.core.MultiFn.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 8, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22name\x22,\x22name\x22,-810760592,null),new cljs.core.Symbol(null,\x22dispatch-fn\x22,\x22dispatch-fn\x22,-1401088155,null),new cljs.core.Symbol(null,\x22default-dispatch-val\x22,\x22default-dispatch-val\x22,-1231201266,null),new cljs.core.Symbol(null,\x22hierarchy\x22,\x22hierarchy\x22,587061186,null),new cljs.core.Symbol(null,\x22method-table\x22,\x22method-table\x22,-1878263165,null),new cljs.core.Symbol(null,\x22prefer-table\x22,\x22prefer-table\x22,462168584,null),new cljs.core.Symbol(null,\x22method-cache\x22,\x22method-cache\x22,1230193905,null),new cljs.core.Symbol(null,\x22cached-hierarchy\x22,\x22cached-hierarchy\x22,-1085460203,null)], null);\n}));\n\n(cljs.core.MultiFn.cljs$lang$type \x3d true);\n\n(cljs.core.MultiFn.cljs$lang$ctorStr \x3d \x22cljs.core/MultiFn\x22);\n\n(cljs.core.MultiFn.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/MultiFn\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/MultiFn.\n */\ncljs.core.__GT_MultiFn \x3d (function cljs$core$__GT_MultiFn(name,dispatch_fn,default_dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy){\nreturn (new cljs.core.MultiFn(name,dispatch_fn,default_dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy));\n});\n\n/**\n * Removes all of the methods of multimethod.\n */\ncljs.core.remove_all_methods \x3d (function cljs$core$remove_all_methods(multifn){\nreturn cljs.core._reset(multifn);\n});\n/**\n * Removes the method of multimethod associated with dispatch-value.\n */\ncljs.core.remove_method \x3d (function cljs$core$remove_method(multifn,dispatch_val){\nreturn cljs.core._remove_method(multifn,dispatch_val);\n});\n/**\n * Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y\n * when there is a conflict\n */\ncljs.core.prefer_method \x3d (function cljs$core$prefer_method(multifn,dispatch_val_x,dispatch_val_y){\nreturn cljs.core._prefer_method(multifn,dispatch_val_x,dispatch_val_y);\n});\n/**\n * Given a multimethod, returns a map of dispatch values -\x3e dispatch fns\n */\ncljs.core.methods$ \x3d (function cljs$core$methods(multifn){\nreturn cljs.core._methods(multifn);\n});\n/**\n * Given a multimethod and a dispatch value, returns the dispatch fn\n *   that would apply to that value, or nil if none apply and no default\n */\ncljs.core.get_method \x3d (function cljs$core$get_method(multifn,dispatch_val){\nreturn cljs.core._get_method(multifn,dispatch_val);\n});\n/**\n * Given a multimethod, returns a map of preferred value -\x3e set of other values\n */\ncljs.core.prefers \x3d (function cljs$core$prefers(multifn){\nreturn cljs.core._prefers(multifn);\n});\n/**\n * Given a multimethod, return its default-dispatch-val.\n */\ncljs.core.default_dispatch_val \x3d (function cljs$core$default_dispatch_val(multifn){\nreturn cljs.core._default_dispatch_val(multifn);\n});\n/**\n * Given a multimethod, return its dispatch-fn.\n */\ncljs.core.dispatch_fn \x3d (function cljs$core$dispatch_fn(multifn){\nreturn cljs.core._dispatch_fn(multifn);\n});\n\n/**\n * A marker protocol for UUIDs\n * @interface\n */\ncljs.core.IUUID \x3d function(){};\n\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IComparable}\n * @implements {cljs.core.IUUID}\n*/\ncljs.core.UUID \x3d (function (uuid,__hash){\nthis.uuid \x3d uuid;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2153775104;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 2048;\n});\n(cljs.core.UUID.prototype.cljs$core$IUUID$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.UUID.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn self__.uuid;\n}));\n\n(cljs.core.UUID.prototype.equiv \x3d (function (other){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.cljs$core$IEquiv$_equiv$arity$2(null, other);\n}));\n\n(cljs.core.UUID.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (_,other){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar and__5000__auto__ \x3d (((!((other \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d other.cljs$core$IUUID$))))?true:false):false);\nif(and__5000__auto__){\nreturn (self__.uuid \x3d\x3d\x3d other.uuid);\n} else {\nreturn and__5000__auto__;\n}\n}));\n\n(cljs.core.UUID.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (_,writer,___$1){\nvar self__ \x3d this;\nvar ___$2 \x3d this;\nreturn cljs.core._write(writer,[\x22#uuid \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.uuid),\x22\\\x22\x22].join(\x27\x27));\n}));\n\n(cljs.core.UUID.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((self__.__hash \x3d\x3d null)){\n(self__.__hash \x3d cljs.core.hash(self__.uuid));\n} else {\n}\n\nreturn self__.__hash;\n}));\n\n(cljs.core.UUID.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (this$,other){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((other instanceof cljs.core.UUID)){\nreturn cljs.core.goog$module$goog$array.defaultCompare(self__.uuid,other.uuid);\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(other)].join(\x27\x27)));\n}\n}));\n\n(cljs.core.UUID.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22uuid\x22,\x22uuid\x22,-504564192,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22__hash\x22,\x22__hash\x22,-1328796629,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.UUID.cljs$lang$type \x3d true);\n\n(cljs.core.UUID.cljs$lang$ctorStr \x3d \x22cljs.core/UUID\x22);\n\n(cljs.core.UUID.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/UUID\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/UUID.\n */\ncljs.core.__GT_UUID \x3d (function cljs$core$__GT_UUID(uuid,__hash){\nreturn (new cljs.core.UUID(uuid,__hash));\n});\n\n/**\n * Returns a UUID consistent with the string s.\n */\ncljs.core.uuid \x3d (function cljs$core$uuid(s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\n} else {\nthrow (new Error(\x22Assert failed: (string? s)\x22));\n}\n\nreturn (new cljs.core.UUID(s.toLowerCase(),null));\n});\n/**\n * Returns a pseudo-randomly generated UUID instance (i.e. type 4).\n */\ncljs.core.random_uuid \x3d (function cljs$core$random_uuid(){\nvar quad_hex \x3d (function cljs$core$random_uuid_$_quad_hex(){\nvar unpadded_hex \x3d cljs.core.rand_int((65536)).toString((16));\nvar G__19689 \x3d ((unpadded_hex).length);\nswitch (G__19689) {\ncase (1):\nreturn [\x22000\x22,unpadded_hex].join(\x27\x27);\n\nbreak;\ncase (2):\nreturn [\x2200\x22,unpadded_hex].join(\x27\x27);\n\nbreak;\ncase (3):\nreturn [\x220\x22,unpadded_hex].join(\x27\x27);\n\nbreak;\ndefault:\nreturn unpadded_hex;\n\n}\n});\nvar ver_tripple_hex \x3d ((16384) | ((4095) \x26 cljs.core.rand_int((65536)))).toString((16));\nvar res_tripple_hex \x3d ((32768) | ((16383) \x26 cljs.core.rand_int((65536)))).toString((16));\nreturn cljs.core.uuid([quad_hex(),quad_hex(),\x22-\x22,quad_hex(),\x22-\x22,ver_tripple_hex,\x22-\x22,res_tripple_hex,\x22-\x22,quad_hex(),quad_hex(),quad_hex()].join(\x27\x27));\n});\n/**\n * Return true if x is a UUID.\n */\ncljs.core.uuid_QMARK_ \x3d (function cljs$core$uuid_QMARK_(x){\nif((!((x \x3d\x3d null)))){\nif(((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IUUID$)))){\nreturn true;\n} else {\nreturn false;\n}\n} else {\nreturn false;\n}\n});\ncljs.core.pr_writer_ex_info \x3d (function cljs$core$pr_writer_ex_info(obj,writer,opts){\ncljs.core._write(writer,\x22#error {:message \x22);\n\ncljs.core.pr_writer(obj.message,writer,opts);\n\nif(cljs.core.truth_(obj.data)){\ncljs.core._write(writer,\x22, :data \x22);\n\ncljs.core.pr_writer(obj.data,writer,opts);\n} else {\n}\n\nif(cljs.core.truth_(obj.cause)){\ncljs.core._write(writer,\x22, :cause \x22);\n\ncljs.core.pr_writer(obj.cause,writer,opts);\n} else {\n}\n\nreturn cljs.core._write(writer,\x22}\x22);\n});\n/**\n * @constructor\n */\ncljs.core.ExceptionInfo \x3d (function cljs$core$ExceptionInfo(message,data,cause){\nvar e \x3d (new Error(message));\nvar this$ \x3d this;\n(this$.message \x3d message);\n\n(this$.data \x3d data);\n\n(this$.cause \x3d cause);\n\n(this$.name \x3d e.name);\n\n(this$.description \x3d e.description);\n\n(this$.number \x3d e.number);\n\n(this$.fileName \x3d e.fileName);\n\n(this$.lineNumber \x3d e.lineNumber);\n\n(this$.columnNumber \x3d e.columnNumber);\n\n(this$.stack \x3d e.stack);\n\nreturn this$;\n});\n(cljs.core.ExceptionInfo.prototype.__proto__ \x3d Error.prototype);\n(cljs.core.ExceptionInfo.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ExceptionInfo.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (obj,writer,opts){\nvar obj__$1 \x3d this;\nreturn cljs.core.pr_writer_ex_info(obj__$1,writer,opts);\n}));\n(cljs.core.ExceptionInfo.prototype.toString \x3d (function (){\nvar this$ \x3d this;\nreturn cljs.core.pr_str_STAR_(this$);\n}));\n/**\n * Create an instance of ExceptionInfo, an Error type that carries a\n *   map of additional data.\n */\ncljs.core.ex_info \x3d (function cljs$core$ex_info(var_args){\nvar G__19692 \x3d arguments.length;\nswitch (G__19692) {\ncase 2:\nreturn cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2 \x3d (function (msg,data){\nreturn cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3(msg,data,null);\n}));\n\n(cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3 \x3d (function (msg,data,cause){\nreturn (new cljs.core.ExceptionInfo(msg,data,cause));\n}));\n\n(cljs.core.ex_info.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Returns exception data (a map) if ex is an ExceptionInfo.\n *   Otherwise returns nil.\n */\ncljs.core.ex_data \x3d (function cljs$core$ex_data(ex){\nif((ex instanceof cljs.core.ExceptionInfo)){\nreturn ex.data;\n} else {\nreturn null;\n}\n});\n/**\n * Returns the message attached to the given Error / ExceptionInfo object.\n *   For non-Errors returns nil.\n */\ncljs.core.ex_message \x3d (function cljs$core$ex_message(ex){\nif((ex instanceof Error)){\nreturn ex.message;\n} else {\nreturn null;\n}\n});\n/**\n * Returns exception cause (an Error / ExceptionInfo) if ex is an\n *   ExceptionInfo.\n *   Otherwise returns nil.\n */\ncljs.core.ex_cause \x3d (function cljs$core$ex_cause(ex){\nif((ex instanceof cljs.core.ExceptionInfo)){\nreturn ex.cause;\n} else {\nreturn null;\n}\n});\n/**\n * Constructs a data representation for an Error with keys:\n *  :cause - root cause message\n *  :phase - error phase\n *  :via - cause chain, with cause keys:\n *           :type - exception class symbol\n *           :message - exception message\n *           :data - ex-data\n *           :at - top stack element\n *  :trace - root cause stack elements\n */\ncljs.core.Throwable__GT_map \x3d (function cljs$core$Throwable__GT_map(o){\nvar base \x3d (function (t){\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),(((t instanceof cljs.core.ExceptionInfo))?new cljs.core.Symbol(\x22cljs.core\x22,\x22ExceptionInfo\x22,\x22cljs.core/ExceptionInfo\x22,701839050,null):(((t instanceof Error))?cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(\x22js\x22,t.name):null\n))], null),(function (){var temp__5804__auto__ \x3d cljs.core.ex_message(t);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar msg \x3d temp__5804__auto__;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22message\x22,\x22message\x22,-406056002),msg], null);\n} else {\nreturn null;\n}\n})(),(function (){var temp__5804__auto__ \x3d cljs.core.ex_data(t);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar ed \x3d temp__5804__auto__;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),ed], null);\n} else {\nreturn null;\n}\n})()], 0));\n});\nvar via \x3d (function (){var via \x3d cljs.core.PersistentVector.EMPTY;\nvar t \x3d o;\nwhile(true){\nif(cljs.core.truth_(t)){\nvar G__27487 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(via,t);\nvar G__27488 \x3d cljs.core.ex_cause(t);\nvia \x3d G__27487;\nt \x3d G__27488;\ncontinue;\n} else {\nreturn via;\n}\nbreak;\n}\n})();\nvar root \x3d cljs.core.peek(via);\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2(base,via)),new cljs.core.Keyword(null,\x22trace\x22,\x22trace\x22,-1082747415),null], null),(function (){var temp__5804__auto__ \x3d cljs.core.ex_message(root);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar root_msg \x3d temp__5804__auto__;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22cause\x22,\x22cause\x22,231901252),root_msg], null);\n} else {\nreturn null;\n}\n})(),(function (){var temp__5804__auto__ \x3d cljs.core.ex_data(root);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar data \x3d temp__5804__auto__;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),data], null);\n} else {\nreturn null;\n}\n})(),(function (){var temp__5804__auto__ \x3d new cljs.core.Keyword(\x22clojure.error\x22,\x22phase\x22,\x22clojure.error/phase\x22,275140358).cljs$core$IFn$_invoke$arity$1(cljs.core.ex_data(o));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar phase \x3d temp__5804__auto__;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22phase\x22,\x22phase\x22,575722892),phase], null);\n} else {\nreturn null;\n}\n})()], 0));\n});\n/**\n * Returns an JavaScript compatible comparator based upon pred.\n */\ncljs.core.comparator \x3d (function cljs$core$comparator(pred){\nreturn (function (x,y){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$2 ? pred.cljs$core$IFn$_invoke$arity$2(x,y) : pred.call(null, x,y)))){\nreturn (-1);\n} else {\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$2 ? pred.cljs$core$IFn$_invoke$arity$2(y,x) : pred.call(null, y,x)))){\nreturn (1);\n} else {\nreturn (0);\n\n}\n}\n});\n});\n/**\n * Returns true if x names a special form\n */\ncljs.core.special_symbol_QMARK_ \x3d (function cljs$core$special_symbol_QMARK_(x){\nreturn cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 24, [new cljs.core.Symbol(null,\x22\x26\x22,\x22\x26\x22,-2144855648,null),\x22null\x22,new cljs.core.Symbol(null,\x22case*\x22,\x22case*\x22,-1938255072,null),\x22null\x22,new cljs.core.Symbol(null,\x22defrecord*\x22,\x22defrecord*\x22,-1936366207,null),\x22null\x22,new cljs.core.Symbol(null,\x22try\x22,\x22try\x22,-1273693247,null),\x22null\x22,new cljs.core.Symbol(null,\x22ns*\x22,\x22ns*\x22,1840949383,null),\x22null\x22,new cljs.core.Symbol(null,\x22finally\x22,\x22finally\x22,-1065347064,null),\x22null\x22,new cljs.core.Symbol(null,\x22loop*\x22,\x22loop*\x22,615029416,null),\x22null\x22,new cljs.core.Symbol(null,\x22do\x22,\x22do\x22,1686842252,null),\x22null\x22,new cljs.core.Symbol(null,\x22letfn*\x22,\x22letfn*\x22,-110097810,null),\x22null\x22,new cljs.core.Symbol(null,\x22if\x22,\x22if\x22,1181717262,null),\x22null\x22,new cljs.core.Symbol(null,\x22new\x22,\x22new\x22,-444906321,null),\x22null\x22,new cljs.core.Symbol(null,\x22ns\x22,\x22ns\x22,2082130287,null),\x22null\x22,new cljs.core.Symbol(null,\x22deftype*\x22,\x22deftype*\x22,962659890,null),\x22null\x22,new cljs.core.Symbol(null,\x22let*\x22,\x22let*\x22,1920721458,null),\x22null\x22,new cljs.core.Symbol(null,\x22js*\x22,\x22js*\x22,-1134233646,null),\x22null\x22,new cljs.core.Symbol(null,\x22fn*\x22,\x22fn*\x22,-752876845,null),\x22null\x22,new cljs.core.Symbol(null,\x22recur\x22,\x22recur\x22,1202958259,null),\x22null\x22,new cljs.core.Symbol(null,\x22set!\x22,\x22set!\x22,250714521,null),\x22null\x22,new cljs.core.Symbol(null,\x22.\x22,\x22.\x22,1975675962,null),\x22null\x22,new cljs.core.Symbol(null,\x22var\x22,\x22var\x22,870848730,null),\x22null\x22,new cljs.core.Symbol(null,\x22quote\x22,\x22quote\x22,1377916282,null),\x22null\x22,new cljs.core.Symbol(null,\x22catch\x22,\x22catch\x22,-1616370245,null),\x22null\x22,new cljs.core.Symbol(null,\x22throw\x22,\x22throw\x22,595905694,null),\x22null\x22,new cljs.core.Symbol(null,\x22def\x22,\x22def\x22,597100991,null),\x22null\x22], null), null),x);\n});\n/**\n * test [v] finds fn at key :test in var metadata and calls it,\n *   presuming failure will throw exception\n */\ncljs.core.test \x3d (function cljs$core$test(v){\nvar f \x3d v.cljs$lang$test;\nif(cljs.core.truth_(f)){\n(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null, ));\n\nreturn new cljs.core.Keyword(null,\x22ok\x22,\x22ok\x22,967785236);\n} else {\nreturn new cljs.core.Keyword(null,\x22no-test\x22,\x22no-test\x22,-1679482642);\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.ILookup}\n*/\ncljs.core.TaggedLiteral \x3d (function (tag,form){\nthis.tag \x3d tag;\nthis.form \x3d form;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2153775360;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.TaggedLiteral.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar coll \x3d this;\nreturn cljs.core.pr_str_STAR_(coll);\n}));\n\n(cljs.core.TaggedLiteral.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this$,other){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (((other instanceof cljs.core.TaggedLiteral)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.tag,other.tag)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.form,other.form)))));\n}));\n\n(cljs.core.TaggedLiteral.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (((31) * cljs.core.hash(self__.tag)) + cljs.core.hash(self__.form));\n}));\n\n(cljs.core.TaggedLiteral.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this$,v){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn this$__$1.cljs$core$ILookup$_lookup$arity$3(null, v,null);\n}));\n\n(cljs.core.TaggedLiteral.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this$,v,not_found){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar G__19693 \x3d v;\nvar G__19693__$1 \x3d (((G__19693 instanceof cljs.core.Keyword))?G__19693.fqn:null);\nswitch (G__19693__$1) {\ncase \x22tag\x22:\nreturn self__.tag;\n\nbreak;\ncase \x22form\x22:\nreturn self__.form;\n\nbreak;\ndefault:\nreturn not_found;\n\n}\n}));\n\n(cljs.core.TaggedLiteral.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (o,writer,opts){\nvar self__ \x3d this;\nvar o__$1 \x3d this;\ncljs.core._write(writer,[\x22#\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.tag),\x22 \x22].join(\x27\x27));\n\nreturn cljs.core.pr_writer(self__.form,writer,opts);\n}));\n\n(cljs.core.TaggedLiteral.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22tag\x22,\x22tag\x22,350170304,null),new cljs.core.Symbol(null,\x22form\x22,\x22form\x22,16469056,null)], null);\n}));\n\n(cljs.core.TaggedLiteral.cljs$lang$type \x3d true);\n\n(cljs.core.TaggedLiteral.cljs$lang$ctorStr \x3d \x22cljs.core/TaggedLiteral\x22);\n\n(cljs.core.TaggedLiteral.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/TaggedLiteral\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/TaggedLiteral.\n */\ncljs.core.__GT_TaggedLiteral \x3d (function cljs$core$__GT_TaggedLiteral(tag,form){\nreturn (new cljs.core.TaggedLiteral(tag,form));\n});\n\n/**\n * Return true if the value is the data representation of a tagged literal\n */\ncljs.core.tagged_literal_QMARK_ \x3d (function cljs$core$tagged_literal_QMARK_(value){\nreturn (value instanceof cljs.core.TaggedLiteral);\n});\n/**\n * Construct a data representation of a tagged literal from a\n *   tag symbol and a form.\n */\ncljs.core.tagged_literal \x3d (function cljs$core$tagged_literal(tag,form){\nif((tag instanceof cljs.core.Symbol)){\n} else {\nthrow (new Error(\x22Assert failed: (symbol? tag)\x22));\n}\n\nreturn (new cljs.core.TaggedLiteral(tag,form));\n});\n/**\n * @type {*}\n */\ncljs.core.js_reserved_arr \x3d [\x22arguments\x22,\x22abstract\x22,\x22await\x22,\x22boolean\x22,\x22break\x22,\x22byte\x22,\x22case\x22,\x22catch\x22,\x22char\x22,\x22class\x22,\x22const\x22,\x22continue\x22,\x22debugger\x22,\x22default\x22,\x22delete\x22,\x22do\x22,\x22double\x22,\x22else\x22,\x22enum\x22,\x22export\x22,\x22extends\x22,\x22final\x22,\x22finally\x22,\x22float\x22,\x22for\x22,\x22function\x22,\x22goto\x22,\x22if\x22,\x22implements\x22,\x22import\x22,\x22in\x22,\x22instanceof\x22,\x22int\x22,\x22interface\x22,\x22let\x22,\x22long\x22,\x22native\x22,\x22new\x22,\x22package\x22,\x22private\x22,\x22protected\x22,\x22public\x22,\x22return\x22,\x22short\x22,\x22static\x22,\x22super\x22,\x22switch\x22,\x22synchronized\x22,\x22this\x22,\x22throw\x22,\x22throws\x22,\x22transient\x22,\x22try\x22,\x22typeof\x22,\x22var\x22,\x22void\x22,\x22volatile\x22,\x22while\x22,\x22with\x22,\x22yield\x22,\x22methods\x22,\x22null\x22,\x22constructor\x22];\n/**\n * @type {null|Object}\n */\ncljs.core.js_reserved \x3d null;\ncljs.core.js_reserved_QMARK_ \x3d (function cljs$core$js_reserved_QMARK_(x){\nif((cljs.core.js_reserved \x3d\x3d null)){\n(cljs.core.js_reserved \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19694_SHARP_,p2__19695_SHARP_){\ncljs.core.goog$module$goog$object.set(p1__19694_SHARP_,p2__19695_SHARP_,true);\n\nreturn p1__19694_SHARP_;\n}),({}),cljs.core.js_reserved_arr));\n} else {\n}\n\nreturn cljs.core.js_reserved.hasOwnProperty(x);\n});\ncljs.core.demunge_pattern \x3d (function cljs$core$demunge_pattern(){\nif(cljs.core.truth_(cljs.core.DEMUNGE_PATTERN)){\n} else {\n(cljs.core.DEMUNGE_PATTERN \x3d (function (){var ks \x3d cljs.core.sort.cljs$core$IFn$_invoke$arity$2((function (a,b){\nreturn (b.length - a.length);\n}),cljs.core.js_keys(cljs.core.DEMUNGE_MAP));\nvar ks__$1 \x3d ks;\nvar ret \x3d \x22\x22;\nwhile(true){\nif(cljs.core.seq(ks__$1)){\nvar G__27516 \x3d cljs.core.next(ks__$1);\nvar G__27517 \x3d [(function (){var G__19699 \x3d ret;\nif((!((ret \x3d\x3d\x3d \x22\x22)))){\nreturn [G__19699,\x22|\x22].join(\x27\x27);\n} else {\nreturn G__19699;\n}\n})(),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(ks__$1))].join(\x27\x27);\nks__$1 \x3d G__27516;\nret \x3d G__27517;\ncontinue;\n} else {\nreturn [ret,\x22|\\\\$\x22].join(\x27\x27);\n}\nbreak;\n}\n})());\n}\n\nreturn cljs.core.DEMUNGE_PATTERN;\n});\ncljs.core.munge_str \x3d (function cljs$core$munge_str(name){\nvar sb \x3d (new goog.string.StringBuffer());\nvar i_27518 \x3d (0);\nwhile(true){\nif((i_27518 \x3c name.length)){\nvar c_27522 \x3d name.charAt(i_27518);\nvar sub_27523 \x3d cljs.core.goog$module$goog$object.get(cljs.core.CHAR_MAP,c_27522);\nif((!((sub_27523 \x3d\x3d null)))){\nsb.append(sub_27523);\n} else {\nsb.append(c_27522);\n}\n\nvar G__27524 \x3d (i_27518 + (1));\ni_27518 \x3d G__27524;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn sb.toString();\n});\ncljs.core.munge \x3d (function cljs$core$munge(name){\nvar name_SINGLEQUOTE_ \x3d cljs.core.munge_str(cljs.core.str.cljs$core$IFn$_invoke$arity$1(name));\nvar name_SINGLEQUOTE___$1 \x3d (((name_SINGLEQUOTE_ \x3d\x3d\x3d \x22..\x22))?\x22_DOT__DOT_\x22:(cljs.core.truth_(cljs.core.js_reserved_QMARK_(name_SINGLEQUOTE_))?[name_SINGLEQUOTE_,\x22$\x22].join(\x27\x27):name_SINGLEQUOTE_\n));\nif((name instanceof cljs.core.Symbol)){\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(name_SINGLEQUOTE___$1);\n} else {\nreturn name_SINGLEQUOTE___$1;\n}\n});\ncljs.core.demunge_str \x3d (function cljs$core$demunge_str(munged_name){\nvar r \x3d (new RegExp(cljs.core.demunge_pattern(),\x22g\x22));\nvar munged_name__$1 \x3d (cljs.core.truth_(goog.string.endsWith(munged_name,\x22$\x22))?munged_name.substring((0),(munged_name.length - (1))):munged_name);\nvar ret \x3d \x22\x22;\nvar last_match_end \x3d (0);\nwhile(true){\nvar temp__5802__auto__ \x3d r.exec(munged_name__$1);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar match \x3d temp__5802__auto__;\nvar vec__19703 \x3d match;\nvar x \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19703,(0),null);\nvar G__27526 \x3d [ret,cljs.core.str.cljs$core$IFn$_invoke$arity$1(munged_name__$1.substring(last_match_end,(r.lastIndex - x.length))),cljs.core.str.cljs$core$IFn$_invoke$arity$1((((x \x3d\x3d\x3d \x22$\x22))?\x22/\x22:cljs.core.goog$module$goog$object.get(cljs.core.DEMUNGE_MAP,x)))].join(\x27\x27);\nvar G__27527 \x3d r.lastIndex;\nret \x3d G__27526;\nlast_match_end \x3d G__27527;\ncontinue;\n} else {\nreturn [ret,cljs.core.str.cljs$core$IFn$_invoke$arity$1(munged_name__$1.substring(last_match_end,munged_name__$1.length))].join(\x27\x27);\n}\nbreak;\n}\n});\ncljs.core.demunge \x3d (function cljs$core$demunge(name){\nvar G__19707 \x3d (function (){var name_SINGLEQUOTE_ \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(name);\nif((name_SINGLEQUOTE_ \x3d\x3d\x3d \x22_DOT__DOT_\x22)){\nreturn \x22..\x22;\n} else {\nreturn cljs.core.demunge_str(name_SINGLEQUOTE_);\n}\n})();\nvar fexpr__19706 \x3d (((name instanceof cljs.core.Symbol))?cljs.core.symbol:cljs.core.str);\nreturn (fexpr__19706.cljs$core$IFn$_invoke$arity$1 ? fexpr__19706.cljs$core$IFn$_invoke$arity$1(G__19707) : fexpr__19706.call(null, G__19707));\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.tapset !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * @type {*}\n */\ncljs.core.tapset \x3d null;\n}\ncljs.core.maybe_init_tapset \x3d (function cljs$core$maybe_init_tapset(){\nif((cljs.core.tapset \x3d\x3d null)){\nreturn (cljs.core.tapset \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentHashSet.EMPTY));\n} else {\nreturn null;\n}\n});\n/**\n * Adds f, a fn of one argument, to the tap set. This function will be called with\n *   anything sent via tap\x3e. Remember f in order to remove-tap\n */\ncljs.core.add_tap \x3d (function cljs$core$add_tap(f){\ncljs.core.maybe_init_tapset();\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(cljs.core.tapset,cljs.core.conj,f);\n\nreturn null;\n});\n/**\n * Remove f from the tap set.\n */\ncljs.core.remove_tap \x3d (function cljs$core$remove_tap(f){\ncljs.core.maybe_init_tapset();\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(cljs.core.tapset,cljs.core.disj,f);\n\nreturn null;\n});\n/**\n * Sends x to any taps. Returns the result of *exec-tap-fn*, a Boolean value.\n */\ncljs.core.tap_GT_ \x3d (function cljs$core$tap_GT_(x){\ncljs.core.maybe_init_tapset();\n\nreturn cljs.core._STAR_exec_tap_fn_STAR_.call(null, (function (){\nvar seq__19708 \x3d cljs.core.seq(cljs.core.deref(cljs.core.tapset));\nvar chunk__19709 \x3d null;\nvar count__19710 \x3d (0);\nvar i__19711 \x3d (0);\nwhile(true){\nif((i__19711 \x3c count__19710)){\nvar tap \x3d chunk__19709.cljs$core$IIndexed$_nth$arity$2(null, i__19711);\ntry{(tap.cljs$core$IFn$_invoke$arity$1 ? tap.cljs$core$IFn$_invoke$arity$1(x) : tap.call(null, x));\n}catch (e19714){if((e19714 instanceof Error)){\nvar ex_27532 \x3d e19714;\n} else {\nthrow e19714;\n\n}\n}\n\nvar G__27533 \x3d seq__19708;\nvar G__27534 \x3d chunk__19709;\nvar G__27535 \x3d count__19710;\nvar G__27536 \x3d (i__19711 + (1));\nseq__19708 \x3d G__27533;\nchunk__19709 \x3d G__27534;\ncount__19710 \x3d G__27535;\ni__19711 \x3d G__27536;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__19708);\nif(temp__5804__auto__){\nvar seq__19708__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__19708__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__19708__$1);\nvar G__27538 \x3d cljs.core.chunk_rest(seq__19708__$1);\nvar G__27539 \x3d c__5525__auto__;\nvar G__27540 \x3d cljs.core.count(c__5525__auto__);\nvar G__27541 \x3d (0);\nseq__19708 \x3d G__27538;\nchunk__19709 \x3d G__27539;\ncount__19710 \x3d G__27540;\ni__19711 \x3d G__27541;\ncontinue;\n} else {\nvar tap \x3d cljs.core.first(seq__19708__$1);\ntry{(tap.cljs$core$IFn$_invoke$arity$1 ? tap.cljs$core$IFn$_invoke$arity$1(x) : tap.call(null, x));\n}catch (e19715){if((e19715 instanceof Error)){\nvar ex_27542 \x3d e19715;\n} else {\nthrow e19715;\n\n}\n}\n\nvar G__27543 \x3d cljs.core.next(seq__19708__$1);\nvar G__27544 \x3d null;\nvar G__27545 \x3d (0);\nvar G__27546 \x3d (0);\nseq__19708 \x3d G__27543;\nchunk__19709 \x3d G__27544;\ncount__19710 \x3d G__27545;\ni__19711 \x3d G__27546;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n});\n/**\n * m f \x3d\x3e {k (f v) ...}\n *   Given a map m and a function f of 1-argument, returns a new map where the keys of m\n *   are mapped to result of applying f to the corresponding values of m.\n */\ncljs.core.update_vals \x3d (function cljs$core$update_vals(m,f){\nreturn cljs.core.with_meta(cljs.core.persistent_BANG_(cljs.core.reduce_kv((function (acc,k,v){\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(acc,k,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(v) : f.call(null, v)));\n}),(((((!((m \x3d\x3d null))))?(((((m.cljs$lang$protocol_mask$partition1$ \x26 (4))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d m.cljs$core$IEditableCollection$))))?true:false):false))?cljs.core.transient$(m):cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY)),m)),cljs.core.meta(m));\n});\n/**\n * m f \x3d\x3e {(f k) v ...}\n *   Given a map m and a function f of 1-argument, returns a new map whose\n *   keys are the result of applying f to the keys of m, mapped to the\n *   corresponding values of m.\n *   f must return a unique key for each key of m, else the behavior is undefined.\n */\ncljs.core.update_keys \x3d (function cljs$core$update_keys(m,f){\nvar ret \x3d cljs.core.persistent_BANG_(cljs.core.reduce_kv((function (acc,k,v){\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(acc,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(k) : f.call(null, k)),v);\n}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),m));\nreturn cljs.core.with_meta(ret,cljs.core.meta(m));\n});\n/**\n * Bootstrap only.\n */\ncljs.core.ns_lookup \x3d (function cljs$core$ns_lookup(ns_obj,k){\nreturn (function (){\nreturn cljs.core.goog$module$goog$object.get(ns_obj,k);\n});\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n*/\ncljs.core.Namespace \x3d (function (obj,name){\nthis.obj \x3d obj;\nthis.name \x3d name;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 6291456;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.Namespace.prototype.findInternedVar \x3d (function (sym){\nvar self__ \x3d this;\nvar this$ \x3d this;\nvar k \x3d cljs.core.munge(cljs.core.str.cljs$core$IFn$_invoke$arity$1(sym));\nif(cljs.core.goog$module$goog$object.containsKey(self__.obj,k)){\nvar var_sym \x3d cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.name),cljs.core.str.cljs$core$IFn$_invoke$arity$1(sym));\nvar var_meta \x3d new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),this$], null);\nreturn (new cljs.core.Var(cljs.core.ns_lookup(self__.obj,k),var_sym,var_meta));\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.Namespace.prototype.getName \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn self__.name;\n}));\n\n(cljs.core.Namespace.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.name);\n}));\n\n(cljs.core.Namespace.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (_,other){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((other instanceof cljs.core.Namespace)){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.name,other.name);\n} else {\nreturn false;\n}\n}));\n\n(cljs.core.Namespace.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.hash(self__.name);\n}));\n\n(cljs.core.Namespace.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22obj\x22,\x22obj\x22,-1672671807,null),new cljs.core.Symbol(null,\x22name\x22,\x22name\x22,-810760592,null)], null);\n}));\n\n(cljs.core.Namespace.cljs$lang$type \x3d true);\n\n(cljs.core.Namespace.cljs$lang$ctorStr \x3d \x22cljs.core/Namespace\x22);\n\n(cljs.core.Namespace.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core/Namespace\x22);\n}));\n\n/**\n * Positional factory function for cljs.core/Namespace.\n */\ncljs.core.__GT_Namespace \x3d (function cljs$core$__GT_Namespace(obj,name){\nreturn (new cljs.core.Namespace(obj,name));\n});\n\n/**\n * Bootstrap only.\n * @type {*}\n */\ncljs.core.NS_CACHE \x3d null;\n/**\n * Bootstrap only.\n */\ncljs.core.find_ns_obj_STAR_ \x3d (function cljs$core$find_ns_obj_STAR_(ctxt,xs){\nwhile(true){\nif((ctxt \x3d\x3d null)){\nreturn null;\n} else {\nif((xs \x3d\x3d null)){\nreturn ctxt;\n} else {\nvar G__27562 \x3d cljs.core.goog$module$goog$object.get(ctxt,cljs.core.first(xs));\nvar G__27563 \x3d cljs.core.next(xs);\nctxt \x3d G__27562;\nxs \x3d G__27563;\ncontinue;\n\n}\n}\nbreak;\n}\n});\n/**\n * Bootstrap only.\n */\ncljs.core.find_ns_obj \x3d (function cljs$core$find_ns_obj(ns){\nvar munged_ns \x3d cljs.core.munge(cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns));\nvar segs \x3d munged_ns.split(\x22.\x22);\nvar G__19717 \x3d cljs.core._STAR_target_STAR_;\nswitch (G__19717) {\ncase \x22nodejs\x22:\nif(COMPILED){\nreturn cljs.core.find_ns_obj_STAR_((function (){try{var ctxt \x3d eval(cljs.core.first(segs));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d ctxt;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.object_QMARK_(ctxt);\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn ctxt;\n} else {\nreturn null;\n}\n}catch (e19718){if((e19718 instanceof ReferenceError)){\nvar e \x3d e19718;\nreturn null;\n} else {\nthrow e19718;\n\n}\n}})(),cljs.core.next(segs));\n} else {\nreturn cljs.core.find_ns_obj_STAR_(goog.global,segs);\n}\n\nbreak;\ncase \x22default\x22:\ncase \x22webworker\x22:\nreturn cljs.core.find_ns_obj_STAR_(goog.global,segs);\n\nbreak;\ndefault:\nthrow (new Error([\x22find-ns-obj not supported for target \x22,cljs.core._STAR_target_STAR_].join(\x27\x27)));\n\n}\n});\n/**\n * Returns a map of the intern mappings for the namespace.\n *   Bootstrap only.\n */\ncljs.core.ns_interns_STAR_ \x3d (function cljs$core$ns_interns_STAR_(sym){\nvar ns_obj \x3d cljs.core.find_ns_obj(sym);\nvar ns \x3d (new cljs.core.Namespace(ns_obj,sym));\nvar step \x3d (function cljs$core$ns_interns_STAR__$_step(ret,k){\nvar var_sym \x3d cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.demunge(k));\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,var_sym,(new cljs.core.Var((function (){\nreturn cljs.core.goog$module$goog$object.get(ns_obj,k);\n}),cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(cljs.core.str.cljs$core$IFn$_invoke$arity$1(sym),cljs.core.str.cljs$core$IFn$_invoke$arity$1(var_sym)),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),ns], null))));\n});\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(step,cljs.core.PersistentArrayMap.EMPTY,cljs.core.js_keys(ns_obj));\n});\n/**\n * Create a new namespace named by the symbol. Bootstrap only.\n */\ncljs.core.create_ns \x3d (function cljs$core$create_ns(var_args){\nvar G__19720 \x3d arguments.length;\nswitch (G__19720) {\ncase 1:\nreturn cljs.core.create_ns.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.create_ns.cljs$core$IFn$_invoke$arity$1 \x3d (function (sym){\nreturn cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2(sym,cljs.core.find_ns_obj(sym));\n}));\n\n(cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2 \x3d (function (sym,ns_obj){\nreturn (new cljs.core.Namespace(ns_obj,sym));\n}));\n\n(cljs.core.create_ns.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns the namespace named by the symbol or nil if it doesn\x27t exist.\n *   Bootstrap only.\n */\ncljs.core.find_ns \x3d (function cljs$core$find_ns(ns){\nif((cljs.core.NS_CACHE \x3d\x3d null)){\n(cljs.core.NS_CACHE \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY));\n} else {\n}\n\nvar the_ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.NS_CACHE),ns);\nif((!((the_ns \x3d\x3d null)))){\nreturn the_ns;\n} else {\nvar ns_obj \x3d cljs.core.find_ns_obj(ns);\nif((ns_obj \x3d\x3d null)){\nreturn null;\n} else {\nvar new_ns \x3d cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2(ns,ns_obj);\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.NS_CACHE,cljs.core.assoc,ns,new_ns);\n\nreturn new_ns;\n}\n}\n});\n/**\n * Returns the macros namespace named by the symbol or nil if it doesn\x27t exist.\n *   Bootstrap only.\n */\ncljs.core.find_macros_ns \x3d (function cljs$core$find_macros_ns(ns){\nif((cljs.core.NS_CACHE \x3d\x3d null)){\n(cljs.core.NS_CACHE \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY));\n} else {\n}\n\nvar ns_str \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns);\nvar ns__$1 \x3d (((!(goog.string.contains(ns_str,\x22$macros\x22))))?cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([ns_str,\x22$macros\x22].join(\x27\x27)):ns);\nvar the_ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.NS_CACHE),ns__$1);\nif((!((the_ns \x3d\x3d null)))){\nreturn the_ns;\n} else {\nvar ns_obj \x3d cljs.core.find_ns_obj(ns__$1);\nif((ns_obj \x3d\x3d null)){\nreturn null;\n} else {\nvar new_ns \x3d cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2(ns__$1,ns_obj);\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.NS_CACHE,cljs.core.assoc,ns__$1,new_ns);\n\nreturn new_ns;\n}\n}\n});\n/**\n * Returns the name of the namespace, a Namespace object.\n *   Bootstrap only.\n */\ncljs.core.ns_name \x3d (function cljs$core$ns_name(ns_obj){\nreturn ns_obj.name;\n});\n/**\n * Returns true x is a goog.Uri instance.\n */\ncljs.core.uri_QMARK_ \x3d (function cljs$core$uri_QMARK_(x){\nreturn (x instanceof goog.Uri);\n});\n/**\n * Returns true if num is NaN, else false\n */\ncljs.core.NaN_QMARK_ \x3d (function cljs$core$NaN_QMARK_(val){\nreturn isNaN(val);\n});\n/**\n * Construct message for parsing for non-string parsing error\n */\ncljs.core.parsing_err \x3d (function cljs$core$parsing_err(val){\nreturn [\x22Expected string, got: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((((val \x3d\x3d null))?\x22nil\x22:goog.typeOf(val)))].join(\x27\x27);\n});\n/**\n * Parse string of decimal digits with optional leading -/+ and return an\n *   integer value, or nil if parse fails\n */\ncljs.core.parse_long \x3d (function cljs$core$parse_long(s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\nvar and__5000__auto__ \x3d cljs.core.re_matches(/[+-]?\\d+/,s);\nif(cljs.core.truth_(and__5000__auto__)){\nvar i \x3d parseInt(s);\nif((((i \x3c\x3d Number.MAX_SAFE_INTEGER)) \x26\x26 ((i \x3e\x3d Number.MIN_SAFE_INTEGER)))){\nreturn i;\n} else {\nreturn null;\n}\n} else {\nreturn and__5000__auto__;\n}\n} else {\nthrow (new Error(cljs.core.parsing_err(s)));\n}\n});\n/**\n * Parse string with floating point components and return a floating point value,\n *   or nil if parse fails.\n *   Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-\n */\ncljs.core.parse_double \x3d (function cljs$core$parse_double(s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\nif(cljs.core.re_matches(/[\\x00-\\x20]*[+-]?NaN[\\x00-\\x20]*/,s)){\nreturn NaN;\n} else {\nif(cljs.core.re_matches(/[\\x00-\\x20]*[+-]?(Infinity|((\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?)[dDfF]?)[\\x00-\\x20]*/,s)){\nreturn parseFloat(s);\n} else {\nreturn null;\n\n}\n}\n} else {\nthrow (new Error(cljs.core.parsing_err(s)));\n}\n});\ncljs.core.uuid_regex \x3d /^[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]-[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]$/;\n/**\n * Parse a string representing a UUID and return a UUID instance,\n *   or nil if parse fails.\n *   Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--\n */\ncljs.core.parse_uuid \x3d (function cljs$core$parse_uuid(s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\nif(cljs.core.re_matches(cljs.core.uuid_regex,s)){\nreturn cljs.core.uuid(s);\n} else {\nreturn null;\n}\n} else {\nthrow (new Error(cljs.core.parsing_err(s)));\n}\n});\n/**\n * Parse strings \x22true\x22 or \x22false\x22 and return a boolean, or nil if invalid. Note that this explicitly\n *   excludes strings with different cases, or space characters.\n */\ncljs.core.parse_boolean \x3d (function cljs$core$parse_boolean(s){\nif(typeof s \x3d\x3d\x3d \x27string\x27){\nvar G__19721 \x3d s;\nswitch (G__19721) {\ncase \x22true\x22:\nreturn true;\n\nbreak;\ncase \x22false\x22:\nreturn false;\n\nbreak;\ndefault:\nreturn null;\n\n}\n} else {\nthrow (new Error(cljs.core.parsing_err(s)));\n}\n});\ncljs.core.maybe_enable_print_BANG_ \x3d (function cljs$core$maybe_enable_print_BANG_(){\nif((typeof console !\x3d\x3d \x27undefined\x27)){\nreturn cljs.core.enable_console_print_BANG_();\n} else {\nif((((cljs.core._STAR_target_STAR_ \x3d\x3d\x3d \x22nashorn\x22)) || ((cljs.core._STAR_target_STAR_ \x3d\x3d\x3d \x22graaljs\x22)))){\nvar system \x3d Java.type(\x22java.lang.System\x22);\n(cljs.core._STAR_print_newline_STAR_ \x3d false);\n\ncljs.core.set_print_fn_BANG_((function (){\nvar xs \x3d arguments;\nvar s \x3d cljs.core.goog$module$goog$array.clone(xs).join(\x22\x22);\nreturn system.out.println(s);\n}));\n\nreturn cljs.core.set_print_err_fn_BANG_((function (){\nvar xs \x3d arguments;\nvar s \x3d cljs.core.goog$module$goog$array.clone(xs).join(\x22\x22);\nreturn system.error.println(s);\n}));\n} else {\nreturn null;\n}\n}\n});\ncljs.core.maybe_enable_print_BANG_();\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core._STAR_eval_STAR_ !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * Runtime environments may provide a way to evaluate ClojureScript\n *   forms. Whatever function *eval* is bound to will be passed any forms which\n *   should be evaluated.\n */\ncljs.core._STAR_eval_STAR_ \x3d (function cljs$core$_STAR_eval_STAR_(_){\nthrow (new Error(\x22cljs.core/*eval* not bound\x22));\n});\n}\n/**\n * Evaluates the form data structure (not text!) and returns the result.\n *   Delegates to cljs.core/*eval*. Intended for use in self-hosted ClojureScript,\n *   which sets up an implementation of cljs.core/*eval* for that environment.\n */\ncljs.core.eval \x3d (function cljs$core$eval(form){\nreturn cljs.core._STAR_eval_STAR_.call(null, form);\n});\nif(COMPILED){\nif((\x22nodejs\x22 \x3d\x3d\x3d cljs.core._STAR_target_STAR_)){\n(goog.global \x3d global);\n} else {\n}\n\nif((\x22window\x22 \x3d\x3d\x3d cljs.core._STAR_global_STAR_)){\n(goog.global \x3d window);\n} else {\nif((\x22self\x22 \x3d\x3d\x3d cljs.core._STAR_global_STAR_)){\n(goog.global \x3d self);\n} else {\nif((\x22global\x22 \x3d\x3d\x3d cljs.core._STAR_global_STAR_)){\n(goog.global \x3d global);\n} else {\n}\n}\n}\n} else {\n}\n\ncljs.core.enable_console_print_BANG_();\n");
SHADOW_ENV.evalLoad("clojure.string.js", true, "goog.provide(\x27clojure.string\x27);\nclojure.string.seq_reverse \x3d (function clojure$string$seq_reverse(coll){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,cljs.core.List.EMPTY,coll);\n});\nclojure.string.re_surrogate_pair \x3d (new RegExp(\x22([\\\\uD800-\\\\uDBFF])([\\\\uDC00-\\\\uDFFF])\x22,\x22g\x22));\n/**\n * Returns s with its characters reversed.\n */\nclojure.string.reverse \x3d (function clojure$string$reverse(s){\nreturn s.replace(clojure.string.re_surrogate_pair,\x22$2$1\x22).split(\x22\x22).reverse().join(\x22\x22);\n});\nclojure.string.replace_all \x3d (function clojure$string$replace_all(s,re,replacement){\nvar r \x3d (new RegExp(re.source,(function (){var G__19782 \x3d \x22g\x22;\nvar G__19782__$1 \x3d (cljs.core.truth_(re.ignoreCase)?[G__19782,\x22i\x22].join(\x27\x27):G__19782);\nvar G__19782__$2 \x3d (cljs.core.truth_(re.multiline)?[G__19782__$1,\x22m\x22].join(\x27\x27):G__19782__$1);\nif(cljs.core.truth_(re.unicode)){\nreturn [G__19782__$2,\x22u\x22].join(\x27\x27);\n} else {\nreturn G__19782__$2;\n}\n})()));\nreturn s.replace(r,replacement);\n});\nclojure.string.replace_with \x3d (function clojure$string$replace_with(f){\nreturn (function() { \nvar G__19960__delegate \x3d function (args){\nvar matches \x3d cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2((2),args);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(matches),(1))){\nvar G__19786 \x3d cljs.core.first(matches);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__19786) : f.call(null, G__19786));\n} else {\nvar G__19787 \x3d cljs.core.vec(matches);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__19787) : f.call(null, G__19787));\n}\n};\nvar G__19960 \x3d function (var_args){\nvar args \x3d null;\nif (arguments.length \x3e 0) {\nvar G__19967__i \x3d 0, G__19967__a \x3d new Array(arguments.length -  0);\nwhile (G__19967__i \x3c G__19967__a.length) {G__19967__a[G__19967__i] \x3d arguments[G__19967__i + 0]; ++G__19967__i;}\n  args \x3d new cljs.core.IndexedSeq(G__19967__a,0,null);\n} \nreturn G__19960__delegate.call(this,args);};\nG__19960.cljs$lang$maxFixedArity \x3d 0;\nG__19960.cljs$lang$applyTo \x3d (function (arglist__19968){\nvar args \x3d cljs.core.seq(arglist__19968);\nreturn G__19960__delegate(args);\n});\nG__19960.cljs$core$IFn$_invoke$arity$variadic \x3d G__19960__delegate;\nreturn G__19960;\n})()\n;\n});\n/**\n * Replaces all instance of match with replacement in s.\n * \n * match/replacement can be:\n * \n * string / string\n * pattern / (string or function of match).\n * \n * See also replace-first.\n * \n * The replacement is literal (i.e. none of its characters are treated\n * specially) for all cases above except pattern / string.\n * \n * For pattern / string, $1, $2, etc. in the replacement string are\n * substituted with the string that matched the corresponding\n * parenthesized group in the pattern.\n * \n * Example:\n * (clojure.string/replace \x22Almost Pig Latin\x22 #\x22\\b(\\w)(\\w+)\\b\x22 \x22$2$1ay\x22)\n * -\x3e \x22lmostAay igPay atinLay\x22\n */\nclojure.string.replace \x3d (function clojure$string$replace(s,match,replacement){\nif(typeof match \x3d\x3d\x3d \x27string\x27){\nreturn s.replace((new RegExp(goog.string.regExpEscape(match),\x22g\x22)),replacement);\n} else {\nif((match instanceof RegExp)){\nif(typeof replacement \x3d\x3d\x3d \x27string\x27){\nreturn clojure.string.replace_all(s,match,replacement);\n} else {\nreturn clojure.string.replace_all(s,match,clojure.string.replace_with(replacement));\n}\n} else {\nthrow [\x22Invalid match arg: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(match)].join(\x27\x27);\n\n}\n}\n});\n/**\n * Replaces the first instance of match with replacement in s.\n * \n * match/replacement can be:\n * \n * string / string\n * pattern / (string or function of match).\n * \n * See also replace.\n * \n * The replacement is literal (i.e. none of its characters are treated\n * specially) for all cases above except pattern / string.\n * \n * For pattern / string, $1, $2, etc. in the replacement string are\n * substituted with the string that matched the corresponding\n * parenthesized group in the pattern.\n * \n * Example:\n * (clojure.string/replace-first \x22swap first two words\x22\n *                               #\x22(\\w+)(\\s+)(\\w+)\x22 \x22$3$2$1\x22)\n * -\x3e \x22first swap two words\x22\n */\nclojure.string.replace_first \x3d (function clojure$string$replace_first(s,match,replacement){\nreturn s.replace(match,replacement);\n});\n/**\n * Returns a string of all elements in coll, as returned by (seq coll),\n *   separated by an optional separator.\n */\nclojure.string.join \x3d (function clojure$string$join(var_args){\nvar G__19799 \x3d arguments.length;\nswitch (G__19799) {\ncase 1:\nreturn clojure.string.join.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn clojure.string.join.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(clojure.string.join.cljs$core$IFn$_invoke$arity$1 \x3d (function (coll){\nvar sb \x3d (new goog.string.StringBuffer());\nvar coll__$1 \x3d cljs.core.seq(coll);\nwhile(true){\nif((!((coll__$1 \x3d\x3d null)))){\nvar G__19995 \x3d sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(coll__$1)));\nvar G__19996 \x3d cljs.core.next(coll__$1);\nsb \x3d G__19995;\ncoll__$1 \x3d G__19996;\ncontinue;\n} else {\nreturn sb.toString();\n}\nbreak;\n}\n}));\n\n(clojure.string.join.cljs$core$IFn$_invoke$arity$2 \x3d (function (separator,coll){\nvar sb \x3d (new goog.string.StringBuffer());\nvar coll__$1 \x3d cljs.core.seq(coll);\nwhile(true){\nif((!((coll__$1 \x3d\x3d null)))){\nsb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(coll__$1)));\n\nvar coll__$2 \x3d cljs.core.next(coll__$1);\nif((coll__$2 \x3d\x3d null)){\n} else {\nsb.append(separator);\n}\n\nvar G__20004 \x3d sb;\nvar G__20005 \x3d coll__$2;\nsb \x3d G__20004;\ncoll__$1 \x3d G__20005;\ncontinue;\n} else {\nreturn sb.toString();\n}\nbreak;\n}\n}));\n\n(clojure.string.join.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Converts string to all upper-case.\n */\nclojure.string.upper_case \x3d (function clojure$string$upper_case(s){\nreturn s.toUpperCase();\n});\n/**\n * Converts string to all lower-case.\n */\nclojure.string.lower_case \x3d (function clojure$string$lower_case(s){\nreturn s.toLowerCase();\n});\n/**\n * Converts first character of the string to upper-case, all other\n *   characters to lower-case.\n */\nclojure.string.capitalize \x3d (function clojure$string$capitalize(s){\nreturn goog.string.capitalize(s);\n});\nclojure.string.pop_last_while_empty \x3d (function clojure$string$pop_last_while_empty(v){\nvar v__$1 \x3d v;\nwhile(true){\nif((\x22\x22 \x3d\x3d\x3d cljs.core.peek(v__$1))){\nvar G__20014 \x3d cljs.core.pop(v__$1);\nv__$1 \x3d G__20014;\ncontinue;\n} else {\nreturn v__$1;\n}\nbreak;\n}\n});\nclojure.string.discard_trailing_if_needed \x3d (function clojure$string$discard_trailing_if_needed(limit,v){\nif(((((0) \x3d\x3d\x3d limit)) \x26\x26 (((1) \x3c cljs.core.count(v))))){\nreturn clojure.string.pop_last_while_empty(v);\n} else {\nreturn v;\n}\n});\nclojure.string.split_with_empty_regex \x3d (function clojure$string$split_with_empty_regex(s,limit){\nif((((limit \x3c\x3d (0))) || ((limit \x3e\x3d ((2) + cljs.core.count(s)))))){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.vec(cljs.core.cons(\x22\x22,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.seq(s)))),\x22\x22);\n} else {\nvar pred__19821 \x3d cljs.core._EQ__EQ_;\nvar expr__19822 \x3d limit;\nif(cljs.core.truth_((pred__19821.cljs$core$IFn$_invoke$arity$2 ? pred__19821.cljs$core$IFn$_invoke$arity$2((1),expr__19822) : pred__19821.call(null, (1),expr__19822)))){\nreturn (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[s],null));\n} else {\nif(cljs.core.truth_((pred__19821.cljs$core$IFn$_invoke$arity$2 ? pred__19821.cljs$core$IFn$_invoke$arity$2((2),expr__19822) : pred__19821.call(null, (2),expr__19822)))){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[\x22\x22,s],null));\n} else {\nvar c \x3d (limit - (2));\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.vec(cljs.core.cons(\x22\x22,cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.seq(s))),(0),c))),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,c));\n}\n}\n}\n});\n/**\n * Splits string on a regular expression. Optional argument limit is\n *   the maximum number of parts. Not lazy. Returns vector of the parts.\n *   Trailing empty strings are not returned - pass limit of -1 to return all.\n */\nclojure.string.split \x3d (function clojure$string$split(var_args){\nvar G__19835 \x3d arguments.length;\nswitch (G__19835) {\ncase 2:\nreturn clojure.string.split.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn clojure.string.split.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(clojure.string.split.cljs$core$IFn$_invoke$arity$2 \x3d (function (s,re){\nreturn clojure.string.split.cljs$core$IFn$_invoke$arity$3(s,re,(0));\n}));\n\n(clojure.string.split.cljs$core$IFn$_invoke$arity$3 \x3d (function (s,re,limit){\nreturn clojure.string.discard_trailing_if_needed(limit,(((\x22/(?:)/\x22 \x3d\x3d\x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(re)))?clojure.string.split_with_empty_regex(s,limit):(((limit \x3c (1)))?cljs.core.vec(cljs.core.str.cljs$core$IFn$_invoke$arity$1(s).split(re)):(function (){var s__$1 \x3d s;\nvar limit__$1 \x3d limit;\nvar parts \x3d cljs.core.PersistentVector.EMPTY;\nwhile(true){\nif(((1) \x3d\x3d\x3d limit__$1)){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(parts,s__$1);\n} else {\nvar m \x3d cljs.core.re_find(re,s__$1);\nif((!((m \x3d\x3d null)))){\nvar index \x3d s__$1.indexOf(m);\nvar G__20055 \x3d s__$1.substring((index + cljs.core.count(m)));\nvar G__20056 \x3d (limit__$1 - (1));\nvar G__20057 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(parts,s__$1.substring((0),index));\ns__$1 \x3d G__20055;\nlimit__$1 \x3d G__20056;\nparts \x3d G__20057;\ncontinue;\n} else {\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(parts,s__$1);\n}\n}\nbreak;\n}\n})())));\n}));\n\n(clojure.string.split.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Splits s on \\n or \\r\\n. Trailing empty lines are not returned.\n */\nclojure.string.split_lines \x3d (function clojure$string$split_lines(s){\nreturn clojure.string.split.cljs$core$IFn$_invoke$arity$2(s,/\\n|\\r\\n/);\n});\n/**\n * Removes whitespace from both ends of string.\n */\nclojure.string.trim \x3d (function clojure$string$trim(s){\nreturn goog.string.trim(s);\n});\n/**\n * Removes whitespace from the left side of string.\n */\nclojure.string.triml \x3d (function clojure$string$triml(s){\nreturn goog.string.trimLeft(s);\n});\n/**\n * Removes whitespace from the right side of string.\n */\nclojure.string.trimr \x3d (function clojure$string$trimr(s){\nreturn goog.string.trimRight(s);\n});\n/**\n * Removes all trailing newline \\n or return \\r characters from\n *   string.  Similar to Perl\x27s chomp.\n */\nclojure.string.trim_newline \x3d (function clojure$string$trim_newline(s){\nvar index \x3d s.length;\nwhile(true){\nif((index \x3d\x3d\x3d (0))){\nreturn \x22\x22;\n} else {\nvar ch \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(s,(index - (1)));\nif((((\x22\\n\x22 \x3d\x3d\x3d ch)) || ((\x22\\r\x22 \x3d\x3d\x3d ch)))){\nvar G__20071 \x3d (index - (1));\nindex \x3d G__20071;\ncontinue;\n} else {\nreturn s.substring((0),index);\n}\n}\nbreak;\n}\n});\n/**\n * True if s is nil, empty, or contains only whitespace.\n */\nclojure.string.blank_QMARK_ \x3d (function clojure$string$blank_QMARK_(s){\nreturn goog.string.isEmptyOrWhitespace(goog.string.makeSafe(s));\n});\n/**\n * Return a new string, using cmap to escape each character ch\n * from s as follows:\n * \n * If (cmap ch) is nil, append ch to the new string.\n * If (cmap ch) is non-nil, append (str (cmap ch)) instead.\n */\nclojure.string.escape \x3d (function clojure$string$escape(s,cmap){\nvar buffer \x3d (new goog.string.StringBuffer());\nvar length \x3d s.length;\nvar index \x3d (0);\nwhile(true){\nif((length \x3d\x3d\x3d index)){\nreturn buffer.toString();\n} else {\nvar ch \x3d s.charAt(index);\nvar replacement \x3d (cmap.cljs$core$IFn$_invoke$arity$1 ? cmap.cljs$core$IFn$_invoke$arity$1(ch) : cmap.call(null, ch));\nif((!((replacement \x3d\x3d null)))){\nbuffer.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(replacement));\n} else {\nbuffer.append(ch);\n}\n\nvar G__20089 \x3d (index + (1));\nindex \x3d G__20089;\ncontinue;\n}\nbreak;\n}\n});\n/**\n * Return index of value (string or char) in s, optionally searching\n *   forward from from-index or nil if not found.\n */\nclojure.string.index_of \x3d (function clojure$string$index_of(var_args){\nvar G__19902 \x3d arguments.length;\nswitch (G__19902) {\ncase 2:\nreturn clojure.string.index_of.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn clojure.string.index_of.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(clojure.string.index_of.cljs$core$IFn$_invoke$arity$2 \x3d (function (s,value){\nvar result \x3d s.indexOf(value);\nif((result \x3c (0))){\nreturn null;\n} else {\nreturn result;\n}\n}));\n\n(clojure.string.index_of.cljs$core$IFn$_invoke$arity$3 \x3d (function (s,value,from_index){\nvar result \x3d s.indexOf(value,from_index);\nif((result \x3c (0))){\nreturn null;\n} else {\nreturn result;\n}\n}));\n\n(clojure.string.index_of.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Return last index of value (string or char) in s, optionally\n *   searching backward from from-index or nil if not found.\n */\nclojure.string.last_index_of \x3d (function clojure$string$last_index_of(var_args){\nvar G__19918 \x3d arguments.length;\nswitch (G__19918) {\ncase 2:\nreturn clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$2 \x3d (function (s,value){\nvar result \x3d s.lastIndexOf(value);\nif((result \x3c (0))){\nreturn null;\n} else {\nreturn result;\n}\n}));\n\n(clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$3 \x3d (function (s,value,from_index){\nvar result \x3d s.lastIndexOf(value,from_index);\nif((result \x3c (0))){\nreturn null;\n} else {\nreturn result;\n}\n}));\n\n(clojure.string.last_index_of.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * True if s starts with substr.\n */\nclojure.string.starts_with_QMARK_ \x3d (function clojure$string$starts_with_QMARK_(s,substr){\nreturn goog.string.startsWith(s,substr);\n});\n/**\n * True if s ends with substr.\n */\nclojure.string.ends_with_QMARK_ \x3d (function clojure$string$ends_with_QMARK_(s,substr){\nreturn goog.string.endsWith(s,substr);\n});\n/**\n * True if s includes substr.\n */\nclojure.string.includes_QMARK_ \x3d (function clojure$string$includes_QMARK_(s,substr){\nreturn goog.string.contains(s,substr);\n});\n");
SHADOW_ENV.evalLoad("shadow.cljs.devtools.client.console.js", true, "goog.provide(\x27shadow.cljs.devtools.client.console\x27);\nshadow.cljs.devtools.client.console.push_all \x3d (function shadow$cljs$devtools$client$console$push_all(arr,item){\nif(cljs.core.vector_QMARK_(item)){\nvar seq__21716 \x3d cljs.core.seq(item);\nvar chunk__21717 \x3d null;\nvar count__21718 \x3d (0);\nvar i__21719 \x3d (0);\nwhile(true){\nif((i__21719 \x3c count__21718)){\nvar it \x3d chunk__21717.cljs$core$IIndexed$_nth$arity$2(null, i__21719);\narr.push(it);\n\n\nvar G__22059 \x3d seq__21716;\nvar G__22060 \x3d chunk__21717;\nvar G__22061 \x3d count__21718;\nvar G__22062 \x3d (i__21719 + (1));\nseq__21716 \x3d G__22059;\nchunk__21717 \x3d G__22060;\ncount__21718 \x3d G__22061;\ni__21719 \x3d G__22062;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__21716);\nif(temp__5804__auto__){\nvar seq__21716__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__21716__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__21716__$1);\nvar G__22064 \x3d cljs.core.chunk_rest(seq__21716__$1);\nvar G__22065 \x3d c__5525__auto__;\nvar G__22066 \x3d cljs.core.count(c__5525__auto__);\nvar G__22067 \x3d (0);\nseq__21716 \x3d G__22064;\nchunk__21717 \x3d G__22065;\ncount__21718 \x3d G__22066;\ni__21719 \x3d G__22067;\ncontinue;\n} else {\nvar it \x3d cljs.core.first(seq__21716__$1);\narr.push(it);\n\n\nvar G__22072 \x3d cljs.core.next(seq__21716__$1);\nvar G__22073 \x3d null;\nvar G__22074 \x3d (0);\nvar G__22075 \x3d (0);\nseq__21716 \x3d G__22072;\nchunk__21717 \x3d G__22073;\ncount__21718 \x3d G__22074;\ni__21719 \x3d G__22075;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n} else {\nreturn arr.push(item);\n}\n});\nshadow.cljs.devtools.client.console.object_ref \x3d (function shadow$cljs$devtools$client$console$object_ref(obj){\nif((obj \x3d\x3d null)){\nreturn null;\n} else {\nreturn [\x22object\x22,({\x22object\x22: obj})];\n}\n});\nshadow.cljs.devtools.client.console.map__GT_style \x3d (function shadow$cljs$devtools$client$console$map__GT_style(m){\nreturn ({\x22style\x22: clojure.string.join.cljs$core$IFn$_invoke$arity$2(\x22\x22,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p__21740){\nvar vec__21741 \x3d p__21740;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21741,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21741,(1),null);\nreturn [cljs.core.name(k),\x22: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(v),\x22;\x22].join(\x27\x27);\n}),m))});\n});\nshadow.cljs.devtools.client.console.clj__GT_jsonml \x3d (function shadow$cljs$devtools$client$console$clj__GT_jsonml(struct){\nif((struct \x3d\x3d null)){\nreturn null;\n} else {\nif(cljs.core.array_QMARK_(struct)){\nreturn struct;\n} else {\nif(cljs.core.vector_QMARK_(struct)){\nvar vec__21759 \x3d struct;\nvar seq__21760 \x3d cljs.core.seq(vec__21759);\nvar first__21761 \x3d cljs.core.first(seq__21760);\nvar seq__21760__$1 \x3d cljs.core.next(seq__21760);\nvar tag \x3d first__21761;\nvar first__21761__$1 \x3d cljs.core.first(seq__21760__$1);\nvar seq__21760__$2 \x3d cljs.core.next(seq__21760__$1);\nvar attrs \x3d first__21761__$1;\nvar children \x3d seq__21760__$2;\nvar js \x3d [cljs.core.name(tag),shadow.cljs.devtools.client.console.map__GT_style(attrs)];\nvar seq__21769_22084 \x3d cljs.core.seq(children);\nvar chunk__21770_22085 \x3d null;\nvar count__21771_22086 \x3d (0);\nvar i__21772_22087 \x3d (0);\nwhile(true){\nif((i__21772_22087 \x3c count__21771_22086)){\nvar child_22088 \x3d chunk__21770_22085.cljs$core$IIndexed$_nth$arity$2(null, i__21772_22087);\nshadow.cljs.devtools.client.console.push_all(js,(shadow.cljs.devtools.client.console.clj__GT_jsonml.cljs$core$IFn$_invoke$arity$1 ? shadow.cljs.devtools.client.console.clj__GT_jsonml.cljs$core$IFn$_invoke$arity$1(child_22088) : shadow.cljs.devtools.client.console.clj__GT_jsonml.call(null, child_22088)));\n\n\nvar G__22089 \x3d seq__21769_22084;\nvar G__22090 \x3d chunk__21770_22085;\nvar G__22091 \x3d count__21771_22086;\nvar G__22092 \x3d (i__21772_22087 + (1));\nseq__21769_22084 \x3d G__22089;\nchunk__21770_22085 \x3d G__22090;\ncount__21771_22086 \x3d G__22091;\ni__21772_22087 \x3d G__22092;\ncontinue;\n} else {\nvar temp__5804__auto___22093 \x3d cljs.core.seq(seq__21769_22084);\nif(temp__5804__auto___22093){\nvar seq__21769_22094__$1 \x3d temp__5804__auto___22093;\nif(cljs.core.chunked_seq_QMARK_(seq__21769_22094__$1)){\nvar c__5525__auto___22095 \x3d cljs.core.chunk_first(seq__21769_22094__$1);\nvar G__22100 \x3d cljs.core.chunk_rest(seq__21769_22094__$1);\nvar G__22101 \x3d c__5525__auto___22095;\nvar G__22102 \x3d cljs.core.count(c__5525__auto___22095);\nvar G__22103 \x3d (0);\nseq__21769_22084 \x3d G__22100;\nchunk__21770_22085 \x3d G__22101;\ncount__21771_22086 \x3d G__22102;\ni__21772_22087 \x3d G__22103;\ncontinue;\n} else {\nvar child_22104 \x3d cljs.core.first(seq__21769_22094__$1);\nshadow.cljs.devtools.client.console.push_all(js,(shadow.cljs.devtools.client.console.clj__GT_jsonml.cljs$core$IFn$_invoke$arity$1 ? shadow.cljs.devtools.client.console.clj__GT_jsonml.cljs$core$IFn$_invoke$arity$1(child_22104) : shadow.cljs.devtools.client.console.clj__GT_jsonml.call(null, child_22104)));\n\n\nvar G__22108 \x3d cljs.core.next(seq__21769_22094__$1);\nvar G__22109 \x3d null;\nvar G__22110 \x3d (0);\nvar G__22111 \x3d (0);\nseq__21769_22084 \x3d G__22108;\nchunk__21770_22085 \x3d G__22109;\ncount__21771_22086 \x3d G__22110;\ni__21772_22087 \x3d G__22111;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn js;\n} else {\nif(typeof struct \x3d\x3d\x3d \x27string\x27){\nreturn struct;\n} else {\nif(typeof struct \x3d\x3d\x3d \x27number\x27){\nreturn struct;\n} else {\nif(cljs.core.seq_QMARK_(struct)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.console.clj__GT_jsonml),struct);\n} else {\nreturn shadow.cljs.devtools.client.console.object_ref(struct);\n\n}\n}\n}\n}\n}\n}\n});\n\n/**\n* @constructor\n*/\nshadow.cljs.devtools.client.console.SeqFormatter \x3d (function (){\n});\n(shadow.cljs.devtools.client.console.SeqFormatter.prototype.shadow$formatter \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn true;\n}));\n\n(shadow.cljs.devtools.client.console.SeqFormatter.prototype.header \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif(((cljs.core.sequential_QMARK_(obj)) || (cljs.core.set_QMARK_(obj)))){\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),cljs.core.PersistentArrayMap.EMPTY,[cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.type(obj)], 0)),\x22 [count: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.count(obj)),\x22]\x22].join(\x27\x27)], null));\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.console.SeqFormatter.prototype.hasBody \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn cljs.core.boolean$(cljs.core.seq(obj));\n}));\n\n(shadow.cljs.devtools.client.console.SeqFormatter.prototype.body \x3d (function (s){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22ol\x22,\x22ol\x22,932524051),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22margin\x22,\x22margin\x22,-995903681),(0)], null),(function (){var iter__5480__auto__ \x3d (function shadow$cljs$devtools$client$console$iter__21803(s__21804){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__21804__$1 \x3d s__21804;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__21804__$1);\nif(temp__5804__auto__){\nvar s__21804__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__21804__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__21804__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__21807 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__21806 \x3d (0);\nwhile(true){\nif((i__21806 \x3c size__5479__auto__)){\nvar value \x3d cljs.core._nth(c__5478__auto__,i__21806);\ncljs.core.chunk_append(b__21807,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22li\x22,\x22li\x22,723558921),cljs.core.PersistentArrayMap.EMPTY,shadow.cljs.devtools.client.console.object_ref(value)], null));\n\nvar G__22128 \x3d (i__21806 + (1));\ni__21806 \x3d G__22128;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21807),shadow$cljs$devtools$client$console$iter__21803(cljs.core.chunk_rest(s__21804__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21807),null);\n}\n} else {\nvar value \x3d cljs.core.first(s__21804__$2);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22li\x22,\x22li\x22,723558921),cljs.core.PersistentArrayMap.EMPTY,shadow.cljs.devtools.client.console.object_ref(value)], null),shadow$cljs$devtools$client$console$iter__21803(cljs.core.rest(s__21804__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(s);\n})()], null));\n}));\n\n(shadow.cljs.devtools.client.console.SeqFormatter.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(shadow.cljs.devtools.client.console.SeqFormatter.cljs$lang$type \x3d true);\n\n(shadow.cljs.devtools.client.console.SeqFormatter.cljs$lang$ctorStr \x3d \x22shadow.cljs.devtools.client.console/SeqFormatter\x22);\n\n(shadow.cljs.devtools.client.console.SeqFormatter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.cljs.devtools.client.console/SeqFormatter\x22);\n}));\n\n/**\n * Positional factory function for shadow.cljs.devtools.client.console/SeqFormatter.\n */\nshadow.cljs.devtools.client.console.__GT_SeqFormatter \x3d (function shadow$cljs$devtools$client$console$__GT_SeqFormatter(){\nreturn (new shadow.cljs.devtools.client.console.SeqFormatter());\n});\n\n\n/**\n* @constructor\n*/\nshadow.cljs.devtools.client.console.MapFormatter \x3d (function (){\n});\n(shadow.cljs.devtools.client.console.MapFormatter.prototype.shadow$formatter \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn true;\n}));\n\n(shadow.cljs.devtools.client.console.MapFormatter.prototype.header \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((((obj instanceof cljs.core.PersistentHashMap)) || ((((obj instanceof cljs.core.PersistentArrayMap)) || (cljs.core.record_QMARK_(obj)))))){\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),cljs.core.PersistentArrayMap.EMPTY,[cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.type(obj)], 0)),\x22 [count: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.count(obj)),\x22]\x22].join(\x27\x27)], null));\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.console.MapFormatter.prototype.hasBody \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn cljs.core.boolean$(cljs.core.seq(obj));\n}));\n\n(shadow.cljs.devtools.client.console.MapFormatter.prototype.body \x3d (function (m){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22table\x22,\x22table\x22,-564943036),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22width\x22,\x22width\x22,-384071477),\x22100%\x22,new cljs.core.Keyword(null,\x22margin-left\x22,\x22margin-left\x22,2015598377),\x2214px\x22], null),(function (){var iter__5480__auto__ \x3d (function shadow$cljs$devtools$client$console$iter__21883(s__21884){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__21884__$1 \x3d s__21884;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__21884__$1);\nif(temp__5804__auto__){\nvar s__21884__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__21884__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__21884__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__21886 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__21885 \x3d (0);\nwhile(true){\nif((i__21885 \x3c size__5479__auto__)){\nvar key \x3d cljs.core._nth(c__5478__auto__,i__21885);\nvar value \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,key);\ncljs.core.chunk_append(b__21886,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22tr\x22,\x22tr\x22,-1424774646),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22vertical-align\x22,\x22vertical-align\x22,651007333),\x22top\x22], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22td\x22,\x22td\x22,1479933353),cljs.core.PersistentArrayMap.EMPTY,shadow.cljs.devtools.client.console.object_ref(key)], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22td\x22,\x22td\x22,1479933353),cljs.core.PersistentArrayMap.EMPTY,shadow.cljs.devtools.client.console.object_ref(value)], null)], null));\n\nvar G__22146 \x3d (i__21885 + (1));\ni__21885 \x3d G__22146;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21886),shadow$cljs$devtools$client$console$iter__21883(cljs.core.chunk_rest(s__21884__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21886),null);\n}\n} else {\nvar key \x3d cljs.core.first(s__21884__$2);\nvar value \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,key);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22tr\x22,\x22tr\x22,-1424774646),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22vertical-align\x22,\x22vertical-align\x22,651007333),\x22top\x22], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22td\x22,\x22td\x22,1479933353),cljs.core.PersistentArrayMap.EMPTY,shadow.cljs.devtools.client.console.object_ref(key)], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22td\x22,\x22td\x22,1479933353),cljs.core.PersistentArrayMap.EMPTY,shadow.cljs.devtools.client.console.object_ref(value)], null)], null),shadow$cljs$devtools$client$console$iter__21883(cljs.core.rest(s__21884__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__((function (){var k \x3d cljs.core.keys(m);\ntry{return cljs.core.sort.cljs$core$IFn$_invoke$arity$1(k);\n}catch (e21925){var e \x3d e21925;\nreturn k;\n}})());\n})()], null));\n}));\n\n(shadow.cljs.devtools.client.console.MapFormatter.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(shadow.cljs.devtools.client.console.MapFormatter.cljs$lang$type \x3d true);\n\n(shadow.cljs.devtools.client.console.MapFormatter.cljs$lang$ctorStr \x3d \x22shadow.cljs.devtools.client.console/MapFormatter\x22);\n\n(shadow.cljs.devtools.client.console.MapFormatter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.cljs.devtools.client.console/MapFormatter\x22);\n}));\n\n/**\n * Positional factory function for shadow.cljs.devtools.client.console/MapFormatter.\n */\nshadow.cljs.devtools.client.console.__GT_MapFormatter \x3d (function shadow$cljs$devtools$client$console$__GT_MapFormatter(){\nreturn (new shadow.cljs.devtools.client.console.MapFormatter());\n});\n\nshadow.cljs.devtools.client.console.keyword_style \x3d new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22color\x22,\x22color\x22,1011675173),\x22rgb(136, 19, 145)\x22], null);\n\n/**\n* @constructor\n*/\nshadow.cljs.devtools.client.console.KeywordFormatter \x3d (function (){\n});\n(shadow.cljs.devtools.client.console.KeywordFormatter.prototype.shadow$formatter \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn true;\n}));\n\n(shadow.cljs.devtools.client.console.KeywordFormatter.prototype.header \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((obj instanceof cljs.core.Keyword)){\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),shadow.cljs.devtools.client.console.keyword_style,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([obj], 0))], null));\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.console.KeywordFormatter.prototype.hasBody \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn false;\n}));\n\n(shadow.cljs.devtools.client.console.KeywordFormatter.prototype.body \x3d (function (m){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn null;\n}));\n\n(shadow.cljs.devtools.client.console.KeywordFormatter.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(shadow.cljs.devtools.client.console.KeywordFormatter.cljs$lang$type \x3d true);\n\n(shadow.cljs.devtools.client.console.KeywordFormatter.cljs$lang$ctorStr \x3d \x22shadow.cljs.devtools.client.console/KeywordFormatter\x22);\n\n(shadow.cljs.devtools.client.console.KeywordFormatter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.cljs.devtools.client.console/KeywordFormatter\x22);\n}));\n\n/**\n * Positional factory function for shadow.cljs.devtools.client.console/KeywordFormatter.\n */\nshadow.cljs.devtools.client.console.__GT_KeywordFormatter \x3d (function shadow$cljs$devtools$client$console$__GT_KeywordFormatter(){\nreturn (new shadow.cljs.devtools.client.console.KeywordFormatter());\n});\n\n\n/**\n* @constructor\n*/\nshadow.cljs.devtools.client.console.SymbolFormatter \x3d (function (){\n});\n(shadow.cljs.devtools.client.console.SymbolFormatter.prototype.shadow$formatter \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn true;\n}));\n\n(shadow.cljs.devtools.client.console.SymbolFormatter.prototype.header \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((obj instanceof cljs.core.Symbol)){\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),shadow.cljs.devtools.client.console.keyword_style,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([obj], 0))], null));\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.console.SymbolFormatter.prototype.hasBody \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn false;\n}));\n\n(shadow.cljs.devtools.client.console.SymbolFormatter.prototype.body \x3d (function (m){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn null;\n}));\n\n(shadow.cljs.devtools.client.console.SymbolFormatter.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(shadow.cljs.devtools.client.console.SymbolFormatter.cljs$lang$type \x3d true);\n\n(shadow.cljs.devtools.client.console.SymbolFormatter.cljs$lang$ctorStr \x3d \x22shadow.cljs.devtools.client.console/SymbolFormatter\x22);\n\n(shadow.cljs.devtools.client.console.SymbolFormatter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.cljs.devtools.client.console/SymbolFormatter\x22);\n}));\n\n/**\n * Positional factory function for shadow.cljs.devtools.client.console/SymbolFormatter.\n */\nshadow.cljs.devtools.client.console.__GT_SymbolFormatter \x3d (function shadow$cljs$devtools$client$console$__GT_SymbolFormatter(){\nreturn (new shadow.cljs.devtools.client.console.SymbolFormatter());\n});\n\n\n/**\n* @constructor\n*/\nshadow.cljs.devtools.client.console.DerefFormatter \x3d (function (){\n});\n(shadow.cljs.devtools.client.console.DerefFormatter.prototype.shadow$formatter \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn true;\n}));\n\n(shadow.cljs.devtools.client.console.DerefFormatter.prototype.header \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif((((obj instanceof cljs.core.Atom)) || ((obj instanceof cljs.core.Volatile)))){\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),shadow.cljs.devtools.client.console.keyword_style,[\x22@DEREF \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.type(obj)], 0))].join(\x27\x27)], null));\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.console.DerefFormatter.prototype.hasBody \x3d (function (obj){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn true;\n}));\n\n(shadow.cljs.devtools.client.console.DerefFormatter.prototype.body \x3d (function (v){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn shadow.cljs.devtools.client.console.clj__GT_jsonml(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22margin-left\x22,\x22margin-left\x22,2015598377),\x2214px\x22], null),shadow.cljs.devtools.client.console.object_ref(cljs.core.deref(v))], null));\n}));\n\n(shadow.cljs.devtools.client.console.DerefFormatter.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(shadow.cljs.devtools.client.console.DerefFormatter.cljs$lang$type \x3d true);\n\n(shadow.cljs.devtools.client.console.DerefFormatter.cljs$lang$ctorStr \x3d \x22shadow.cljs.devtools.client.console/DerefFormatter\x22);\n\n(shadow.cljs.devtools.client.console.DerefFormatter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.cljs.devtools.client.console/DerefFormatter\x22);\n}));\n\n/**\n * Positional factory function for shadow.cljs.devtools.client.console/DerefFormatter.\n */\nshadow.cljs.devtools.client.console.__GT_DerefFormatter \x3d (function shadow$cljs$devtools$client$console$__GT_DerefFormatter(){\nreturn (new shadow.cljs.devtools.client.console.DerefFormatter());\n});\n\nshadow.cljs.devtools.client.console.install_all_BANG_ \x3d (function shadow$cljs$devtools$client$console$install_all_BANG_(){\nvar temp__5804__auto__ \x3d goog.global.devtoolsFormatters;\nif(cljs.core.truth_(temp__5804__auto__)){\nvar f \x3d temp__5804__auto__;\nvar G__22010 \x3d f;\nG__22010.push((new shadow.cljs.devtools.client.console.KeywordFormatter()));\n\nG__22010.push((new shadow.cljs.devtools.client.console.MapFormatter()));\n\nG__22010.push((new shadow.cljs.devtools.client.console.SeqFormatter()));\n\nG__22010.push((new shadow.cljs.devtools.client.console.SymbolFormatter()));\n\nG__22010.push((new shadow.cljs.devtools.client.console.DerefFormatter()));\n\nreturn G__22010;\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.console.remove_all_BANG_ \x3d (function shadow$cljs$devtools$client$console$remove_all_BANG_(){\nvar all \x3d cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p1__22017_SHARP_){\nreturn goog.object.get(p1__22017_SHARP_,\x22shadow$formatter\x22);\n}),cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1((function (){var or__5002__auto__ \x3d goog.global.devtoolsFormatters;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn [];\n}\n})())));\nreturn goog.object.set(goog.global,\x22devtoolsFormatters\x22,all);\n});\nshadow.cljs.devtools.client.console.remove_all_BANG_();\nshadow.cljs.devtools.client.console.install_all_BANG_();\n");
SHADOW_ENV.evalLoad("goog.labs.useragent.engine.js", true, "goog.loadModule(function(exports) {\n  function isPresto() {\n    return util.matchUserAgent(\x22Presto\x22);\n  }\n  function isTrident() {\n    return util.matchUserAgent(\x22Trident\x22) || util.matchUserAgent(\x22MSIE\x22);\n  }\n  function isEdge() {\n    return util.matchUserAgent(\x22Edge\x22);\n  }\n  function isWebKit() {\n    return util.matchUserAgentIgnoreCase(\x22WebKit\x22) \x26\x26 !isEdge();\n  }\n  function isGecko() {\n    return util.matchUserAgent(\x22Gecko\x22) \x26\x26 !isWebKit() \x26\x26 !isTrident() \x26\x26 !isEdge();\n  }\n  function getVersion() {\n    const userAgentString \x3d util.getUserAgent();\n    if (userAgentString) {\n      const tuples \x3d util.extractVersionTuples(userAgentString);\n      const engineTuple \x3d getEngineTuple(tuples);\n      if (engineTuple) {\n        if (engineTuple[0] \x3d\x3d \x22Gecko\x22) {\n          return getVersionForKey(tuples, \x22Firefox\x22);\n        }\n        return engineTuple[1];\n      }\n      const browserTuple \x3d tuples[0];\n      let info;\n      if (browserTuple \x26\x26 (info \x3d browserTuple[2])) {\n        const match \x3d /Trident\\/([^\\s;]+)/.exec(info);\n        if (match) {\n          return match[1];\n        }\n      }\n    }\n    return \x22\x22;\n  }\n  function getEngineTuple(tuples) {\n    if (!isEdge()) {\n      return tuples[1];\n    }\n    for (let i \x3d 0; i \x3c tuples.length; i++) {\n      const tuple \x3d tuples[i];\n      if (tuple[0] \x3d\x3d \x22Edge\x22) {\n        return tuple;\n      }\n    }\n  }\n  function isVersionOrHigher(version) {\n    return googString.compareVersions(getVersion(), version) \x3e\x3d 0;\n  }\n  function getVersionForKey(tuples, key) {\n    const pair \x3d googArray.find(tuples, function(pair) {\n      return key \x3d\x3d pair[0];\n    });\n    return pair \x26\x26 pair[1] || \x22\x22;\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.labs.userAgent.engine\x22);\n  goog.module.declareLegacyNamespace();\n  const googArray \x3d goog.require(\x22goog.array\x22);\n  const googString \x3d goog.require(\x22goog.string.internal\x22);\n  const util \x3d goog.require(\x22goog.labs.userAgent.util\x22);\n  exports \x3d {getVersion, isEdge, isGecko, isPresto, isTrident, isVersionOrHigher, isWebKit};\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.labs.useragent.platform.js", true, "goog.loadModule(function(exports) {\n  function useUserAgentDataPlatform(ignoreClientHintsFlag \x3d false) {\n    if (util.ASSUME_CLIENT_HINTS_SUPPORT) {\n      return true;\n    }\n    if (!ignoreClientHintsFlag \x26\x26 !useClientHints()) {\n      return false;\n    }\n    const userAgentData \x3d util.getUserAgentData();\n    return !!userAgentData \x26\x26 !!userAgentData.platform;\n  }\n  function isAndroid() {\n    if (useUserAgentDataPlatform()) {\n      return util.getUserAgentData().platform \x3d\x3d\x3d \x22Android\x22;\n    }\n    return util.matchUserAgent(\x22Android\x22);\n  }\n  function isIpod() {\n    return util.matchUserAgent(\x22iPod\x22);\n  }\n  function isIphone() {\n    return util.matchUserAgent(\x22iPhone\x22) \x26\x26 !util.matchUserAgent(\x22iPod\x22) \x26\x26 !util.matchUserAgent(\x22iPad\x22);\n  }\n  function isIpad() {\n    return util.matchUserAgent(\x22iPad\x22);\n  }\n  function isIos() {\n    return isIphone() || isIpad() || isIpod();\n  }\n  function isMacintosh() {\n    if (useUserAgentDataPlatform()) {\n      return util.getUserAgentData().platform \x3d\x3d\x3d \x22macOS\x22;\n    }\n    return util.matchUserAgent(\x22Macintosh\x22);\n  }\n  function isLinux() {\n    if (useUserAgentDataPlatform()) {\n      return util.getUserAgentData().platform \x3d\x3d\x3d \x22Linux\x22;\n    }\n    return util.matchUserAgent(\x22Linux\x22);\n  }\n  function isWindows() {\n    if (useUserAgentDataPlatform()) {\n      return util.getUserAgentData().platform \x3d\x3d\x3d \x22Windows\x22;\n    }\n    return util.matchUserAgent(\x22Windows\x22);\n  }\n  function isChromeOS() {\n    if (useUserAgentDataPlatform()) {\n      return util.getUserAgentData().platform \x3d\x3d\x3d \x22Chrome OS\x22;\n    }\n    return util.matchUserAgent(\x22CrOS\x22);\n  }\n  function isChromecast() {\n    return util.matchUserAgent(\x22CrKey\x22);\n  }\n  function isKaiOS() {\n    return util.matchUserAgentIgnoreCase(\x22KaiOS\x22);\n  }\n  function getVersion() {\n    const userAgentString \x3d util.getUserAgent();\n    let version \x3d \x22\x22;\n    let re;\n    if (isWindows()) {\n      re \x3d /Windows (?:NT|Phone) ([0-9.]+)/;\n      const match \x3d re.exec(userAgentString);\n      if (match) {\n        version \x3d match[1];\n      } else {\n        version \x3d \x220.0\x22;\n      }\n    } else if (isIos()) {\n      re \x3d /(?:iPhone|iPod|iPad|CPU)\\s+OS\\s+(\\S+)/;\n      const match \x3d re.exec(userAgentString);\n      version \x3d match \x26\x26 match[1].replace(/_/g, \x22.\x22);\n    } else if (isMacintosh()) {\n      re \x3d /Mac OS X ([0-9_.]+)/;\n      const match \x3d re.exec(userAgentString);\n      version \x3d match ? match[1].replace(/_/g, \x22.\x22) : \x2210\x22;\n    } else if (isKaiOS()) {\n      re \x3d /(?:KaiOS)\\/(\\S+)/i;\n      const match \x3d re.exec(userAgentString);\n      version \x3d match \x26\x26 match[1];\n    } else if (isAndroid()) {\n      re \x3d /Android\\s+([^\\);]+)(\\)|;)/;\n      const match \x3d re.exec(userAgentString);\n      version \x3d match \x26\x26 match[1];\n    } else if (isChromeOS()) {\n      re \x3d /(?:CrOS\\s+(?:i686|x86_64)\\s+([0-9.]+))/;\n      const match \x3d re.exec(userAgentString);\n      version \x3d match \x26\x26 match[1];\n    }\n    return version || \x22\x22;\n  }\n  function isVersionOrHigher(version) {\n    return googString.compareVersions(getVersion(), version) \x3e\x3d 0;\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.labs.userAgent.platform\x22);\n  goog.module.declareLegacyNamespace();\n  const googString \x3d goog.require(\x22goog.string.internal\x22);\n  const util \x3d goog.require(\x22goog.labs.userAgent.util\x22);\n  const {AsyncValue, Version} \x3d goog.require(\x22goog.labs.userAgent.highEntropy.highEntropyValue\x22);\n  const {platformVersion} \x3d goog.require(\x22goog.labs.userAgent.highEntropy.highEntropyData\x22);\n  const {useClientHints} \x3d goog.require(\x22goog.labs.userAgent\x22);\n  class PlatformVersion {\n    constructor() {\n      this.preUachHasLoaded_ \x3d false;\n    }\n    getIfLoaded() {\n      if (useUserAgentDataPlatform(true)) {\n        const loadedPlatformVersion \x3d platformVersion.getIfLoaded();\n        if (loadedPlatformVersion \x3d\x3d\x3d undefined) {\n          return undefined;\n        }\n        return new Version(loadedPlatformVersion);\n      } else if (!this.preUachHasLoaded_) {\n        return undefined;\n      } else {\n        return new Version(getVersion());\n      }\n    }\n    async load() {\n      if (useUserAgentDataPlatform(true)) {\n        return new Version(await platformVersion.load());\n      } else {\n        this.preUachHasLoaded_ \x3d true;\n        return new Version(getVersion());\n      }\n    }\n    resetForTesting() {\n      platformVersion.resetForTesting();\n      this.preUachHasLoaded_ \x3d false;\n    }\n  }\n  const version \x3d new PlatformVersion();\n  exports \x3d {getVersion, isAndroid, isChromeOS, isChromecast, isIos, isIpad, isIphone, isIpod, isKaiOS, isLinux, isMacintosh, isVersionOrHigher, isWindows, version};\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.useragent.useragent.js", true, "goog.provide(\x22goog.userAgent\x22);\ngoog.require(\x22goog.labs.userAgent.browser\x22);\ngoog.require(\x22goog.labs.userAgent.engine\x22);\ngoog.require(\x22goog.labs.userAgent.platform\x22);\ngoog.require(\x22goog.labs.userAgent.util\x22);\ngoog.require(\x22goog.reflect\x22);\ngoog.require(\x22goog.string.internal\x22);\ngoog.userAgent.ASSUME_IE \x3d goog.define(\x22goog.userAgent.ASSUME_IE\x22, false);\ngoog.userAgent.ASSUME_EDGE \x3d goog.define(\x22goog.userAgent.ASSUME_EDGE\x22, false);\ngoog.userAgent.ASSUME_GECKO \x3d goog.define(\x22goog.userAgent.ASSUME_GECKO\x22, false);\ngoog.userAgent.ASSUME_WEBKIT \x3d goog.define(\x22goog.userAgent.ASSUME_WEBKIT\x22, false);\ngoog.userAgent.ASSUME_MOBILE_WEBKIT \x3d goog.define(\x22goog.userAgent.ASSUME_MOBILE_WEBKIT\x22, false);\ngoog.userAgent.ASSUME_OPERA \x3d goog.define(\x22goog.userAgent.ASSUME_OPERA\x22, false);\ngoog.userAgent.ASSUME_ANY_VERSION \x3d goog.define(\x22goog.userAgent.ASSUME_ANY_VERSION\x22, false);\ngoog.userAgent.BROWSER_KNOWN_ \x3d goog.userAgent.ASSUME_IE || goog.userAgent.ASSUME_EDGE || goog.userAgent.ASSUME_GECKO || goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_OPERA;\ngoog.userAgent.getUserAgentString \x3d function() {\n  return goog.labs.userAgent.util.getUserAgent();\n};\ngoog.userAgent.getNavigatorTyped \x3d function() {\n  return goog.global[\x22navigator\x22] || null;\n};\ngoog.userAgent.getNavigator \x3d function() {\n  return goog.userAgent.getNavigatorTyped();\n};\ngoog.userAgent.OPERA \x3d goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_OPERA : goog.labs.userAgent.browser.isOpera();\ngoog.userAgent.IE \x3d goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_IE : goog.labs.userAgent.browser.isIE();\ngoog.userAgent.EDGE \x3d goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_EDGE : goog.labs.userAgent.engine.isEdge();\ngoog.userAgent.EDGE_OR_IE \x3d goog.userAgent.EDGE || goog.userAgent.IE;\ngoog.userAgent.GECKO \x3d goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_GECKO : goog.labs.userAgent.engine.isGecko();\ngoog.userAgent.WEBKIT \x3d goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_MOBILE_WEBKIT : goog.labs.userAgent.engine.isWebKit();\ngoog.userAgent.isMobile_ \x3d function() {\n  return goog.userAgent.WEBKIT \x26\x26 goog.labs.userAgent.util.matchUserAgent(\x22Mobile\x22);\n};\ngoog.userAgent.MOBILE \x3d goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.isMobile_();\ngoog.userAgent.SAFARI \x3d goog.userAgent.WEBKIT;\ngoog.userAgent.determinePlatform_ \x3d function() {\n  var navigator \x3d goog.userAgent.getNavigatorTyped();\n  return navigator \x26\x26 navigator.platform || \x22\x22;\n};\ngoog.userAgent.PLATFORM \x3d goog.userAgent.determinePlatform_();\ngoog.userAgent.ASSUME_MAC \x3d goog.define(\x22goog.userAgent.ASSUME_MAC\x22, false);\ngoog.userAgent.ASSUME_WINDOWS \x3d goog.define(\x22goog.userAgent.ASSUME_WINDOWS\x22, false);\ngoog.userAgent.ASSUME_LINUX \x3d goog.define(\x22goog.userAgent.ASSUME_LINUX\x22, false);\ngoog.userAgent.ASSUME_X11 \x3d goog.define(\x22goog.userAgent.ASSUME_X11\x22, false);\ngoog.userAgent.ASSUME_ANDROID \x3d goog.define(\x22goog.userAgent.ASSUME_ANDROID\x22, false);\ngoog.userAgent.ASSUME_IPHONE \x3d goog.define(\x22goog.userAgent.ASSUME_IPHONE\x22, false);\ngoog.userAgent.ASSUME_IPAD \x3d goog.define(\x22goog.userAgent.ASSUME_IPAD\x22, false);\ngoog.userAgent.ASSUME_IPOD \x3d goog.define(\x22goog.userAgent.ASSUME_IPOD\x22, false);\ngoog.userAgent.ASSUME_KAIOS \x3d goog.define(\x22goog.userAgent.ASSUME_KAIOS\x22, false);\ngoog.userAgent.PLATFORM_KNOWN_ \x3d goog.userAgent.ASSUME_MAC || goog.userAgent.ASSUME_WINDOWS || goog.userAgent.ASSUME_LINUX || goog.userAgent.ASSUME_X11 || goog.userAgent.ASSUME_ANDROID || goog.userAgent.ASSUME_IPHONE || goog.userAgent.ASSUME_IPAD || goog.userAgent.ASSUME_IPOD;\ngoog.userAgent.MAC \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_MAC : goog.labs.userAgent.platform.isMacintosh();\ngoog.userAgent.WINDOWS \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_WINDOWS : goog.labs.userAgent.platform.isWindows();\ngoog.userAgent.isLegacyLinux_ \x3d function() {\n  return goog.labs.userAgent.platform.isLinux() || goog.labs.userAgent.platform.isChromeOS();\n};\ngoog.userAgent.LINUX \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_LINUX : goog.userAgent.isLegacyLinux_();\ngoog.userAgent.isX11_ \x3d function() {\n  var navigator \x3d goog.userAgent.getNavigatorTyped();\n  return !!navigator \x26\x26 goog.string.internal.contains(navigator[\x22appVersion\x22] || \x22\x22, \x22X11\x22);\n};\ngoog.userAgent.X11 \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_X11 : goog.userAgent.isX11_();\ngoog.userAgent.ANDROID \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_ANDROID : goog.labs.userAgent.platform.isAndroid();\ngoog.userAgent.IPHONE \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPHONE : goog.labs.userAgent.platform.isIphone();\ngoog.userAgent.IPAD \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPAD : goog.labs.userAgent.platform.isIpad();\ngoog.userAgent.IPOD \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPOD : goog.labs.userAgent.platform.isIpod();\ngoog.userAgent.IOS \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPHONE || goog.userAgent.ASSUME_IPAD || goog.userAgent.ASSUME_IPOD : goog.labs.userAgent.platform.isIos();\ngoog.userAgent.KAIOS \x3d goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_KAIOS : goog.labs.userAgent.platform.isKaiOS();\ngoog.userAgent.determineVersion_ \x3d function() {\n  var version \x3d \x22\x22;\n  var arr \x3d goog.userAgent.getVersionRegexResult_();\n  if (arr) {\n    version \x3d arr ? arr[1] : \x22\x22;\n  }\n  if (goog.userAgent.IE) {\n    var docMode \x3d goog.userAgent.getDocumentMode_();\n    if (docMode !\x3d null \x26\x26 docMode \x3e parseFloat(version)) {\n      return String(docMode);\n    }\n  }\n  return version;\n};\ngoog.userAgent.getVersionRegexResult_ \x3d function() {\n  var userAgent \x3d goog.userAgent.getUserAgentString();\n  if (goog.userAgent.GECKO) {\n    return /rv:([^\\);]+)(\\)|;)/.exec(userAgent);\n  }\n  if (goog.userAgent.EDGE) {\n    return /Edge\\/([\\d\\.]+)/.exec(userAgent);\n  }\n  if (goog.userAgent.IE) {\n    return /\\b(?:MSIE|rv)[: ]([^\\);]+)(\\)|;)/.exec(userAgent);\n  }\n  if (goog.userAgent.WEBKIT) {\n    return /WebKit\\/(\\S+)/.exec(userAgent);\n  }\n  if (goog.userAgent.OPERA) {\n    return /(?:Version)[ \\/]?(\\S+)/.exec(userAgent);\n  }\n  return undefined;\n};\ngoog.userAgent.getDocumentMode_ \x3d function() {\n  var doc \x3d goog.global[\x22document\x22];\n  return doc ? doc[\x22documentMode\x22] : undefined;\n};\ngoog.userAgent.VERSION \x3d goog.userAgent.determineVersion_();\ngoog.userAgent.compare \x3d function(v1, v2) {\n  return goog.string.internal.compareVersions(v1, v2);\n};\ngoog.userAgent.isVersionOrHigherCache_ \x3d {};\ngoog.userAgent.isVersionOrHigher \x3d function(version) {\n  return goog.userAgent.ASSUME_ANY_VERSION || goog.reflect.cache(goog.userAgent.isVersionOrHigherCache_, version, function() {\n    return goog.string.internal.compareVersions(goog.userAgent.VERSION, version) \x3e\x3d 0;\n  });\n};\ngoog.userAgent.isDocumentModeOrHigher \x3d function(documentMode) {\n  return Number(goog.userAgent.DOCUMENT_MODE) \x3e\x3d documentMode;\n};\ngoog.userAgent.isDocumentMode \x3d goog.userAgent.isDocumentModeOrHigher;\ngoog.userAgent.DOCUMENT_MODE \x3d function() {\n  var doc \x3d goog.global[\x22document\x22];\n  if (!doc || !goog.userAgent.IE) {\n    return undefined;\n  }\n  var documentMode \x3d goog.userAgent.getDocumentMode_();\n  if (documentMode) {\n    return documentMode;\n  }\n  var ieVersion \x3d parseInt(goog.userAgent.VERSION, 10);\n  return ieVersion || undefined;\n}();\n");
SHADOW_ENV.evalLoad("goog.dom.browserfeature.js", true, "goog.provide(\x22goog.dom.BrowserFeature\x22);\ngoog.require(\x22goog.userAgent\x22);\ngoog.dom.BrowserFeature.ASSUME_NO_OFFSCREEN_CANVAS \x3d goog.define(\x22goog.dom.ASSUME_NO_OFFSCREEN_CANVAS\x22, false);\ngoog.dom.BrowserFeature.ASSUME_OFFSCREEN_CANVAS \x3d goog.define(\x22goog.dom.ASSUME_OFFSCREEN_CANVAS\x22, false);\ngoog.dom.BrowserFeature.detectOffscreenCanvas_ \x3d function(contextName) {\n  try {\n    return Boolean((new self.OffscreenCanvas(0, 0)).getContext(contextName));\n  } catch (ex) {\n  }\n  return false;\n};\ngoog.dom.BrowserFeature.OFFSCREEN_CANVAS_2D \x3d !goog.dom.BrowserFeature.ASSUME_NO_OFFSCREEN_CANVAS \x26\x26 (goog.dom.BrowserFeature.ASSUME_OFFSCREEN_CANVAS || goog.dom.BrowserFeature.detectOffscreenCanvas_(\x222d\x22));\ngoog.dom.BrowserFeature.CAN_ADD_NAME_OR_TYPE_ATTRIBUTES \x3d true;\ngoog.dom.BrowserFeature.CAN_USE_CHILDREN_ATTRIBUTE \x3d true;\ngoog.dom.BrowserFeature.CAN_USE_INNER_TEXT \x3d false;\ngoog.dom.BrowserFeature.CAN_USE_PARENT_ELEMENT_PROPERTY \x3d goog.userAgent.IE || goog.userAgent.WEBKIT;\ngoog.dom.BrowserFeature.INNER_HTML_NEEDS_SCOPED_ELEMENT \x3d goog.userAgent.IE;\n");
SHADOW_ENV.evalLoad("goog.math.math.js", true, "goog.provide(\x22goog.math\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.math.randomInt \x3d function(a) {\n  return Math.floor(Math.random() * a);\n};\ngoog.math.uniformRandom \x3d function(a, b) {\n  return a + Math.random() * (b - a);\n};\ngoog.math.clamp \x3d function(value, min, max) {\n  return Math.min(Math.max(value, min), max);\n};\ngoog.math.modulo \x3d function(a, b) {\n  var r \x3d a % b;\n  return r * b \x3c 0 ? r + b : r;\n};\ngoog.math.lerp \x3d function(a, b, x) {\n  return a + x * (b - a);\n};\ngoog.math.nearlyEquals \x3d function(a, b, opt_tolerance) {\n  return Math.abs(a - b) \x3c\x3d (opt_tolerance || 0.000001);\n};\ngoog.math.standardAngle \x3d function(angle) {\n  return goog.math.modulo(angle, 360);\n};\ngoog.math.standardAngleInRadians \x3d function(angle) {\n  return goog.math.modulo(angle, 2 * Math.PI);\n};\ngoog.math.toRadians \x3d function(angleDegrees) {\n  return angleDegrees * Math.PI / 180;\n};\ngoog.math.toDegrees \x3d function(angleRadians) {\n  return angleRadians * 180 / Math.PI;\n};\ngoog.math.angleDx \x3d function(degrees, radius) {\n  return radius * Math.cos(goog.math.toRadians(degrees));\n};\ngoog.math.angleDy \x3d function(degrees, radius) {\n  return radius * Math.sin(goog.math.toRadians(degrees));\n};\ngoog.math.angle \x3d function(x1, y1, x2, y2) {\n  return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(y2 - y1, x2 - x1)));\n};\ngoog.math.angleDifference \x3d function(startAngle, endAngle) {\n  var d \x3d goog.math.standardAngle(endAngle) - goog.math.standardAngle(startAngle);\n  if (d \x3e 180) {\n    d \x3d d - 360;\n  } else if (d \x3c\x3d -180) {\n    d \x3d 360 + d;\n  }\n  return d;\n};\ngoog.math.sign \x3d function(x) {\n  if (x \x3e 0) {\n    return 1;\n  }\n  if (x \x3c 0) {\n    return -1;\n  }\n  return x;\n};\ngoog.math.longestCommonSubsequence \x3d function(array1, array2, opt_compareFn, opt_collectorFn) {\n  var compare \x3d opt_compareFn || function(a, b) {\n    return a \x3d\x3d b;\n  };\n  var collect \x3d opt_collectorFn || function(i1, i2) {\n    return array1[i1];\n  };\n  var length1 \x3d array1.length;\n  var length2 \x3d array2.length;\n  var arr \x3d [];\n  var i \x3d 0;\n  for (; i \x3c length1 + 1; i++) {\n    arr[i] \x3d [];\n    arr[i][0] \x3d 0;\n  }\n  var j \x3d 0;\n  for (; j \x3c length2 + 1; j++) {\n    arr[0][j] \x3d 0;\n  }\n  i \x3d 1;\n  for (; i \x3c\x3d length1; i++) {\n    j \x3d 1;\n    for (; j \x3c\x3d length2; j++) {\n      if (compare(array1[i - 1], array2[j - 1])) {\n        arr[i][j] \x3d arr[i - 1][j - 1] + 1;\n      } else {\n        arr[i][j] \x3d Math.max(arr[i - 1][j], arr[i][j - 1]);\n      }\n    }\n  }\n  var result \x3d [];\n  i \x3d length1;\n  j \x3d length2;\n  for (; i \x3e 0 \x26\x26 j \x3e 0;) {\n    if (compare(array1[i - 1], array2[j - 1])) {\n      result.unshift(collect(i - 1, j - 1));\n      i--;\n      j--;\n    } else {\n      if (arr[i - 1][j] \x3e arr[i][j - 1]) {\n        i--;\n      } else {\n        j--;\n      }\n    }\n  }\n  return result;\n};\ngoog.math.sum \x3d function(var_args) {\n  return Array.prototype.reduce.call(arguments, function(sum, value) {\n    return sum + value;\n  }, 0);\n};\ngoog.math.average \x3d function(var_args) {\n  return goog.math.sum.apply(null, arguments) / arguments.length;\n};\ngoog.math.sampleVariance \x3d function(var_args) {\n  var sampleSize \x3d arguments.length;\n  if (sampleSize \x3c 2) {\n    return 0;\n  }\n  var mean \x3d goog.math.average.apply(null, arguments);\n  var variance \x3d goog.math.sum.apply(null, Array.prototype.map.call(arguments, function(val) {\n    return Math.pow(val - mean, 2);\n  })) / (sampleSize - 1);\n  return variance;\n};\ngoog.math.standardDeviation \x3d function(var_args) {\n  return Math.sqrt(goog.math.sampleVariance.apply(null, arguments));\n};\ngoog.math.isInt \x3d function(num) {\n  return isFinite(num) \x26\x26 num % 1 \x3d\x3d 0;\n};\ngoog.math.isFiniteNumber \x3d function(num) {\n  return isFinite(num);\n};\ngoog.math.isNegativeZero \x3d function(num) {\n  return num \x3d\x3d 0 \x26\x26 1 / num \x3c 0;\n};\ngoog.math.log10Floor \x3d function(num) {\n  if (num \x3e 0) {\n    var x \x3d Math.round(Math.log(num) * Math.LOG10E);\n    return x - (parseFloat(\x221e\x22 + x) \x3e num ? 1 : 0);\n  }\n  return num \x3d\x3d 0 ? -Infinity : NaN;\n};\ngoog.math.safeFloor \x3d function(num, opt_epsilon) {\n  goog.asserts.assert(opt_epsilon \x3d\x3d\x3d undefined || opt_epsilon \x3e 0);\n  return Math.floor(num + (opt_epsilon || 2e-15));\n};\ngoog.math.safeCeil \x3d function(num, opt_epsilon) {\n  goog.asserts.assert(opt_epsilon \x3d\x3d\x3d undefined || opt_epsilon \x3e 0);\n  return Math.ceil(num - (opt_epsilon || 2e-15));\n};\n");
SHADOW_ENV.evalLoad("goog.math.coordinate.js", true, "goog.provide(\x22goog.math.Coordinate\x22);\ngoog.require(\x22goog.math\x22);\ngoog.math.Coordinate \x3d function(opt_x, opt_y) {\n  this.x \x3d opt_x !\x3d\x3d undefined ? opt_x : 0;\n  this.y \x3d opt_y !\x3d\x3d undefined ? opt_y : 0;\n};\ngoog.math.Coordinate.prototype.clone \x3d function() {\n  return new goog.math.Coordinate(this.x, this.y);\n};\nif (goog.DEBUG) {\n  goog.math.Coordinate.prototype.toString \x3d function() {\n    return \x22(\x22 + this.x + \x22, \x22 + this.y + \x22)\x22;\n  };\n}\ngoog.math.Coordinate.prototype.equals \x3d function(other) {\n  return other instanceof goog.math.Coordinate \x26\x26 goog.math.Coordinate.equals(this, other);\n};\ngoog.math.Coordinate.equals \x3d function(a, b) {\n  if (a \x3d\x3d b) {\n    return true;\n  }\n  if (!a || !b) {\n    return false;\n  }\n  return a.x \x3d\x3d b.x \x26\x26 a.y \x3d\x3d b.y;\n};\ngoog.math.Coordinate.distance \x3d function(a, b) {\n  var dx \x3d a.x - b.x;\n  var dy \x3d a.y - b.y;\n  return Math.sqrt(dx * dx + dy * dy);\n};\ngoog.math.Coordinate.magnitude \x3d function(a) {\n  return Math.sqrt(a.x * a.x + a.y * a.y);\n};\ngoog.math.Coordinate.azimuth \x3d function(a) {\n  return goog.math.angle(0, 0, a.x, a.y);\n};\ngoog.math.Coordinate.squaredDistance \x3d function(a, b) {\n  var dx \x3d a.x - b.x;\n  var dy \x3d a.y - b.y;\n  return dx * dx + dy * dy;\n};\ngoog.math.Coordinate.difference \x3d function(a, b) {\n  return new goog.math.Coordinate(a.x - b.x, a.y - b.y);\n};\ngoog.math.Coordinate.sum \x3d function(a, b) {\n  return new goog.math.Coordinate(a.x + b.x, a.y + b.y);\n};\ngoog.math.Coordinate.prototype.ceil \x3d function() {\n  this.x \x3d Math.ceil(this.x);\n  this.y \x3d Math.ceil(this.y);\n  return this;\n};\ngoog.math.Coordinate.prototype.floor \x3d function() {\n  this.x \x3d Math.floor(this.x);\n  this.y \x3d Math.floor(this.y);\n  return this;\n};\ngoog.math.Coordinate.prototype.round \x3d function() {\n  this.x \x3d Math.round(this.x);\n  this.y \x3d Math.round(this.y);\n  return this;\n};\ngoog.math.Coordinate.prototype.translate \x3d function(tx, opt_ty) {\n  if (tx instanceof goog.math.Coordinate) {\n    this.x +\x3d tx.x;\n    this.y +\x3d tx.y;\n  } else {\n    this.x +\x3d Number(tx);\n    if (typeof opt_ty \x3d\x3d\x3d \x22number\x22) {\n      this.y +\x3d opt_ty;\n    }\n  }\n  return this;\n};\ngoog.math.Coordinate.prototype.scale \x3d function(sx, opt_sy) {\n  var sy \x3d typeof opt_sy \x3d\x3d\x3d \x22number\x22 ? opt_sy : sx;\n  this.x *\x3d sx;\n  this.y *\x3d sy;\n  return this;\n};\ngoog.math.Coordinate.prototype.rotateRadians \x3d function(radians, opt_center) {\n  var center \x3d opt_center || new goog.math.Coordinate(0, 0);\n  var x \x3d this.x;\n  var y \x3d this.y;\n  var cos \x3d Math.cos(radians);\n  var sin \x3d Math.sin(radians);\n  this.x \x3d (x - center.x) * cos - (y - center.y) * sin + center.x;\n  this.y \x3d (x - center.x) * sin + (y - center.y) * cos + center.y;\n};\ngoog.math.Coordinate.prototype.rotateDegrees \x3d function(degrees, opt_center) {\n  this.rotateRadians(goog.math.toRadians(degrees), opt_center);\n};\n");
SHADOW_ENV.evalLoad("goog.math.size.js", true, "goog.provide(\x22goog.math.Size\x22);\ngoog.math.Size \x3d function(width, height) {\n  this.width \x3d width;\n  this.height \x3d height;\n};\ngoog.math.Size.equals \x3d function(a, b) {\n  if (a \x3d\x3d b) {\n    return true;\n  }\n  if (!a || !b) {\n    return false;\n  }\n  return a.width \x3d\x3d b.width \x26\x26 a.height \x3d\x3d b.height;\n};\ngoog.math.Size.prototype.clone \x3d function() {\n  return new goog.math.Size(this.width, this.height);\n};\nif (goog.DEBUG) {\n  goog.math.Size.prototype.toString \x3d function() {\n    return \x22(\x22 + this.width + \x22 x \x22 + this.height + \x22)\x22;\n  };\n}\ngoog.math.Size.prototype.getLongest \x3d function() {\n  return Math.max(this.width, this.height);\n};\ngoog.math.Size.prototype.getShortest \x3d function() {\n  return Math.min(this.width, this.height);\n};\ngoog.math.Size.prototype.area \x3d function() {\n  return this.width * this.height;\n};\ngoog.math.Size.prototype.perimeter \x3d function() {\n  return (this.width + this.height) * 2;\n};\ngoog.math.Size.prototype.aspectRatio \x3d function() {\n  return this.width / this.height;\n};\ngoog.math.Size.prototype.isEmpty \x3d function() {\n  return !this.area();\n};\ngoog.math.Size.prototype.ceil \x3d function() {\n  this.width \x3d Math.ceil(this.width);\n  this.height \x3d Math.ceil(this.height);\n  return this;\n};\ngoog.math.Size.prototype.fitsInside \x3d function(target) {\n  return this.width \x3c\x3d target.width \x26\x26 this.height \x3c\x3d target.height;\n};\ngoog.math.Size.prototype.floor \x3d function() {\n  this.width \x3d Math.floor(this.width);\n  this.height \x3d Math.floor(this.height);\n  return this;\n};\ngoog.math.Size.prototype.round \x3d function() {\n  this.width \x3d Math.round(this.width);\n  this.height \x3d Math.round(this.height);\n  return this;\n};\ngoog.math.Size.prototype.scale \x3d function(sx, opt_sy) {\n  const sy \x3d typeof opt_sy \x3d\x3d\x3d \x22number\x22 ? opt_sy : sx;\n  this.width *\x3d sx;\n  this.height *\x3d sy;\n  return this;\n};\ngoog.math.Size.prototype.scaleToCover \x3d function(target) {\n  const s \x3d this.aspectRatio() \x3c\x3d target.aspectRatio() ? target.width / this.width : target.height / this.height;\n  return this.scale(s);\n};\ngoog.math.Size.prototype.scaleToFit \x3d function(target) {\n  const s \x3d this.aspectRatio() \x3e target.aspectRatio() ? target.width / this.width : target.height / this.height;\n  return this.scale(s);\n};\n");
SHADOW_ENV.evalLoad("goog.dom.dom.js", true, "goog.provide(\x22goog.dom\x22);\ngoog.provide(\x22goog.dom.Appendable\x22);\ngoog.provide(\x22goog.dom.DomHelper\x22);\ngoog.require(\x22goog.array\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.asserts.dom\x22);\ngoog.require(\x22goog.dom.BrowserFeature\x22);\ngoog.require(\x22goog.dom.NodeType\x22);\ngoog.require(\x22goog.dom.TagName\x22);\ngoog.require(\x22goog.dom.safe\x22);\ngoog.require(\x22goog.html.SafeHtml\x22);\ngoog.require(\x22goog.html.uncheckedconversions\x22);\ngoog.require(\x22goog.math.Coordinate\x22);\ngoog.require(\x22goog.math.Size\x22);\ngoog.require(\x22goog.object\x22);\ngoog.require(\x22goog.string\x22);\ngoog.require(\x22goog.string.Const\x22);\ngoog.require(\x22goog.string.Unicode\x22);\ngoog.require(\x22goog.userAgent\x22);\ngoog.dom.ASSUME_QUIRKS_MODE \x3d goog.define(\x22goog.dom.ASSUME_QUIRKS_MODE\x22, false);\ngoog.dom.ASSUME_STANDARDS_MODE \x3d goog.define(\x22goog.dom.ASSUME_STANDARDS_MODE\x22, false);\ngoog.dom.COMPAT_MODE_KNOWN_ \x3d goog.dom.ASSUME_QUIRKS_MODE || goog.dom.ASSUME_STANDARDS_MODE;\ngoog.dom.getDomHelper \x3d function(opt_element) {\n  return opt_element ? new goog.dom.DomHelper(goog.dom.getOwnerDocument(opt_element)) : goog.dom.defaultDomHelper_ || (goog.dom.defaultDomHelper_ \x3d new goog.dom.DomHelper());\n};\ngoog.dom.defaultDomHelper_;\ngoog.dom.getDocument \x3d function() {\n  return document;\n};\ngoog.dom.getElement \x3d function(element) {\n  return goog.dom.getElementHelper_(document, element);\n};\ngoog.dom.getHTMLElement \x3d function(id) {\n  const element \x3d goog.dom.getElement(id);\n  if (!element) {\n    return null;\n  }\n  return goog.asserts.dom.assertIsHtmlElement(element);\n};\ngoog.dom.getElementHelper_ \x3d function(doc, element) {\n  return typeof element \x3d\x3d\x3d \x22string\x22 ? doc.getElementById(element) : element;\n};\ngoog.dom.getRequiredElement \x3d function(id) {\n  return goog.dom.getRequiredElementHelper_(document, id);\n};\ngoog.dom.getRequiredHTMLElement \x3d function(id) {\n  return goog.asserts.dom.assertIsHtmlElement(goog.dom.getRequiredElementHelper_(document, id));\n};\ngoog.dom.getRequiredElementHelper_ \x3d function(doc, id) {\n  goog.asserts.assertString(id);\n  var element \x3d goog.dom.getElementHelper_(doc, id);\n  return goog.asserts.assert(element, \x22No element found with id: \x22 + id);\n};\ngoog.dom.$ \x3d goog.dom.getElement;\ngoog.dom.getElementsByTagName \x3d function(tagName, opt_parent) {\n  var parent \x3d opt_parent || document;\n  return parent.getElementsByTagName(String(tagName));\n};\ngoog.dom.getElementsByTagNameAndClass \x3d function(opt_tag, opt_class, opt_el) {\n  return goog.dom.getElementsByTagNameAndClass_(document, opt_tag, opt_class, opt_el);\n};\ngoog.dom.getElementByTagNameAndClass \x3d function(opt_tag, opt_class, opt_el) {\n  return goog.dom.getElementByTagNameAndClass_(document, opt_tag, opt_class, opt_el);\n};\ngoog.dom.getElementsByClass \x3d function(className, opt_el) {\n  var parent \x3d opt_el || document;\n  if (goog.dom.canUseQuerySelector_(parent)) {\n    return parent.querySelectorAll(\x22.\x22 + className);\n  }\n  return goog.dom.getElementsByTagNameAndClass_(document, \x22*\x22, className, opt_el);\n};\ngoog.dom.getElementByClass \x3d function(className, opt_el) {\n  var parent \x3d opt_el || document;\n  var retVal \x3d null;\n  if (parent.getElementsByClassName) {\n    retVal \x3d parent.getElementsByClassName(className)[0];\n  } else {\n    retVal \x3d goog.dom.getElementByTagNameAndClass_(document, \x22*\x22, className, opt_el);\n  }\n  return retVal || null;\n};\ngoog.dom.getHTMLElementByClass \x3d function(className, opt_parent) {\n  const element \x3d goog.dom.getElementByClass(className, opt_parent);\n  if (!element) {\n    return null;\n  }\n  return goog.asserts.dom.assertIsHtmlElement(element);\n};\ngoog.dom.getRequiredElementByClass \x3d function(className, opt_root) {\n  var retValue \x3d goog.dom.getElementByClass(className, opt_root);\n  return goog.asserts.assert(retValue, \x22No element found with className: \x22 + className);\n};\ngoog.dom.getRequiredHTMLElementByClass \x3d function(className, opt_parent) {\n  const retValue \x3d goog.dom.getElementByClass(className, opt_parent);\n  goog.asserts.assert(retValue, \x22No HTMLElement found with className: \x22 + className);\n  return goog.asserts.dom.assertIsHtmlElement(retValue);\n};\ngoog.dom.canUseQuerySelector_ \x3d function(parent) {\n  return !!(parent.querySelectorAll \x26\x26 parent.querySelector);\n};\ngoog.dom.getElementsByTagNameAndClass_ \x3d function(doc, opt_tag, opt_class, opt_el) {\n  var parent \x3d opt_el || doc;\n  var tagName \x3d opt_tag \x26\x26 opt_tag !\x3d \x22*\x22 ? String(opt_tag).toUpperCase() : \x22\x22;\n  if (goog.dom.canUseQuerySelector_(parent) \x26\x26 (tagName || opt_class)) {\n    var query \x3d tagName + (opt_class ? \x22.\x22 + opt_class : \x22\x22);\n    return parent.querySelectorAll(query);\n  }\n  if (opt_class \x26\x26 parent.getElementsByClassName) {\n    var els \x3d parent.getElementsByClassName(opt_class);\n    if (tagName) {\n      var arrayLike \x3d {};\n      var len \x3d 0;\n      var i \x3d 0;\n      var el;\n      for (; el \x3d els[i]; i++) {\n        if (tagName \x3d\x3d el.nodeName) {\n          arrayLike[len++] \x3d el;\n        }\n      }\n      arrayLike.length \x3d len;\n      return arrayLike;\n    } else {\n      return els;\n    }\n  }\n  els \x3d parent.getElementsByTagName(tagName || \x22*\x22);\n  if (opt_class) {\n    arrayLike \x3d {};\n    len \x3d 0;\n    i \x3d 0;\n    for (; el \x3d els[i]; i++) {\n      var className \x3d el.className;\n      if (typeof className.split \x3d\x3d \x22function\x22 \x26\x26 goog.array.contains(className.split(/\\s+/), opt_class)) {\n        arrayLike[len++] \x3d el;\n      }\n    }\n    arrayLike.length \x3d len;\n    return arrayLike;\n  } else {\n    return els;\n  }\n};\ngoog.dom.getElementByTagNameAndClass_ \x3d function(doc, opt_tag, opt_class, opt_el) {\n  var parent \x3d opt_el || doc;\n  var tag \x3d opt_tag \x26\x26 opt_tag !\x3d \x22*\x22 ? String(opt_tag).toUpperCase() : \x22\x22;\n  if (goog.dom.canUseQuerySelector_(parent) \x26\x26 (tag || opt_class)) {\n    return parent.querySelector(tag + (opt_class ? \x22.\x22 + opt_class : \x22\x22));\n  }\n  var elements \x3d goog.dom.getElementsByTagNameAndClass_(doc, opt_tag, opt_class, opt_el);\n  return elements[0] || null;\n};\ngoog.dom.$$ \x3d goog.dom.getElementsByTagNameAndClass;\ngoog.dom.setProperties \x3d function(element, properties) {\n  goog.object.forEach(properties, function(val, key) {\n    if (val \x26\x26 typeof val \x3d\x3d \x22object\x22 \x26\x26 val.implementsGoogStringTypedString) {\n      val \x3d val.getTypedStringValue();\n    }\n    if (key \x3d\x3d \x22style\x22) {\n      element.style.cssText \x3d val;\n    } else if (key \x3d\x3d \x22class\x22) {\n      element.className \x3d val;\n    } else if (key \x3d\x3d \x22for\x22) {\n      element.htmlFor \x3d val;\n    } else if (goog.dom.DIRECT_ATTRIBUTE_MAP_.hasOwnProperty(key)) {\n      element.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[key], val);\n    } else if (goog.string.startsWith(key, \x22aria-\x22) || goog.string.startsWith(key, \x22data-\x22)) {\n      element.setAttribute(key, val);\n    } else {\n      element[key] \x3d val;\n    }\n  });\n};\ngoog.dom.DIRECT_ATTRIBUTE_MAP_ \x3d {\x22cellpadding\x22:\x22cellPadding\x22, \x22cellspacing\x22:\x22cellSpacing\x22, \x22colspan\x22:\x22colSpan\x22, \x22frameborder\x22:\x22frameBorder\x22, \x22height\x22:\x22height\x22, \x22maxlength\x22:\x22maxLength\x22, \x22nonce\x22:\x22nonce\x22, \x22role\x22:\x22role\x22, \x22rowspan\x22:\x22rowSpan\x22, \x22type\x22:\x22type\x22, \x22usemap\x22:\x22useMap\x22, \x22valign\x22:\x22vAlign\x22, \x22width\x22:\x22width\x22};\ngoog.dom.getViewportSize \x3d function(opt_window) {\n  return goog.dom.getViewportSize_(opt_window || window);\n};\ngoog.dom.getViewportSize_ \x3d function(win) {\n  var doc \x3d win.document;\n  var el \x3d goog.dom.isCss1CompatMode_(doc) ? doc.documentElement : doc.body;\n  return new goog.math.Size(el.clientWidth, el.clientHeight);\n};\ngoog.dom.getDocumentHeight \x3d function() {\n  return goog.dom.getDocumentHeight_(window);\n};\ngoog.dom.getDocumentHeightForWindow \x3d function(win) {\n  return goog.dom.getDocumentHeight_(win);\n};\ngoog.dom.getDocumentHeight_ \x3d function(win) {\n  var doc \x3d win.document;\n  var height \x3d 0;\n  if (doc) {\n    var body \x3d doc.body;\n    var docEl \x3d doc.documentElement;\n    if (!(docEl \x26\x26 body)) {\n      return 0;\n    }\n    var vh \x3d goog.dom.getViewportSize_(win).height;\n    if (goog.dom.isCss1CompatMode_(doc) \x26\x26 docEl.scrollHeight) {\n      height \x3d docEl.scrollHeight !\x3d vh ? docEl.scrollHeight : docEl.offsetHeight;\n    } else {\n      var sh \x3d docEl.scrollHeight;\n      var oh \x3d docEl.offsetHeight;\n      if (docEl.clientHeight !\x3d oh) {\n        sh \x3d body.scrollHeight;\n        oh \x3d body.offsetHeight;\n      }\n      if (sh \x3e vh) {\n        height \x3d sh \x3e oh ? sh : oh;\n      } else {\n        height \x3d sh \x3c oh ? sh : oh;\n      }\n    }\n  }\n  return height;\n};\ngoog.dom.getPageScroll \x3d function(opt_window) {\n  var win \x3d opt_window || goog.global || window;\n  return goog.dom.getDomHelper(win.document).getDocumentScroll();\n};\ngoog.dom.getDocumentScroll \x3d function() {\n  return goog.dom.getDocumentScroll_(document);\n};\ngoog.dom.getDocumentScroll_ \x3d function(doc) {\n  var el \x3d goog.dom.getDocumentScrollElement_(doc);\n  var win \x3d goog.dom.getWindow_(doc);\n  if (goog.userAgent.IE \x26\x26 win.pageYOffset !\x3d el.scrollTop) {\n    return new goog.math.Coordinate(el.scrollLeft, el.scrollTop);\n  }\n  return new goog.math.Coordinate(win.pageXOffset || el.scrollLeft, win.pageYOffset || el.scrollTop);\n};\ngoog.dom.getDocumentScrollElement \x3d function() {\n  return goog.dom.getDocumentScrollElement_(document);\n};\ngoog.dom.getDocumentScrollElement_ \x3d function(doc) {\n  if (doc.scrollingElement) {\n    return doc.scrollingElement;\n  }\n  if (!goog.userAgent.WEBKIT \x26\x26 goog.dom.isCss1CompatMode_(doc)) {\n    return doc.documentElement;\n  }\n  return doc.body || doc.documentElement;\n};\ngoog.dom.getWindow \x3d function(opt_doc) {\n  return opt_doc ? goog.dom.getWindow_(opt_doc) : window;\n};\ngoog.dom.getWindow_ \x3d function(doc) {\n  return doc.parentWindow || doc.defaultView;\n};\ngoog.dom.createDom \x3d function(tagName, opt_attributes, var_args) {\n  return goog.dom.createDom_(document, arguments);\n};\ngoog.dom.createDom_ \x3d function(doc, args) {\n  var tagName \x3d String(args[0]);\n  var attributes \x3d args[1];\n  var element \x3d goog.dom.createElement_(doc, tagName);\n  if (attributes) {\n    if (typeof attributes \x3d\x3d\x3d \x22string\x22) {\n      element.className \x3d attributes;\n    } else if (Array.isArray(attributes)) {\n      element.className \x3d attributes.join(\x22 \x22);\n    } else {\n      goog.dom.setProperties(element, attributes);\n    }\n  }\n  if (args.length \x3e 2) {\n    goog.dom.append_(doc, element, args, 2);\n  }\n  return element;\n};\ngoog.dom.append_ \x3d function(doc, parent, args, startIndex) {\n  function childHandler(child) {\n    if (child) {\n      parent.appendChild(typeof child \x3d\x3d\x3d \x22string\x22 ? doc.createTextNode(child) : child);\n    }\n  }\n  var i \x3d startIndex;\n  for (; i \x3c args.length; i++) {\n    var arg \x3d args[i];\n    if (goog.isArrayLike(arg) \x26\x26 !goog.dom.isNodeLike(arg)) {\n      goog.array.forEach(goog.dom.isNodeList(arg) ? goog.array.toArray(arg) : arg, childHandler);\n    } else {\n      childHandler(arg);\n    }\n  }\n};\ngoog.dom.$dom \x3d goog.dom.createDom;\ngoog.dom.createElement \x3d function(name) {\n  return goog.dom.createElement_(document, name);\n};\ngoog.dom.createElement_ \x3d function(doc, name) {\n  name \x3d String(name);\n  if (doc.contentType \x3d\x3d\x3d \x22application/xhtml+xml\x22) {\n    name \x3d name.toLowerCase();\n  }\n  return doc.createElement(name);\n};\ngoog.dom.createTextNode \x3d function(content) {\n  return document.createTextNode(String(content));\n};\ngoog.dom.createTable \x3d function(rows, columns, opt_fillWithNbsp) {\n  return goog.dom.createTable_(document, rows, columns, !!opt_fillWithNbsp);\n};\ngoog.dom.createTable_ \x3d function(doc, rows, columns, fillWithNbsp) {\n  var table \x3d goog.dom.createElement_(doc, goog.dom.TagName.TABLE);\n  var tbody \x3d table.appendChild(goog.dom.createElement_(doc, goog.dom.TagName.TBODY));\n  var i \x3d 0;\n  for (; i \x3c rows; i++) {\n    var tr \x3d goog.dom.createElement_(doc, goog.dom.TagName.TR);\n    var j \x3d 0;\n    for (; j \x3c columns; j++) {\n      var td \x3d goog.dom.createElement_(doc, goog.dom.TagName.TD);\n      if (fillWithNbsp) {\n        goog.dom.setTextContent(td, goog.string.Unicode.NBSP);\n      }\n      tr.appendChild(td);\n    }\n    tbody.appendChild(tr);\n  }\n  return table;\n};\ngoog.dom.constHtmlToNode \x3d function(var_args) {\n  var stringArray \x3d Array.prototype.map.call(arguments, goog.string.Const.unwrap);\n  var safeHtml \x3d goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from(\x22Constant HTML string, that gets turned into a \x22 + \x22Node later, so it will be automatically balanced.\x22), stringArray.join(\x22\x22));\n  return goog.dom.safeHtmlToNode(safeHtml);\n};\ngoog.dom.safeHtmlToNode \x3d function(html) {\n  return goog.dom.safeHtmlToNode_(document, html);\n};\ngoog.dom.safeHtmlToNode_ \x3d function(doc, html) {\n  var tempDiv \x3d goog.dom.createElement_(doc, goog.dom.TagName.DIV);\n  if (goog.dom.BrowserFeature.INNER_HTML_NEEDS_SCOPED_ELEMENT) {\n    goog.dom.safe.setInnerHtml(tempDiv, goog.html.SafeHtml.concat(goog.html.SafeHtml.BR, html));\n    tempDiv.removeChild(goog.asserts.assert(tempDiv.firstChild));\n  } else {\n    goog.dom.safe.setInnerHtml(tempDiv, html);\n  }\n  return goog.dom.childrenToNode_(doc, tempDiv);\n};\ngoog.dom.childrenToNode_ \x3d function(doc, tempDiv) {\n  if (tempDiv.childNodes.length \x3d\x3d 1) {\n    return tempDiv.removeChild(goog.asserts.assert(tempDiv.firstChild));\n  } else {\n    var fragment \x3d doc.createDocumentFragment();\n    for (; tempDiv.firstChild;) {\n      fragment.appendChild(tempDiv.firstChild);\n    }\n    return fragment;\n  }\n};\ngoog.dom.isCss1CompatMode \x3d function() {\n  return goog.dom.isCss1CompatMode_(document);\n};\ngoog.dom.isCss1CompatMode_ \x3d function(doc) {\n  if (goog.dom.COMPAT_MODE_KNOWN_) {\n    return goog.dom.ASSUME_STANDARDS_MODE;\n  }\n  return doc.compatMode \x3d\x3d \x22CSS1Compat\x22;\n};\ngoog.dom.canHaveChildren \x3d function(node) {\n  if (node.nodeType !\x3d goog.dom.NodeType.ELEMENT) {\n    return false;\n  }\n  switch(node.tagName) {\n    case String(goog.dom.TagName.APPLET):\n    case String(goog.dom.TagName.AREA):\n    case String(goog.dom.TagName.BASE):\n    case String(goog.dom.TagName.BR):\n    case String(goog.dom.TagName.COL):\n    case String(goog.dom.TagName.COMMAND):\n    case String(goog.dom.TagName.EMBED):\n    case String(goog.dom.TagName.FRAME):\n    case String(goog.dom.TagName.HR):\n    case String(goog.dom.TagName.IMG):\n    case String(goog.dom.TagName.INPUT):\n    case String(goog.dom.TagName.IFRAME):\n    case String(goog.dom.TagName.ISINDEX):\n    case String(goog.dom.TagName.KEYGEN):\n    case String(goog.dom.TagName.LINK):\n    case String(goog.dom.TagName.NOFRAMES):\n    case String(goog.dom.TagName.NOSCRIPT):\n    case String(goog.dom.TagName.META):\n    case String(goog.dom.TagName.OBJECT):\n    case String(goog.dom.TagName.PARAM):\n    case String(goog.dom.TagName.SCRIPT):\n    case String(goog.dom.TagName.SOURCE):\n    case String(goog.dom.TagName.STYLE):\n    case String(goog.dom.TagName.TRACK):\n    case String(goog.dom.TagName.WBR):\n      return false;\n  }\n  return true;\n};\ngoog.dom.appendChild \x3d function(parent, child) {\n  goog.asserts.assert(parent !\x3d null \x26\x26 child !\x3d null, \x22goog.dom.appendChild expects non-null arguments\x22);\n  parent.appendChild(child);\n};\ngoog.dom.append \x3d function(parent, var_args) {\n  goog.dom.append_(goog.dom.getOwnerDocument(parent), parent, arguments, 1);\n};\ngoog.dom.removeChildren \x3d function(node) {\n  var child;\n  for (; child \x3d node.firstChild;) {\n    node.removeChild(child);\n  }\n};\ngoog.dom.insertSiblingBefore \x3d function(newNode, refNode) {\n  goog.asserts.assert(newNode !\x3d null \x26\x26 refNode !\x3d null, \x22goog.dom.insertSiblingBefore expects non-null arguments\x22);\n  if (refNode.parentNode) {\n    refNode.parentNode.insertBefore(newNode, refNode);\n  }\n};\ngoog.dom.insertSiblingAfter \x3d function(newNode, refNode) {\n  goog.asserts.assert(newNode !\x3d null \x26\x26 refNode !\x3d null, \x22goog.dom.insertSiblingAfter expects non-null arguments\x22);\n  if (refNode.parentNode) {\n    refNode.parentNode.insertBefore(newNode, refNode.nextSibling);\n  }\n};\ngoog.dom.insertChildAt \x3d function(parent, child, index) {\n  goog.asserts.assert(parent !\x3d null, \x22goog.dom.insertChildAt expects a non-null parent\x22);\n  parent.insertBefore(child, parent.childNodes[index] || null);\n};\ngoog.dom.removeNode \x3d function(node) {\n  return node \x26\x26 node.parentNode ? node.parentNode.removeChild(node) : null;\n};\ngoog.dom.replaceNode \x3d function(newNode, oldNode) {\n  goog.asserts.assert(newNode !\x3d null \x26\x26 oldNode !\x3d null, \x22goog.dom.replaceNode expects non-null arguments\x22);\n  var parent \x3d oldNode.parentNode;\n  if (parent) {\n    parent.replaceChild(newNode, oldNode);\n  }\n};\ngoog.dom.copyContents \x3d function(target, source) {\n  goog.asserts.assert(target !\x3d null \x26\x26 source !\x3d null, \x22goog.dom.copyContents expects non-null arguments\x22);\n  var childNodes \x3d source.cloneNode(true).childNodes;\n  goog.dom.removeChildren(target);\n  for (; childNodes.length;) {\n    target.appendChild(childNodes[0]);\n  }\n};\ngoog.dom.flattenElement \x3d function(element) {\n  var child;\n  var parent \x3d element.parentNode;\n  if (parent \x26\x26 parent.nodeType !\x3d goog.dom.NodeType.DOCUMENT_FRAGMENT) {\n    if (element.removeNode) {\n      return element.removeNode(false);\n    } else {\n      for (; child \x3d element.firstChild;) {\n        parent.insertBefore(child, element);\n      }\n      return goog.dom.removeNode(element);\n    }\n  }\n};\ngoog.dom.getChildren \x3d function(element) {\n  if (element.children !\x3d undefined) {\n    return element.children;\n  }\n  return Array.prototype.filter.call(element.childNodes, function(node) {\n    return node.nodeType \x3d\x3d goog.dom.NodeType.ELEMENT;\n  });\n};\ngoog.dom.getFirstElementChild \x3d function(node) {\n  if (node.firstElementChild !\x3d\x3d undefined) {\n    return node.firstElementChild;\n  }\n  return goog.dom.getNextElementNode_(node.firstChild, true);\n};\ngoog.dom.getLastElementChild \x3d function(node) {\n  if (node.lastElementChild !\x3d\x3d undefined) {\n    return node.lastElementChild;\n  }\n  return goog.dom.getNextElementNode_(node.lastChild, false);\n};\ngoog.dom.getNextElementSibling \x3d function(node) {\n  if (node.nextElementSibling !\x3d\x3d undefined) {\n    return node.nextElementSibling;\n  }\n  return goog.dom.getNextElementNode_(node.nextSibling, true);\n};\ngoog.dom.getPreviousElementSibling \x3d function(node) {\n  if (node.previousElementSibling !\x3d\x3d undefined) {\n    return node.previousElementSibling;\n  }\n  return goog.dom.getNextElementNode_(node.previousSibling, false);\n};\ngoog.dom.getNextElementNode_ \x3d function(node, forward) {\n  for (; node \x26\x26 node.nodeType !\x3d goog.dom.NodeType.ELEMENT;) {\n    node \x3d forward ? node.nextSibling : node.previousSibling;\n  }\n  return node;\n};\ngoog.dom.getNextNode \x3d function(node) {\n  if (!node) {\n    return null;\n  }\n  if (node.firstChild) {\n    return node.firstChild;\n  }\n  for (; node \x26\x26 !node.nextSibling;) {\n    node \x3d node.parentNode;\n  }\n  return node ? node.nextSibling : null;\n};\ngoog.dom.getPreviousNode \x3d function(node) {\n  if (!node) {\n    return null;\n  }\n  if (!node.previousSibling) {\n    return node.parentNode;\n  }\n  node \x3d node.previousSibling;\n  for (; node \x26\x26 node.lastChild;) {\n    node \x3d node.lastChild;\n  }\n  return node;\n};\ngoog.dom.isNodeLike \x3d function(obj) {\n  return goog.isObject(obj) \x26\x26 obj.nodeType \x3e 0;\n};\ngoog.dom.isElement \x3d function(obj) {\n  return goog.isObject(obj) \x26\x26 obj.nodeType \x3d\x3d goog.dom.NodeType.ELEMENT;\n};\ngoog.dom.isWindow \x3d function(obj) {\n  return goog.isObject(obj) \x26\x26 obj[\x22window\x22] \x3d\x3d obj;\n};\ngoog.dom.getParentElement \x3d function(element) {\n  var parent;\n  if (goog.dom.BrowserFeature.CAN_USE_PARENT_ELEMENT_PROPERTY) {\n    parent \x3d element.parentElement;\n    if (parent) {\n      return parent;\n    }\n  }\n  parent \x3d element.parentNode;\n  return goog.dom.isElement(parent) ? parent : null;\n};\ngoog.dom.contains \x3d function(parent, descendant) {\n  if (!parent || !descendant) {\n    return false;\n  }\n  if (parent.contains \x26\x26 descendant.nodeType \x3d\x3d goog.dom.NodeType.ELEMENT) {\n    return parent \x3d\x3d descendant || parent.contains(descendant);\n  }\n  if (typeof parent.compareDocumentPosition !\x3d \x22undefined\x22) {\n    return parent \x3d\x3d descendant || Boolean(parent.compareDocumentPosition(descendant) \x26 16);\n  }\n  for (; descendant \x26\x26 parent !\x3d descendant;) {\n    descendant \x3d descendant.parentNode;\n  }\n  return descendant \x3d\x3d parent;\n};\ngoog.dom.compareNodeOrder \x3d function(node1, node2) {\n  if (node1 \x3d\x3d node2) {\n    return 0;\n  }\n  if (node1.compareDocumentPosition) {\n    return node1.compareDocumentPosition(node2) \x26 2 ? 1 : -1;\n  }\n  if (goog.userAgent.IE \x26\x26 !goog.userAgent.isDocumentModeOrHigher(9)) {\n    if (node1.nodeType \x3d\x3d goog.dom.NodeType.DOCUMENT) {\n      return -1;\n    }\n    if (node2.nodeType \x3d\x3d goog.dom.NodeType.DOCUMENT) {\n      return 1;\n    }\n  }\n  if (\x22sourceIndex\x22 in node1 || node1.parentNode \x26\x26 \x22sourceIndex\x22 in node1.parentNode) {\n    var isElement1 \x3d node1.nodeType \x3d\x3d goog.dom.NodeType.ELEMENT;\n    var isElement2 \x3d node2.nodeType \x3d\x3d goog.dom.NodeType.ELEMENT;\n    if (isElement1 \x26\x26 isElement2) {\n      return node1.sourceIndex - node2.sourceIndex;\n    } else {\n      var parent1 \x3d node1.parentNode;\n      var parent2 \x3d node2.parentNode;\n      if (parent1 \x3d\x3d parent2) {\n        return goog.dom.compareSiblingOrder_(node1, node2);\n      }\n      if (!isElement1 \x26\x26 goog.dom.contains(parent1, node2)) {\n        return -1 * goog.dom.compareParentsDescendantNodeIe_(node1, node2);\n      }\n      if (!isElement2 \x26\x26 goog.dom.contains(parent2, node1)) {\n        return goog.dom.compareParentsDescendantNodeIe_(node2, node1);\n      }\n      return (isElement1 ? node1.sourceIndex : parent1.sourceIndex) - (isElement2 ? node2.sourceIndex : parent2.sourceIndex);\n    }\n  }\n  var doc \x3d goog.dom.getOwnerDocument(node1);\n  var range1;\n  var range2;\n  range1 \x3d doc.createRange();\n  range1.selectNode(node1);\n  range1.collapse(true);\n  range2 \x3d doc.createRange();\n  range2.selectNode(node2);\n  range2.collapse(true);\n  return range1.compareBoundaryPoints(goog.global[\x22Range\x22].START_TO_END, range2);\n};\ngoog.dom.compareParentsDescendantNodeIe_ \x3d function(textNode, node) {\n  var parent \x3d textNode.parentNode;\n  if (parent \x3d\x3d node) {\n    return -1;\n  }\n  var sibling \x3d node;\n  for (; sibling.parentNode !\x3d parent;) {\n    sibling \x3d sibling.parentNode;\n  }\n  return goog.dom.compareSiblingOrder_(sibling, textNode);\n};\ngoog.dom.compareSiblingOrder_ \x3d function(node1, node2) {\n  var s \x3d node2;\n  for (; s \x3d s.previousSibling;) {\n    if (s \x3d\x3d node1) {\n      return -1;\n    }\n  }\n  return 1;\n};\ngoog.dom.findCommonAncestor \x3d function(var_args) {\n  var i;\n  var count \x3d arguments.length;\n  if (!count) {\n    return null;\n  } else if (count \x3d\x3d 1) {\n    return arguments[0];\n  }\n  var paths \x3d [];\n  var minLength \x3d Infinity;\n  i \x3d 0;\n  for (; i \x3c count; i++) {\n    var ancestors \x3d [];\n    var node \x3d arguments[i];\n    for (; node;) {\n      ancestors.unshift(node);\n      node \x3d node.parentNode;\n    }\n    paths.push(ancestors);\n    minLength \x3d Math.min(minLength, ancestors.length);\n  }\n  var output \x3d null;\n  i \x3d 0;\n  for (; i \x3c minLength; i++) {\n    var first \x3d paths[0][i];\n    var j \x3d 1;\n    for (; j \x3c count; j++) {\n      if (first !\x3d paths[j][i]) {\n        return output;\n      }\n    }\n    output \x3d first;\n  }\n  return output;\n};\ngoog.dom.isInDocument \x3d function(node) {\n  return (node.ownerDocument.compareDocumentPosition(node) \x26 16) \x3d\x3d 16;\n};\ngoog.dom.getOwnerDocument \x3d function(node) {\n  goog.asserts.assert(node, \x22Node cannot be null or undefined.\x22);\n  return node.nodeType \x3d\x3d goog.dom.NodeType.DOCUMENT ? node : node.ownerDocument || node.document;\n};\ngoog.dom.getFrameContentDocument \x3d function(frame) {\n  return frame.contentDocument || frame.contentWindow.document;\n};\ngoog.dom.getFrameContentWindow \x3d function(frame) {\n  try {\n    return frame.contentWindow || (frame.contentDocument ? goog.dom.getWindow(frame.contentDocument) : null);\n  } catch (e) {\n  }\n  return null;\n};\ngoog.dom.setTextContent \x3d function(node, text) {\n  goog.asserts.assert(node !\x3d null, \x22goog.dom.setTextContent expects a non-null value for node\x22);\n  if (\x22textContent\x22 in node) {\n    node.textContent \x3d text;\n  } else if (node.nodeType \x3d\x3d goog.dom.NodeType.TEXT) {\n    node.data \x3d String(text);\n  } else if (node.firstChild \x26\x26 node.firstChild.nodeType \x3d\x3d goog.dom.NodeType.TEXT) {\n    for (; node.lastChild !\x3d node.firstChild;) {\n      node.removeChild(goog.asserts.assert(node.lastChild));\n    }\n    node.firstChild.data \x3d String(text);\n  } else {\n    goog.dom.removeChildren(node);\n    var doc \x3d goog.dom.getOwnerDocument(node);\n    node.appendChild(doc.createTextNode(String(text)));\n  }\n};\ngoog.dom.getOuterHtml \x3d function(element) {\n  goog.asserts.assert(element !\x3d\x3d null, \x22goog.dom.getOuterHtml expects a non-null value for element\x22);\n  if (\x22outerHTML\x22 in element) {\n    return element.outerHTML;\n  } else {\n    var doc \x3d goog.dom.getOwnerDocument(element);\n    var div \x3d goog.dom.createElement_(doc, goog.dom.TagName.DIV);\n    div.appendChild(element.cloneNode(true));\n    return div.innerHTML;\n  }\n};\ngoog.dom.findNode \x3d function(root, p) {\n  var rv \x3d [];\n  var found \x3d goog.dom.findNodes_(root, p, rv, true);\n  return found ? rv[0] : undefined;\n};\ngoog.dom.findNodes \x3d function(root, p) {\n  var rv \x3d [];\n  goog.dom.findNodes_(root, p, rv, false);\n  return rv;\n};\ngoog.dom.findNodes_ \x3d function(root, p, rv, findOne) {\n  if (root !\x3d null) {\n    var child \x3d root.firstChild;\n    for (; child;) {\n      if (p(child)) {\n        rv.push(child);\n        if (findOne) {\n          return true;\n        }\n      }\n      if (goog.dom.findNodes_(child, p, rv, findOne)) {\n        return true;\n      }\n      child \x3d child.nextSibling;\n    }\n  }\n  return false;\n};\ngoog.dom.findElement \x3d function(root, pred) {\n  var stack \x3d goog.dom.getChildrenReverse_(root);\n  for (; stack.length \x3e 0;) {\n    var next \x3d stack.pop();\n    if (pred(next)) {\n      return next;\n    }\n    var c \x3d next.lastElementChild;\n    for (; c; c \x3d c.previousElementSibling) {\n      stack.push(c);\n    }\n  }\n  return null;\n};\ngoog.dom.findElements \x3d function(root, pred) {\n  var result \x3d [];\n  var stack \x3d goog.dom.getChildrenReverse_(root);\n  for (; stack.length \x3e 0;) {\n    var next \x3d stack.pop();\n    if (pred(next)) {\n      result.push(next);\n    }\n    var c \x3d next.lastElementChild;\n    for (; c; c \x3d c.previousElementSibling) {\n      stack.push(c);\n    }\n  }\n  return result;\n};\ngoog.dom.getChildrenReverse_ \x3d function(node) {\n  if (node.nodeType \x3d\x3d goog.dom.NodeType.DOCUMENT) {\n    return [node.documentElement];\n  } else {\n    var children \x3d [];\n    var c \x3d node.lastElementChild;\n    for (; c; c \x3d c.previousElementSibling) {\n      children.push(c);\n    }\n    return children;\n  }\n};\ngoog.dom.TAGS_TO_IGNORE_ \x3d {\x22SCRIPT\x22:1, \x22STYLE\x22:1, \x22HEAD\x22:1, \x22IFRAME\x22:1, \x22OBJECT\x22:1};\ngoog.dom.PREDEFINED_TAG_VALUES_ \x3d {\x22IMG\x22:\x22 \x22, \x22BR\x22:\x22\\n\x22};\ngoog.dom.isFocusableTabIndex \x3d function(element) {\n  return goog.dom.hasSpecifiedTabIndex_(element) \x26\x26 goog.dom.isTabIndexFocusable_(element);\n};\ngoog.dom.setFocusableTabIndex \x3d function(element, enable) {\n  if (enable) {\n    element.tabIndex \x3d 0;\n  } else {\n    element.tabIndex \x3d -1;\n    element.removeAttribute(\x22tabIndex\x22);\n  }\n};\ngoog.dom.isFocusable \x3d function(element) {\n  var focusable;\n  if (goog.dom.nativelySupportsFocus_(element)) {\n    focusable \x3d !element.disabled \x26\x26 (!goog.dom.hasSpecifiedTabIndex_(element) || goog.dom.isTabIndexFocusable_(element));\n  } else {\n    focusable \x3d goog.dom.isFocusableTabIndex(element);\n  }\n  return focusable \x26\x26 goog.userAgent.IE ? goog.dom.hasNonZeroBoundingRect_(element) : focusable;\n};\ngoog.dom.hasSpecifiedTabIndex_ \x3d function(element) {\n  return element.hasAttribute(\x22tabindex\x22);\n};\ngoog.dom.isTabIndexFocusable_ \x3d function(element) {\n  var index \x3d element.tabIndex;\n  return typeof index \x3d\x3d\x3d \x22number\x22 \x26\x26 index \x3e\x3d 0 \x26\x26 index \x3c 32768;\n};\ngoog.dom.nativelySupportsFocus_ \x3d function(element) {\n  return element.tagName \x3d\x3d goog.dom.TagName.A \x26\x26 element.hasAttribute(\x22href\x22) || element.tagName \x3d\x3d goog.dom.TagName.INPUT || element.tagName \x3d\x3d goog.dom.TagName.TEXTAREA || element.tagName \x3d\x3d goog.dom.TagName.SELECT || element.tagName \x3d\x3d goog.dom.TagName.BUTTON;\n};\ngoog.dom.hasNonZeroBoundingRect_ \x3d function(element) {\n  var rect;\n  if (typeof element[\x22getBoundingClientRect\x22] !\x3d\x3d \x22function\x22 || goog.userAgent.IE \x26\x26 element.parentElement \x3d\x3d null) {\n    rect \x3d {\x22height\x22:element.offsetHeight, \x22width\x22:element.offsetWidth};\n  } else {\n    rect \x3d element.getBoundingClientRect();\n  }\n  return rect !\x3d null \x26\x26 rect.height \x3e 0 \x26\x26 rect.width \x3e 0;\n};\ngoog.dom.getTextContent \x3d function(node) {\n  var textContent;\n  var buf \x3d [];\n  goog.dom.getTextContent_(node, buf, true);\n  textContent \x3d buf.join(\x22\x22);\n  textContent \x3d textContent.replace(/ \\xAD /g, \x22 \x22).replace(/\\xAD/g, \x22\x22);\n  textContent \x3d textContent.replace(/\\u200B/g, \x22\x22);\n  textContent \x3d textContent.replace(/ +/g, \x22 \x22);\n  if (textContent !\x3d \x22 \x22) {\n    textContent \x3d textContent.replace(/^\\s*/, \x22\x22);\n  }\n  return textContent;\n};\ngoog.dom.getRawTextContent \x3d function(node) {\n  var buf \x3d [];\n  goog.dom.getTextContent_(node, buf, false);\n  return buf.join(\x22\x22);\n};\ngoog.dom.getTextContent_ \x3d function(node, buf, normalizeWhitespace) {\n  if (node.nodeName in goog.dom.TAGS_TO_IGNORE_) {\n  } else if (node.nodeType \x3d\x3d goog.dom.NodeType.TEXT) {\n    if (normalizeWhitespace) {\n      buf.push(String(node.nodeValue).replace(/(\\r\\n|\\r|\\n)/g, \x22\x22));\n    } else {\n      buf.push(node.nodeValue);\n    }\n  } else if (node.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) {\n    buf.push(goog.dom.PREDEFINED_TAG_VALUES_[node.nodeName]);\n  } else {\n    var child \x3d node.firstChild;\n    for (; child;) {\n      goog.dom.getTextContent_(child, buf, normalizeWhitespace);\n      child \x3d child.nextSibling;\n    }\n  }\n};\ngoog.dom.getNodeTextLength \x3d function(node) {\n  return goog.dom.getTextContent(node).length;\n};\ngoog.dom.getNodeTextOffset \x3d function(node, opt_offsetParent) {\n  var root \x3d opt_offsetParent || goog.dom.getOwnerDocument(node).body;\n  var buf \x3d [];\n  for (; node \x26\x26 node !\x3d root;) {\n    var cur \x3d node;\n    for (; cur \x3d cur.previousSibling;) {\n      buf.unshift(goog.dom.getTextContent(cur));\n    }\n    node \x3d node.parentNode;\n  }\n  return goog.string.trimLeft(buf.join(\x22\x22)).replace(/ +/g, \x22 \x22).length;\n};\ngoog.dom.getNodeAtOffset \x3d function(parent, offset, opt_result) {\n  var stack \x3d [parent];\n  var pos \x3d 0;\n  var cur \x3d null;\n  for (; stack.length \x3e 0 \x26\x26 pos \x3c offset;) {\n    cur \x3d stack.pop();\n    if (cur.nodeName in goog.dom.TAGS_TO_IGNORE_) {\n    } else if (cur.nodeType \x3d\x3d goog.dom.NodeType.TEXT) {\n      var text \x3d cur.nodeValue.replace(/(\\r\\n|\\r|\\n)/g, \x22\x22).replace(/ +/g, \x22 \x22);\n      pos \x3d pos + text.length;\n    } else if (cur.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) {\n      pos \x3d pos + goog.dom.PREDEFINED_TAG_VALUES_[cur.nodeName].length;\n    } else {\n      var i \x3d cur.childNodes.length - 1;\n      for (; i \x3e\x3d 0; i--) {\n        stack.push(cur.childNodes[i]);\n      }\n    }\n  }\n  if (goog.isObject(opt_result)) {\n    opt_result.remainder \x3d cur ? cur.nodeValue.length + offset - pos - 1 : 0;\n    opt_result.node \x3d cur;\n  }\n  return cur;\n};\ngoog.dom.isNodeList \x3d function(val) {\n  if (val \x26\x26 typeof val.length \x3d\x3d \x22number\x22) {\n    if (goog.isObject(val)) {\n      return typeof val.item \x3d\x3d \x22function\x22 || typeof val.item \x3d\x3d \x22string\x22;\n    } else if (typeof val \x3d\x3d\x3d \x22function\x22) {\n      return typeof val.item \x3d\x3d \x22function\x22;\n    }\n  }\n  return false;\n};\ngoog.dom.getAncestorByTagNameAndClass \x3d function(element, opt_tag, opt_class, opt_maxSearchSteps) {\n  if (!opt_tag \x26\x26 !opt_class) {\n    return null;\n  }\n  var tagName \x3d opt_tag ? String(opt_tag).toUpperCase() : null;\n  return goog.dom.getAncestor(element, function(node) {\n    return (!tagName || node.nodeName \x3d\x3d tagName) \x26\x26 (!opt_class || typeof node.className \x3d\x3d\x3d \x22string\x22 \x26\x26 goog.array.contains(node.className.split(/\\s+/), opt_class));\n  }, true, opt_maxSearchSteps);\n};\ngoog.dom.getAncestorByClass \x3d function(element, className, opt_maxSearchSteps) {\n  return goog.dom.getAncestorByTagNameAndClass(element, null, className, opt_maxSearchSteps);\n};\ngoog.dom.getAncestor \x3d function(element, matcher, opt_includeNode, opt_maxSearchSteps) {\n  if (element \x26\x26 !opt_includeNode) {\n    element \x3d element.parentNode;\n  }\n  var steps \x3d 0;\n  for (; element \x26\x26 (opt_maxSearchSteps \x3d\x3d null || steps \x3c\x3d opt_maxSearchSteps);) {\n    goog.asserts.assert(element.name !\x3d \x22parentNode\x22);\n    if (matcher(element)) {\n      return element;\n    }\n    element \x3d element.parentNode;\n    steps++;\n  }\n  return null;\n};\ngoog.dom.getActiveElement \x3d function(doc) {\n  try {\n    var activeElement \x3d doc \x26\x26 doc.activeElement;\n    return activeElement \x26\x26 activeElement.nodeName ? activeElement : null;\n  } catch (e) {\n    return null;\n  }\n};\ngoog.dom.getPixelRatio \x3d function() {\n  var win \x3d goog.dom.getWindow();\n  if (win.devicePixelRatio !\x3d\x3d undefined) {\n    return win.devicePixelRatio;\n  } else if (win.matchMedia) {\n    return goog.dom.matchesPixelRatio_(3) || goog.dom.matchesPixelRatio_(2) || goog.dom.matchesPixelRatio_(1.5) || goog.dom.matchesPixelRatio_(1) || .75;\n  }\n  return 1;\n};\ngoog.dom.matchesPixelRatio_ \x3d function(pixelRatio) {\n  var win \x3d goog.dom.getWindow();\n  var dpiPerDppx \x3d 96;\n  var query \x3d \x22(min-resolution: \x22 + pixelRatio + \x22dppx),\x22 + \x22(min--moz-device-pixel-ratio: \x22 + pixelRatio + \x22),\x22 + \x22(min-resolution: \x22 + pixelRatio * dpiPerDppx + \x22dpi)\x22;\n  return win.matchMedia(query).matches ? pixelRatio : 0;\n};\ngoog.dom.getCanvasContext2D \x3d function(canvas) {\n  return canvas.getContext(\x222d\x22);\n};\ngoog.dom.DomHelper \x3d function(opt_document) {\n  this.document_ \x3d opt_document || goog.global.document || document;\n};\ngoog.dom.DomHelper.prototype.getDomHelper \x3d goog.dom.getDomHelper;\ngoog.dom.DomHelper.prototype.setDocument \x3d function(document) {\n  this.document_ \x3d document;\n};\ngoog.dom.DomHelper.prototype.getDocument \x3d function() {\n  return this.document_;\n};\ngoog.dom.DomHelper.prototype.getElement \x3d function(element) {\n  return goog.dom.getElementHelper_(this.document_, element);\n};\ngoog.dom.DomHelper.prototype.getRequiredElement \x3d function(id) {\n  return goog.dom.getRequiredElementHelper_(this.document_, id);\n};\ngoog.dom.DomHelper.prototype.$ \x3d goog.dom.DomHelper.prototype.getElement;\ngoog.dom.DomHelper.prototype.getElementsByTagName \x3d function(tagName, opt_parent) {\n  var parent \x3d opt_parent || this.document_;\n  return parent.getElementsByTagName(String(tagName));\n};\ngoog.dom.DomHelper.prototype.getElementsByTagNameAndClass \x3d function(opt_tag, opt_class, opt_el) {\n  return goog.dom.getElementsByTagNameAndClass_(this.document_, opt_tag, opt_class, opt_el);\n};\ngoog.dom.DomHelper.prototype.getElementByTagNameAndClass \x3d function(opt_tag, opt_class, opt_el) {\n  return goog.dom.getElementByTagNameAndClass_(this.document_, opt_tag, opt_class, opt_el);\n};\ngoog.dom.DomHelper.prototype.getElementsByClass \x3d function(className, opt_el) {\n  var doc \x3d opt_el || this.document_;\n  return goog.dom.getElementsByClass(className, doc);\n};\ngoog.dom.DomHelper.prototype.getElementByClass \x3d function(className, opt_el) {\n  var doc \x3d opt_el || this.document_;\n  return goog.dom.getElementByClass(className, doc);\n};\ngoog.dom.DomHelper.prototype.getRequiredElementByClass \x3d function(className, opt_root) {\n  var root \x3d opt_root || this.document_;\n  return goog.dom.getRequiredElementByClass(className, root);\n};\ngoog.dom.DomHelper.prototype.$$ \x3d goog.dom.DomHelper.prototype.getElementsByTagNameAndClass;\ngoog.dom.DomHelper.prototype.setProperties \x3d goog.dom.setProperties;\ngoog.dom.DomHelper.prototype.getViewportSize \x3d function(opt_window) {\n  return goog.dom.getViewportSize(opt_window || this.getWindow());\n};\ngoog.dom.DomHelper.prototype.getDocumentHeight \x3d function() {\n  return goog.dom.getDocumentHeight_(this.getWindow());\n};\ngoog.dom.Appendable;\ngoog.dom.DomHelper.prototype.createDom \x3d function(tagName, opt_attributes, var_args) {\n  return goog.dom.createDom_(this.document_, arguments);\n};\ngoog.dom.DomHelper.prototype.$dom \x3d goog.dom.DomHelper.prototype.createDom;\ngoog.dom.DomHelper.prototype.createElement \x3d function(name) {\n  return goog.dom.createElement_(this.document_, name);\n};\ngoog.dom.DomHelper.prototype.createTextNode \x3d function(content) {\n  return this.document_.createTextNode(String(content));\n};\ngoog.dom.DomHelper.prototype.createTable \x3d function(rows, columns, opt_fillWithNbsp) {\n  return goog.dom.createTable_(this.document_, rows, columns, !!opt_fillWithNbsp);\n};\ngoog.dom.DomHelper.prototype.safeHtmlToNode \x3d function(html) {\n  return goog.dom.safeHtmlToNode_(this.document_, html);\n};\ngoog.dom.DomHelper.prototype.isCss1CompatMode \x3d function() {\n  return goog.dom.isCss1CompatMode_(this.document_);\n};\ngoog.dom.DomHelper.prototype.getWindow \x3d function() {\n  return goog.dom.getWindow_(this.document_);\n};\ngoog.dom.DomHelper.prototype.getDocumentScrollElement \x3d function() {\n  return goog.dom.getDocumentScrollElement_(this.document_);\n};\ngoog.dom.DomHelper.prototype.getDocumentScroll \x3d function() {\n  return goog.dom.getDocumentScroll_(this.document_);\n};\ngoog.dom.DomHelper.prototype.getActiveElement \x3d function(opt_doc) {\n  return goog.dom.getActiveElement(opt_doc || this.document_);\n};\ngoog.dom.DomHelper.prototype.appendChild \x3d goog.dom.appendChild;\ngoog.dom.DomHelper.prototype.append \x3d goog.dom.append;\ngoog.dom.DomHelper.prototype.canHaveChildren \x3d goog.dom.canHaveChildren;\ngoog.dom.DomHelper.prototype.removeChildren \x3d goog.dom.removeChildren;\ngoog.dom.DomHelper.prototype.insertSiblingBefore \x3d goog.dom.insertSiblingBefore;\ngoog.dom.DomHelper.prototype.insertSiblingAfter \x3d goog.dom.insertSiblingAfter;\ngoog.dom.DomHelper.prototype.insertChildAt \x3d goog.dom.insertChildAt;\ngoog.dom.DomHelper.prototype.removeNode \x3d goog.dom.removeNode;\ngoog.dom.DomHelper.prototype.replaceNode \x3d goog.dom.replaceNode;\ngoog.dom.DomHelper.prototype.copyContents \x3d goog.dom.copyContents;\ngoog.dom.DomHelper.prototype.flattenElement \x3d goog.dom.flattenElement;\ngoog.dom.DomHelper.prototype.getChildren \x3d goog.dom.getChildren;\ngoog.dom.DomHelper.prototype.getFirstElementChild \x3d goog.dom.getFirstElementChild;\ngoog.dom.DomHelper.prototype.getLastElementChild \x3d goog.dom.getLastElementChild;\ngoog.dom.DomHelper.prototype.getNextElementSibling \x3d goog.dom.getNextElementSibling;\ngoog.dom.DomHelper.prototype.getPreviousElementSibling \x3d goog.dom.getPreviousElementSibling;\ngoog.dom.DomHelper.prototype.getNextNode \x3d goog.dom.getNextNode;\ngoog.dom.DomHelper.prototype.getPreviousNode \x3d goog.dom.getPreviousNode;\ngoog.dom.DomHelper.prototype.isNodeLike \x3d goog.dom.isNodeLike;\ngoog.dom.DomHelper.prototype.isElement \x3d goog.dom.isElement;\ngoog.dom.DomHelper.prototype.isWindow \x3d goog.dom.isWindow;\ngoog.dom.DomHelper.prototype.getParentElement \x3d goog.dom.getParentElement;\ngoog.dom.DomHelper.prototype.contains \x3d goog.dom.contains;\ngoog.dom.DomHelper.prototype.compareNodeOrder \x3d goog.dom.compareNodeOrder;\ngoog.dom.DomHelper.prototype.findCommonAncestor \x3d goog.dom.findCommonAncestor;\ngoog.dom.DomHelper.prototype.getOwnerDocument \x3d goog.dom.getOwnerDocument;\ngoog.dom.DomHelper.prototype.getFrameContentDocument \x3d goog.dom.getFrameContentDocument;\ngoog.dom.DomHelper.prototype.getFrameContentWindow \x3d goog.dom.getFrameContentWindow;\ngoog.dom.DomHelper.prototype.setTextContent \x3d goog.dom.setTextContent;\ngoog.dom.DomHelper.prototype.getOuterHtml \x3d goog.dom.getOuterHtml;\ngoog.dom.DomHelper.prototype.findNode \x3d goog.dom.findNode;\ngoog.dom.DomHelper.prototype.findNodes \x3d goog.dom.findNodes;\ngoog.dom.DomHelper.prototype.isFocusableTabIndex \x3d goog.dom.isFocusableTabIndex;\ngoog.dom.DomHelper.prototype.setFocusableTabIndex \x3d goog.dom.setFocusableTabIndex;\ngoog.dom.DomHelper.prototype.isFocusable \x3d goog.dom.isFocusable;\ngoog.dom.DomHelper.prototype.getTextContent \x3d goog.dom.getTextContent;\ngoog.dom.DomHelper.prototype.getNodeTextLength \x3d goog.dom.getNodeTextLength;\ngoog.dom.DomHelper.prototype.getNodeTextOffset \x3d goog.dom.getNodeTextOffset;\ngoog.dom.DomHelper.prototype.getNodeAtOffset \x3d goog.dom.getNodeAtOffset;\ngoog.dom.DomHelper.prototype.isNodeList \x3d goog.dom.isNodeList;\ngoog.dom.DomHelper.prototype.getAncestorByTagNameAndClass \x3d goog.dom.getAncestorByTagNameAndClass;\ngoog.dom.DomHelper.prototype.getAncestorByClass \x3d goog.dom.getAncestorByClass;\ngoog.dom.DomHelper.prototype.getAncestor \x3d goog.dom.getAncestor;\ngoog.dom.DomHelper.prototype.getCanvasContext2D \x3d goog.dom.getCanvasContext2D;\n");
SHADOW_ENV.evalLoad("goog.useragent.product.js", true, "goog.provide(\x22goog.userAgent.product\x22);\ngoog.require(\x22goog.labs.userAgent.browser\x22);\ngoog.require(\x22goog.labs.userAgent.platform\x22);\ngoog.require(\x22goog.userAgent\x22);\ngoog.userAgent.product.ASSUME_FIREFOX \x3d goog.define(\x22goog.userAgent.product.ASSUME_FIREFOX\x22, false);\ngoog.userAgent.product.ASSUME_IPHONE \x3d goog.define(\x22goog.userAgent.product.ASSUME_IPHONE\x22, false);\ngoog.userAgent.product.ASSUME_IPAD \x3d goog.define(\x22goog.userAgent.product.ASSUME_IPAD\x22, false);\ngoog.userAgent.product.ASSUME_ANDROID \x3d goog.define(\x22goog.userAgent.product.ASSUME_ANDROID\x22, false);\ngoog.userAgent.product.ASSUME_CHROME \x3d goog.define(\x22goog.userAgent.product.ASSUME_CHROME\x22, false);\ngoog.userAgent.product.ASSUME_SAFARI \x3d goog.define(\x22goog.userAgent.product.ASSUME_SAFARI\x22, false);\ngoog.userAgent.product.PRODUCT_KNOWN_ \x3d goog.userAgent.ASSUME_IE || goog.userAgent.ASSUME_EDGE || goog.userAgent.ASSUME_OPERA || goog.userAgent.product.ASSUME_FIREFOX || goog.userAgent.product.ASSUME_IPHONE || goog.userAgent.product.ASSUME_IPAD || goog.userAgent.product.ASSUME_ANDROID || goog.userAgent.product.ASSUME_CHROME || goog.userAgent.product.ASSUME_SAFARI;\ngoog.userAgent.product.OPERA \x3d goog.userAgent.OPERA;\ngoog.userAgent.product.IE \x3d goog.userAgent.IE;\ngoog.userAgent.product.EDGE \x3d goog.userAgent.EDGE;\ngoog.userAgent.product.FIREFOX \x3d goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_FIREFOX : goog.labs.userAgent.browser.isFirefox();\ngoog.userAgent.product.isIphoneOrIpod_ \x3d function() {\n  return goog.labs.userAgent.platform.isIphone() || goog.labs.userAgent.platform.isIpod();\n};\ngoog.userAgent.product.IPHONE \x3d goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_IPHONE : goog.userAgent.product.isIphoneOrIpod_();\ngoog.userAgent.product.IPAD \x3d goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_IPAD : goog.labs.userAgent.platform.isIpad();\ngoog.userAgent.product.ANDROID \x3d goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_ANDROID : goog.labs.userAgent.browser.isAndroidBrowser();\ngoog.userAgent.product.CHROME \x3d goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_CHROME : goog.labs.userAgent.browser.isChrome();\ngoog.userAgent.product.isSafariDesktop_ \x3d function() {\n  return goog.labs.userAgent.browser.isSafari() \x26\x26 !goog.labs.userAgent.platform.isIos();\n};\ngoog.userAgent.product.SAFARI \x3d goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_SAFARI : goog.userAgent.product.isSafariDesktop_();\n");
SHADOW_ENV.evalLoad("shadow.json.js", true, "goog.provide(\x27shadow.json\x27);\ngoog.scope(function(){\n  shadow.json.goog$module$goog$object \x3d goog.module.get(\x27goog.object\x27);\n});\n/**\n * simplified js-\x3eclj for JSON data, :key-fn default to keyword\n */\nshadow.json.to_clj \x3d (function shadow$json$to_clj(var_args){\nvar G__19726 \x3d arguments.length;\nswitch (G__19726) {\ncase 1:\nreturn shadow.json.to_clj.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.json.to_clj.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.json.to_clj.cljs$core$IFn$_invoke$arity$1 \x3d (function (x){\nreturn shadow.json.to_clj.cljs$core$IFn$_invoke$arity$2(x,cljs.core.PersistentArrayMap.EMPTY);\n}));\n\n(shadow.json.to_clj.cljs$core$IFn$_invoke$arity$2 \x3d (function (x,opts){\nif((x \x3d\x3d null)){\nreturn x;\n} else {\nif(typeof x \x3d\x3d\x3d \x27number\x27){\nreturn x;\n} else {\nif(typeof x \x3d\x3d\x3d \x27string\x27){\nreturn x;\n} else {\nif(cljs.core.boolean_QMARK_(x)){\nreturn x;\n} else {\nif(cljs.core.array_QMARK_(x)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$1((function (p1__19722_SHARP_){\nreturn shadow.json.to_clj.cljs$core$IFn$_invoke$arity$2(p1__19722_SHARP_,opts);\n})),cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1(x));\n} else {\nvar key_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(opts,new cljs.core.Keyword(null,\x22key-fn\x22,\x22key-fn\x22,-636154479),cljs.core.keyword);\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (result,key){\nvar value \x3d shadow.json.goog$module$goog$object.get(x,key);\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(result,((typeof key \x3d\x3d\x3d \x27string\x27)?(key_fn.cljs$core$IFn$_invoke$arity$1 ? key_fn.cljs$core$IFn$_invoke$arity$1(key) : key_fn.call(null, key)):shadow.json.to_clj.cljs$core$IFn$_invoke$arity$2(key,opts)),shadow.json.to_clj.cljs$core$IFn$_invoke$arity$2(value,opts));\n}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),shadow.json.goog$module$goog$object.getKeys(x)));\n\n}\n}\n}\n}\n}\n}));\n\n(shadow.json.to_clj.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.json.read_str \x3d (function shadow$json$read_str(str,opts){\nreturn shadow.json.to_clj.cljs$core$IFn$_invoke$arity$2(JSON.parse(str),opts);\n});\nshadow.json.write_str \x3d (function shadow$json$write_str(obj){\nreturn JSON.stringify(cljs.core.clj__GT_js(obj));\n});\n");
SHADOW_ENV.evalLoad("clojure.set.js", true, "goog.provide(\x27clojure.set\x27);\nclojure.set.bubble_max_key \x3d (function clojure$set$bubble_max_key(k,coll){\n\nvar max \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.max_key,k,coll);\nreturn cljs.core.cons(max,cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p1__19775_SHARP_){\nreturn (max \x3d\x3d\x3d p1__19775_SHARP_);\n}),coll));\n});\n/**\n * Return a set that is the union of the input sets\n */\nclojure.set.union \x3d (function clojure$set$union(var_args){\nvar G__19781 \x3d arguments.length;\nswitch (G__19781) {\ncase 0:\nreturn clojure.set.union.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn clojure.set.union.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn clojure.set.union.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___19947 \x3d arguments.length;\nvar i__5727__auto___19949 \x3d (0);\nwhile(true){\nif((i__5727__auto___19949 \x3c len__5726__auto___19947)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___19949]));\n\nvar G__19952 \x3d (i__5727__auto___19949 + (1));\ni__5727__auto___19949 \x3d G__19952;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn clojure.set.union.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(clojure.set.union.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.PersistentHashSet.EMPTY;\n}));\n\n(clojure.set.union.cljs$core$IFn$_invoke$arity$1 \x3d (function (s1){\nreturn s1;\n}));\n\n(clojure.set.union.cljs$core$IFn$_invoke$arity$2 \x3d (function (s1,s2){\nif((cljs.core.count(s1) \x3c cljs.core.count(s2))){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,s2,s1);\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,s1,s2);\n}\n}));\n\n(clojure.set.union.cljs$core$IFn$_invoke$arity$variadic \x3d (function (s1,s2,sets){\nvar bubbled_sets \x3d clojure.set.bubble_max_key(cljs.core.count,cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(sets,s2,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([s1], 0)));\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.into,cljs.core.first(bubbled_sets),cljs.core.rest(bubbled_sets));\n}));\n\n/** @this {Function} */\n(clojure.set.union.cljs$lang$applyTo \x3d (function (seq19778){\nvar G__19779 \x3d cljs.core.first(seq19778);\nvar seq19778__$1 \x3d cljs.core.next(seq19778);\nvar G__19780 \x3d cljs.core.first(seq19778__$1);\nvar seq19778__$2 \x3d cljs.core.next(seq19778__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19779,G__19780,seq19778__$2);\n}));\n\n(clojure.set.union.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Return a set that is the intersection of the input sets\n */\nclojure.set.intersection \x3d (function clojure$set$intersection(var_args){\nvar G__19808 \x3d arguments.length;\nswitch (G__19808) {\ncase 1:\nreturn clojure.set.intersection.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn clojure.set.intersection.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___19984 \x3d arguments.length;\nvar i__5727__auto___19989 \x3d (0);\nwhile(true){\nif((i__5727__auto___19989 \x3c len__5726__auto___19984)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___19989]));\n\nvar G__19991 \x3d (i__5727__auto___19989 + (1));\ni__5727__auto___19989 \x3d G__19991;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn clojure.set.intersection.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(clojure.set.intersection.cljs$core$IFn$_invoke$arity$1 \x3d (function (s1){\nreturn s1;\n}));\n\n(clojure.set.intersection.cljs$core$IFn$_invoke$arity$2 \x3d (function (s1,s2){\nwhile(true){\nif((cljs.core.count(s2) \x3c cljs.core.count(s1))){\nvar G__19993 \x3d s2;\nvar G__19994 \x3d s1;\ns1 \x3d G__19993;\ns2 \x3d G__19994;\ncontinue;\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (s1,s2){\nreturn (function (result,item){\nif(cljs.core.contains_QMARK_(s2,item)){\nreturn result;\n} else {\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$2(result,item);\n}\n});})(s1,s2))\n,s1,s1);\n}\nbreak;\n}\n}));\n\n(clojure.set.intersection.cljs$core$IFn$_invoke$arity$variadic \x3d (function (s1,s2,sets){\nvar bubbled_sets \x3d clojure.set.bubble_max_key((function (p1__19801_SHARP_){\nreturn (- cljs.core.count(p1__19801_SHARP_));\n}),cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(sets,s2,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([s1], 0)));\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(clojure.set.intersection,cljs.core.first(bubbled_sets),cljs.core.rest(bubbled_sets));\n}));\n\n/** @this {Function} */\n(clojure.set.intersection.cljs$lang$applyTo \x3d (function (seq19805){\nvar G__19806 \x3d cljs.core.first(seq19805);\nvar seq19805__$1 \x3d cljs.core.next(seq19805);\nvar G__19807 \x3d cljs.core.first(seq19805__$1);\nvar seq19805__$2 \x3d cljs.core.next(seq19805__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19806,G__19807,seq19805__$2);\n}));\n\n(clojure.set.intersection.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Return a set that is the first set without elements of the remaining sets\n */\nclojure.set.difference \x3d (function clojure$set$difference(var_args){\nvar G__19817 \x3d arguments.length;\nswitch (G__19817) {\ncase 1:\nreturn clojure.set.difference.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn clojure.set.difference.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___20006 \x3d arguments.length;\nvar i__5727__auto___20007 \x3d (0);\nwhile(true){\nif((i__5727__auto___20007 \x3c len__5726__auto___20006)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___20007]));\n\nvar G__20010 \x3d (i__5727__auto___20007 + (1));\ni__5727__auto___20007 \x3d G__20010;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((2) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);\nreturn clojure.set.difference.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);\n\n}\n});\n\n(clojure.set.difference.cljs$core$IFn$_invoke$arity$1 \x3d (function (s1){\nreturn s1;\n}));\n\n(clojure.set.difference.cljs$core$IFn$_invoke$arity$2 \x3d (function (s1,s2){\nif((cljs.core.count(s1) \x3c cljs.core.count(s2))){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (result,item){\nif(cljs.core.contains_QMARK_(s2,item)){\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$2(result,item);\n} else {\nreturn result;\n}\n}),s1,s1);\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.disj,s1,s2);\n}\n}));\n\n(clojure.set.difference.cljs$core$IFn$_invoke$arity$variadic \x3d (function (s1,s2,sets){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(clojure.set.difference,s1,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(sets,s2));\n}));\n\n/** @this {Function} */\n(clojure.set.difference.cljs$lang$applyTo \x3d (function (seq19814){\nvar G__19815 \x3d cljs.core.first(seq19814);\nvar seq19814__$1 \x3d cljs.core.next(seq19814);\nvar G__19816 \x3d cljs.core.first(seq19814__$1);\nvar seq19814__$2 \x3d cljs.core.next(seq19814__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19815,G__19816,seq19814__$2);\n}));\n\n(clojure.set.difference.cljs$lang$maxFixedArity \x3d (2));\n\n/**\n * Returns a set of the elements for which pred is true\n */\nclojure.set.select \x3d (function clojure$set$select(pred,xset){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (s,k){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(k) : pred.call(null, k)))){\nreturn s;\n} else {\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$2(s,k);\n}\n}),xset,xset);\n});\n/**\n * Returns a rel of the elements of xrel with only the keys in ks\n */\nclojure.set.project \x3d (function clojure$set$project(xrel,ks){\nreturn cljs.core.set(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__19836_SHARP_){\nreturn cljs.core.select_keys(p1__19836_SHARP_,ks);\n}),xrel));\n});\n/**\n * Returns the map with the keys in kmap renamed to the vals in kmap\n */\nclojure.set.rename_keys \x3d (function clojure$set$rename_keys(map,kmap){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,p__19842){\nvar vec__19844 \x3d p__19842;\nvar old \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19844,(0),null);\nvar new$ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19844,(1),null);\nif(cljs.core.contains_QMARK_(map,old)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,new$,cljs.core.get.cljs$core$IFn$_invoke$arity$2(map,old));\n} else {\nreturn m;\n}\n}),cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.dissoc,map,cljs.core.keys(kmap)),kmap);\n});\n/**\n * Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap\n */\nclojure.set.rename \x3d (function clojure$set$rename(xrel,kmap){\nreturn cljs.core.set(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__19850_SHARP_){\nreturn clojure.set.rename_keys(p1__19850_SHARP_,kmap);\n}),xrel));\n});\n/**\n * Returns a map of the distinct values of ks in the xrel mapped to a\n *   set of the maps in xrel with the corresponding values of ks.\n */\nclojure.set.index \x3d (function clojure$set$index(xrel,ks){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,x){\nvar ik \x3d cljs.core.select_keys(x,ks);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,ik,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(m,ik,cljs.core.PersistentHashSet.EMPTY),x));\n}),cljs.core.PersistentArrayMap.EMPTY,xrel);\n});\n/**\n * Returns the map with the vals mapped to the keys.\n */\nclojure.set.map_invert \x3d (function clojure$set$map_invert(m){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce_kv((function (m__$1,k,v){\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(m__$1,v,k);\n}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),m));\n});\n/**\n * When passed 2 rels, returns the rel corresponding to the natural\n *   join. When passed an additional keymap, joins on the corresponding\n *   keys.\n */\nclojure.set.join \x3d (function clojure$set$join(var_args){\nvar G__19871 \x3d arguments.length;\nswitch (G__19871) {\ncase 2:\nreturn clojure.set.join.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn clojure.set.join.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(clojure.set.join.cljs$core$IFn$_invoke$arity$2 \x3d (function (xrel,yrel){\nif(((cljs.core.seq(xrel)) \x26\x26 (cljs.core.seq(yrel)))){\nvar ks \x3d clojure.set.intersection.cljs$core$IFn$_invoke$arity$2(cljs.core.set(cljs.core.keys(cljs.core.first(xrel))),cljs.core.set(cljs.core.keys(cljs.core.first(yrel))));\nvar vec__19876 \x3d (((cljs.core.count(xrel) \x3c\x3d cljs.core.count(yrel)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel,yrel], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel,xrel], null));\nvar r \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19876,(0),null);\nvar s \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19876,(1),null);\nvar idx \x3d clojure.set.index(r,ks);\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret,x){\nvar found \x3d (function (){var G__19892 \x3d cljs.core.select_keys(x,ks);\nreturn (idx.cljs$core$IFn$_invoke$arity$1 ? idx.cljs$core$IFn$_invoke$arity$1(G__19892) : idx.call(null, G__19892));\n})();\nif(cljs.core.truth_(found)){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19861_SHARP_,p2__19862_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__19861_SHARP_,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([p2__19862_SHARP_,x], 0)));\n}),ret,found);\n} else {\nreturn ret;\n}\n}),cljs.core.PersistentHashSet.EMPTY,s);\n} else {\nreturn cljs.core.PersistentHashSet.EMPTY;\n}\n}));\n\n(clojure.set.join.cljs$core$IFn$_invoke$arity$3 \x3d (function (xrel,yrel,km){\nvar vec__19897 \x3d (((cljs.core.count(xrel) \x3c\x3d cljs.core.count(yrel)))?new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel,yrel,clojure.set.map_invert(km)], null):new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel,xrel,km], null));\nvar r \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19897,(0),null);\nvar s \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19897,(1),null);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19897,(2),null);\nvar idx \x3d clojure.set.index(r,cljs.core.vals(k));\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret,x){\nvar found \x3d (function (){var G__19903 \x3d clojure.set.rename_keys(cljs.core.select_keys(x,cljs.core.keys(k)),k);\nreturn (idx.cljs$core$IFn$_invoke$arity$1 ? idx.cljs$core$IFn$_invoke$arity$1(G__19903) : idx.call(null, G__19903));\n})();\nif(cljs.core.truth_(found)){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__19864_SHARP_,p2__19865_SHARP_){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__19864_SHARP_,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([p2__19865_SHARP_,x], 0)));\n}),ret,found);\n} else {\nreturn ret;\n}\n}),cljs.core.PersistentHashSet.EMPTY,s);\n}));\n\n(clojure.set.join.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Is set1 a subset of set2?\n */\nclojure.set.subset_QMARK_ \x3d (function clojure$set$subset_QMARK_(set1,set2){\nreturn (((cljs.core.count(set1) \x3c\x3d cljs.core.count(set2))) \x26\x26 (cljs.core.every_QMARK_((function (p1__19909_SHARP_){\nreturn cljs.core.contains_QMARK_(set2,p1__19909_SHARP_);\n}),set1)));\n});\n/**\n * Is set1 a superset of set2?\n */\nclojure.set.superset_QMARK_ \x3d (function clojure$set$superset_QMARK_(set1,set2){\nreturn (((cljs.core.count(set1) \x3e\x3d cljs.core.count(set2))) \x26\x26 (cljs.core.every_QMARK_((function (p1__19919_SHARP_){\nreturn cljs.core.contains_QMARK_(set1,p1__19919_SHARP_);\n}),set2)));\n});\n");
SHADOW_ENV.evalLoad("shadow.cljs.devtools.client.env.js", true, "goog.provide(\x27shadow.cljs.devtools.client.env\x27);\ngoog.scope(function(){\n  shadow.cljs.devtools.client.env.goog$module$goog$object \x3d goog.module.get(\x27goog.object\x27);\n});\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env.active_modules_ref !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.env.active_modules_ref \x3d cljs.core.volatile_BANG_(cljs.core.PersistentHashSet.EMPTY);\n}\nshadow.cljs.devtools.client.env.module_loaded \x3d (function shadow$cljs$devtools$client$env$module_loaded(name){\nreturn shadow.cljs.devtools.client.env.active_modules_ref.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, cljs.core.conj.cljs$core$IFn$_invoke$arity$2(shadow.cljs.devtools.client.env.active_modules_ref.cljs$core$IDeref$_deref$arity$1(null, ),cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(name)));\n});\nshadow.cljs.devtools.client.env.module_is_active_QMARK_ \x3d (function shadow$cljs$devtools$client$env$module_is_active_QMARK_(module){\nreturn cljs.core.contains_QMARK_(cljs.core.deref(shadow.cljs.devtools.client.env.active_modules_ref),module);\n});\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env.runtime_id !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.env.runtime_id \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.random_uuid());\n}\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.enabled \x3d goog.define(\x22shadow.cljs.devtools.client.env.enabled\x22,false);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.log \x3d goog.define(\x22shadow.cljs.devtools.client.env.log\x22,true);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.autoload \x3d goog.define(\x22shadow.cljs.devtools.client.env.autoload\x22,true);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.module_format \x3d goog.define(\x22shadow.cljs.devtools.client.env.module_format\x22,\x22goog\x22);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.reload_with_state \x3d goog.define(\x22shadow.cljs.devtools.client.env.reload_with_state\x22,false);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.build_id \x3d goog.define(\x22shadow.cljs.devtools.client.env.build_id\x22,\x22\x22);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.proc_id \x3d goog.define(\x22shadow.cljs.devtools.client.env.proc_id\x22,\x22\x22);\n/**\n * @define {number}\n */\nshadow.cljs.devtools.client.env.worker_client_id \x3d goog.define(\x22shadow.cljs.devtools.client.env.worker_client_id\x22,(0));\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.server_host \x3d goog.define(\x22shadow.cljs.devtools.client.env.server_host\x22,\x22\x22);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.server_hosts \x3d goog.define(\x22shadow.cljs.devtools.client.env.server_hosts\x22,\x22\x22);\n/**\n * @define {number}\n */\nshadow.cljs.devtools.client.env.connect_timeout \x3d goog.define(\x22shadow.cljs.devtools.client.env.connect_timeout\x22,(1000));\nshadow.cljs.devtools.client.env.selected_host \x3d null;\n/**\n * @define {number}\n */\nshadow.cljs.devtools.client.env.server_port \x3d goog.define(\x22shadow.cljs.devtools.client.env.server_port\x22,(8200));\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.repl_pprint \x3d goog.define(\x22shadow.cljs.devtools.client.env.repl_pprint\x22,false);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.use_document_host \x3d goog.define(\x22shadow.cljs.devtools.client.env.use_document_host\x22,true);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.use_document_protocol \x3d goog.define(\x22shadow.cljs.devtools.client.env.use_document_protocol\x22,false);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.devtools_url \x3d goog.define(\x22shadow.cljs.devtools.client.env.devtools_url\x22,\x22\x22);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.reload_strategy \x3d goog.define(\x22shadow.cljs.devtools.client.env.reload_strategy\x22,\x22optimized\x22);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.server_token \x3d goog.define(\x22shadow.cljs.devtools.client.env.server_token\x22,\x22missing\x22);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.ssl \x3d goog.define(\x22shadow.cljs.devtools.client.env.ssl\x22,false);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.env.ignore_warnings \x3d goog.define(\x22shadow.cljs.devtools.client.env.ignore_warnings\x22,false);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.log_style \x3d goog.define(\x22shadow.cljs.devtools.client.env.log_style\x22,\x22font-weight: bold;\x22);\n/**\n * @define {string}\n */\nshadow.cljs.devtools.client.env.custom_notify_fn \x3d goog.define(\x22shadow.cljs.devtools.client.env.custom_notify_fn\x22,\x22\x22);\nshadow.cljs.devtools.client.env.devtools_info \x3d (function shadow$cljs$devtools$client$env$devtools_info(){\nreturn ({\x22server_port\x22: shadow.cljs.devtools.client.env.server_port, \x22server_host\x22: shadow.cljs.devtools.client.env.server_host, \x22build_id\x22: shadow.cljs.devtools.client.env.build_id, \x22proc_id\x22: shadow.cljs.devtools.client.env.proc_id, \x22runtime_id\x22: shadow.cljs.devtools.client.env.runtime_id, \x22ssl\x22: shadow.cljs.devtools.client.env.ssl});\n});\nshadow.cljs.devtools.client.env.get_server_protocol \x3d (function shadow$cljs$devtools$client$env$get_server_protocol(){\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d shadow.cljs.devtools.client.env.use_document_protocol;\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d goog.global.location;\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn cljs.core.seq(goog.global.location.protocol);\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn clojure.string.replace(goog.global.location.protocol,\x22:\x22,\x22\x22);\n} else {\nreturn [\x22http\x22,((shadow.cljs.devtools.client.env.ssl)?\x22s\x22:null)].join(\x27\x27);\n}\n});\nshadow.cljs.devtools.client.env.get_server_host \x3d (function shadow$cljs$devtools$client$env$get_server_host(){\nif(cljs.core.seq(shadow.cljs.devtools.client.env.selected_host)){\nreturn shadow.cljs.devtools.client.env.selected_host;\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d shadow.cljs.devtools.client.env.use_document_host;\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d goog.global.location;\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn cljs.core.seq(goog.global.location.hostname);\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn goog.global.location.hostname;\n} else {\nif(cljs.core.seq(shadow.cljs.devtools.client.env.server_host)){\nreturn shadow.cljs.devtools.client.env.server_host;\n} else {\nreturn \x22localhost\x22;\n\n}\n}\n}\n});\nshadow.cljs.devtools.client.env.get_url_base \x3d (function shadow$cljs$devtools$client$env$get_url_base(){\nif(cljs.core.seq(shadow.cljs.devtools.client.env.devtools_url)){\nreturn shadow.cljs.devtools.client.env.devtools_url;\n} else {\nreturn [shadow.cljs.devtools.client.env.get_server_protocol(),\x22://\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.env.get_server_host()),\x22:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.env.server_port)].join(\x27\x27);\n}\n});\nshadow.cljs.devtools.client.env.get_ws_url_base \x3d (function shadow$cljs$devtools$client$env$get_ws_url_base(){\nreturn clojure.string.replace(shadow.cljs.devtools.client.env.get_url_base(),/^http/,\x22ws\x22);\n});\nshadow.cljs.devtools.client.env.get_ws_relay_path \x3d (function shadow$cljs$devtools$client$env$get_ws_relay_path(){\nreturn [\x22/api/remote-relay?server-token\x3d\x22,shadow.cljs.devtools.client.env.server_token].join(\x27\x27);\n});\nshadow.cljs.devtools.client.env.get_ws_relay_url \x3d (function shadow$cljs$devtools$client$env$get_ws_relay_url(){\nreturn [shadow.cljs.devtools.client.env.get_ws_url_base(),shadow.cljs.devtools.client.env.get_ws_relay_path()].join(\x27\x27);\n});\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env.reset_print_fn_ref !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.env.reset_print_fn_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(null);\n}\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.env.was_print_newline !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.env.was_print_newline \x3d cljs.core._STAR_print_newline_STAR_;\n}\nshadow.cljs.devtools.client.env.set_print_fns_BANG_ \x3d (function shadow$cljs$devtools$client$env$set_print_fns_BANG_(msg_fn){\nvar original_print_fn \x3d cljs.core._STAR_print_fn_STAR_;\nvar original_print_err_fn \x3d cljs.core._STAR_print_err_fn_STAR_;\n(cljs.core._STAR_print_newline_STAR_ \x3d true);\n\n(cljs.core.enable_console_print_BANG_ \x3d (function (){\nreturn null;\n}));\n\ncljs.core.reset_BANG_(shadow.cljs.devtools.client.env.reset_print_fn_ref,(function shadow$cljs$devtools$client$env$set_print_fns_BANG__$_reset_print_fns_BANG_(){\n(cljs.core._STAR_print_newline_STAR_ \x3d shadow.cljs.devtools.client.env.was_print_newline);\n\ncljs.core.set_print_fn_BANG_(original_print_fn);\n\nreturn cljs.core.set_print_err_fn_BANG_(original_print_err_fn);\n}));\n\ncljs.core.set_print_fn_BANG_((function shadow$cljs$devtools$client$env$set_print_fns_BANG__$_repl_print_fn(s){\n(msg_fn.cljs$core$IFn$_invoke$arity$2 ? msg_fn.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22stdout\x22,\x22stdout\x22,-531490018),s) : msg_fn.call(null, new cljs.core.Keyword(null,\x22stdout\x22,\x22stdout\x22,-531490018),s));\n\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d original_print_fn;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(s,\x22\\n\x22);\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn (original_print_fn.cljs$core$IFn$_invoke$arity$1 ? original_print_fn.cljs$core$IFn$_invoke$arity$1(s) : original_print_fn.call(null, s));\n} else {\nreturn null;\n}\n}));\n\nreturn cljs.core.set_print_err_fn_BANG_((function shadow$cljs$devtools$client$env$set_print_fns_BANG__$_repl_print_err_fn(s){\n(msg_fn.cljs$core$IFn$_invoke$arity$2 ? msg_fn.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22stderr\x22,\x22stderr\x22,-1571650309),s) : msg_fn.call(null, new cljs.core.Keyword(null,\x22stderr\x22,\x22stderr\x22,-1571650309),s));\n\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d original_print_err_fn;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(s,\x22\\n\x22);\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn (original_print_err_fn.cljs$core$IFn$_invoke$arity$1 ? original_print_err_fn.cljs$core$IFn$_invoke$arity$1(s) : original_print_err_fn.call(null, s));\n} else {\nreturn null;\n}\n}));\n});\nshadow.cljs.devtools.client.env.reset_print_fns_BANG_ \x3d (function shadow$cljs$devtools$client$env$reset_print_fns_BANG_(){\nvar temp__5804__auto__ \x3d cljs.core.deref(shadow.cljs.devtools.client.env.reset_print_fn_ref);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar x \x3d temp__5804__auto__;\n(x.cljs$core$IFn$_invoke$arity$0 ? x.cljs$core$IFn$_invoke$arity$0() : x.call(null, ));\n\nreturn cljs.core.reset_BANG_(shadow.cljs.devtools.client.env.reset_print_fn_ref,null);\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.env.patch_goog_BANG_ \x3d (function shadow$cljs$devtools$client$env$patch_goog_BANG_(){\n(goog.provide \x3d goog.constructNamespace_);\n\nreturn (goog.require \x3d goog.module.get);\n});\nshadow.cljs.devtools.client.env.add_warnings_to_info \x3d (function shadow$cljs$devtools$client$env$add_warnings_to_info(p__21805){\nvar map__21808 \x3d p__21805;\nvar map__21808__$1 \x3d cljs.core.__destructure_map(map__21808);\nvar msg \x3d map__21808__$1;\nvar info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21808__$1,new cljs.core.Keyword(null,\x22info\x22,\x22info\x22,-317069002));\nvar warnings \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.distinct.cljs$core$IFn$_invoke$arity$1((function (){var iter__5480__auto__ \x3d (function shadow$cljs$devtools$client$env$add_warnings_to_info_$_iter__21811(s__21812){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__21812__$1 \x3d s__21812;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__21812__$1);\nif(temp__5804__auto__){\nvar xs__6360__auto__ \x3d temp__5804__auto__;\nvar map__21825 \x3d cljs.core.first(xs__6360__auto__);\nvar map__21825__$1 \x3d cljs.core.__destructure_map(map__21825);\nvar src \x3d map__21825__$1;\nvar resource_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21825__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nvar warnings \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21825__$1,new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651));\nif(cljs.core.not(new cljs.core.Keyword(null,\x22from-jar\x22,\x22from-jar\x22,1050932827).cljs$core$IFn$_invoke$arity$1(src))){\nvar iterys__5476__auto__ \x3d ((function (s__21812__$1,map__21825,map__21825__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__21808,map__21808__$1,msg,info){\nreturn (function shadow$cljs$devtools$client$env$add_warnings_to_info_$_iter__21811_$_iter__21813(s__21814){\nreturn (new cljs.core.LazySeq(null,((function (s__21812__$1,map__21825,map__21825__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__21808,map__21808__$1,msg,info){\nreturn (function (){\nvar s__21814__$1 \x3d s__21814;\nwhile(true){\nvar temp__5804__auto____$1 \x3d cljs.core.seq(s__21814__$1);\nif(temp__5804__auto____$1){\nvar s__21814__$2 \x3d temp__5804__auto____$1;\nif(cljs.core.chunked_seq_QMARK_(s__21814__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__21814__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__21816 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__21815 \x3d (0);\nwhile(true){\nif((i__21815 \x3c size__5479__auto__)){\nvar warning \x3d cljs.core._nth(c__5478__auto__,i__21815);\ncljs.core.chunk_append(b__21816,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(warning,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100),resource_name));\n\nvar G__22239 \x3d (i__21815 + (1));\ni__21815 \x3d G__22239;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21816),shadow$cljs$devtools$client$env$add_warnings_to_info_$_iter__21811_$_iter__21813(cljs.core.chunk_rest(s__21814__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21816),null);\n}\n} else {\nvar warning \x3d cljs.core.first(s__21814__$2);\nreturn cljs.core.cons(cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(warning,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100),resource_name),shadow$cljs$devtools$client$env$add_warnings_to_info_$_iter__21811_$_iter__21813(cljs.core.rest(s__21814__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});})(s__21812__$1,map__21825,map__21825__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__21808,map__21808__$1,msg,info))\n,null,null));\n});})(s__21812__$1,map__21825,map__21825__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__21808,map__21808__$1,msg,info))\n;\nvar fs__5477__auto__ \x3d cljs.core.seq(iterys__5476__auto__(warnings));\nif(fs__5477__auto__){\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$2(fs__5477__auto__,shadow$cljs$devtools$client$env$add_warnings_to_info_$_iter__21811(cljs.core.rest(s__21812__$1)));\n} else {\nvar G__22246 \x3d cljs.core.rest(s__21812__$1);\ns__21812__$1 \x3d G__22246;\ncontinue;\n}\n} else {\nvar G__22248 \x3d cljs.core.rest(s__21812__$1);\ns__21812__$1 \x3d G__22248;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424).cljs$core$IFn$_invoke$arity$1(info));\n})()));\nreturn cljs.core.assoc_in(msg,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22info\x22,\x22info\x22,-317069002),new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651)], null),warnings);\n});\nshadow.cljs.devtools.client.env.custom_notify_types \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22build-complete\x22,\x22build-complete\x22,-501868472),null,new cljs.core.Keyword(null,\x22build-init\x22,\x22build-init\x22,-1115755563),null,new cljs.core.Keyword(null,\x22build-failure\x22,\x22build-failure\x22,-2107487466),null,new cljs.core.Keyword(null,\x22build-start\x22,\x22build-start\x22,-959649480),null], null), null);\nshadow.cljs.devtools.client.env.run_custom_notify_BANG_ \x3d (function shadow$cljs$devtools$client$env$run_custom_notify_BANG_(msg){\nif(cljs.core.seq(shadow.cljs.devtools.client.env.custom_notify_fn)){\nvar fn \x3d goog.getObjectByName(shadow.cljs.devtools.client.env.custom_notify_fn,$CLJS);\nif((!(cljs.core.fn_QMARK_(fn)))){\nreturn console.warn(\x22couldn\x27t find custom :build-notify\x22,shadow.cljs.devtools.client.env.custom_notify_fn);\n} else {\ntry{return (fn.cljs$core$IFn$_invoke$arity$1 ? fn.cljs$core$IFn$_invoke$arity$1(msg) : fn.call(null, msg));\n}catch (e21860){var e \x3d e21860;\nconsole.error(\x22Failed to run custom :build-notify\x22,shadow.cljs.devtools.client.env.custom_notify_fn);\n\nreturn console.error(e);\n}}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.env.make_task_fn \x3d (function shadow$cljs$devtools$client$env$make_task_fn(p__21867,p__21868){\nvar map__21869 \x3d p__21867;\nvar map__21869__$1 \x3d cljs.core.__destructure_map(map__21869);\nvar log_missing_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21869__$1,new cljs.core.Keyword(null,\x22log-missing-fn\x22,\x22log-missing-fn\x22,732676765));\nvar log_call_async \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21869__$1,new cljs.core.Keyword(null,\x22log-call-async\x22,\x22log-call-async\x22,183826192));\nvar log_call \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21869__$1,new cljs.core.Keyword(null,\x22log-call\x22,\x22log-call\x22,412404391));\nvar map__21870 \x3d p__21868;\nvar map__21870__$1 \x3d cljs.core.__destructure_map(map__21870);\nvar fn_sym \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21870__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_str \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21870__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar async \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21870__$1,new cljs.core.Keyword(null,\x22async\x22,\x22async\x22,1050769601));\nreturn (function (next){\ntry{var fn_obj \x3d goog.getObjectByName(fn_str,$CLJS);\nif((fn_obj \x3d\x3d null)){\nif(cljs.core.truth_(log_missing_fn)){\n(log_missing_fn.cljs$core$IFn$_invoke$arity$1 ? log_missing_fn.cljs$core$IFn$_invoke$arity$1(fn_sym) : log_missing_fn.call(null, fn_sym));\n} else {\n}\n\nreturn (next.cljs$core$IFn$_invoke$arity$0 ? next.cljs$core$IFn$_invoke$arity$0() : next.call(null, ));\n} else {\nif(cljs.core.truth_(async)){\nif(cljs.core.truth_(log_call_async)){\n(log_call_async.cljs$core$IFn$_invoke$arity$1 ? log_call_async.cljs$core$IFn$_invoke$arity$1(fn_sym) : log_call_async.call(null, fn_sym));\n} else {\n}\n\nreturn (fn_obj.cljs$core$IFn$_invoke$arity$1 ? fn_obj.cljs$core$IFn$_invoke$arity$1(next) : fn_obj.call(null, next));\n} else {\nif(cljs.core.truth_(log_call)){\n(log_call.cljs$core$IFn$_invoke$arity$1 ? log_call.cljs$core$IFn$_invoke$arity$1(fn_sym) : log_call.call(null, fn_sym));\n} else {\n}\n\n(fn_obj.cljs$core$IFn$_invoke$arity$0 ? fn_obj.cljs$core$IFn$_invoke$arity$0() : fn_obj.call(null, ));\n\nreturn (next.cljs$core$IFn$_invoke$arity$0 ? next.cljs$core$IFn$_invoke$arity$0() : next.call(null, ));\n\n}\n}\n}catch (e21880){var ex \x3d e21880;\nconsole.warn(\x22error when calling lifecycle function\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym),ex);\n\nreturn (next.cljs$core$IFn$_invoke$arity$0 ? next.cljs$core$IFn$_invoke$arity$0() : next.call(null, ));\n}});\n});\nshadow.cljs.devtools.client.env.do_js_reload_STAR_ \x3d (function shadow$cljs$devtools$client$env$do_js_reload_STAR_(failure_fn,p__21901){\nvar vec__21906 \x3d p__21901;\nvar seq__21907 \x3d cljs.core.seq(vec__21906);\nvar first__21908 \x3d cljs.core.first(seq__21907);\nvar seq__21907__$1 \x3d cljs.core.next(seq__21907);\nvar task \x3d first__21908;\nvar remaining_tasks \x3d seq__21907__$1;\nif(cljs.core.truth_(task)){\ntry{var G__21912 \x3d (function (){\nreturn (shadow.cljs.devtools.client.env.do_js_reload_STAR_.cljs$core$IFn$_invoke$arity$2 ? shadow.cljs.devtools.client.env.do_js_reload_STAR_.cljs$core$IFn$_invoke$arity$2(failure_fn,remaining_tasks) : shadow.cljs.devtools.client.env.do_js_reload_STAR_.call(null, failure_fn,remaining_tasks));\n});\nreturn (task.cljs$core$IFn$_invoke$arity$1 ? task.cljs$core$IFn$_invoke$arity$1(G__21912) : task.call(null, G__21912));\n}catch (e21911){var e \x3d e21911;\nreturn (failure_fn.cljs$core$IFn$_invoke$arity$3 ? failure_fn.cljs$core$IFn$_invoke$arity$3(e,task,remaining_tasks) : failure_fn.call(null, e,task,remaining_tasks));\n}} else {\nreturn null;\n}\n});\n/**\n * should pass the :build-complete message and an additional callback\n * which performs the actual loading of the code (sync)\n * will call all before/after callbacks in order\n */\nshadow.cljs.devtools.client.env.do_js_reload \x3d (function shadow$cljs$devtools$client$env$do_js_reload(var_args){\nvar G__21926 \x3d arguments.length;\nswitch (G__21926) {\ncase 2:\nreturn shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$2 \x3d (function (msg,load_code_fn){\nreturn shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$3(msg,load_code_fn,(function (){\nreturn null;\n}));\n}));\n\n(shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$3 \x3d (function (msg,load_code_fn,complete_fn){\nreturn shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$4(msg,load_code_fn,complete_fn,(function (error,task,remaining){\nreturn console.warn(\x22JS reload failed\x22,error);\n}));\n}));\n\n(shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$4 \x3d (function (p__21940,load_code_fn,complete_fn,failure_fn){\nvar map__21941 \x3d p__21940;\nvar map__21941__$1 \x3d cljs.core.__destructure_map(map__21941);\nvar msg \x3d map__21941__$1;\nvar reload_info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21941__$1,new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086));\nvar load_tasks \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.reverse(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__21914_SHARP_){\nreturn shadow.cljs.devtools.client.env.make_task_fn(msg,p1__21914_SHARP_);\n}),new cljs.core.Keyword(null,\x22before-load\x22,\x22before-load\x22,-2060117064).cljs$core$IFn$_invoke$arity$1(reload_info)))),(function (next){\n(load_code_fn.cljs$core$IFn$_invoke$arity$0 ? load_code_fn.cljs$core$IFn$_invoke$arity$0() : load_code_fn.call(null, ));\n\nreturn (next.cljs$core$IFn$_invoke$arity$0 ? next.cljs$core$IFn$_invoke$arity$0() : next.call(null, ));\n})),cljs.core.map.cljs$core$IFn$_invoke$arity$1((function (p1__21915_SHARP_){\nreturn shadow.cljs.devtools.client.env.make_task_fn(msg,p1__21915_SHARP_);\n})),new cljs.core.Keyword(null,\x22after-load\x22,\x22after-load\x22,-1278503285).cljs$core$IFn$_invoke$arity$1(reload_info)),(function (next){\n(complete_fn.cljs$core$IFn$_invoke$arity$0 ? complete_fn.cljs$core$IFn$_invoke$arity$0() : complete_fn.call(null, ));\n\nreturn (next.cljs$core$IFn$_invoke$arity$0 ? next.cljs$core$IFn$_invoke$arity$0() : next.call(null, ));\n}));\nreturn shadow.cljs.devtools.client.env.do_js_reload_STAR_(failure_fn,load_tasks);\n}));\n\n(shadow.cljs.devtools.client.env.do_js_reload.cljs$lang$maxFixedArity \x3d 4);\n\nshadow.cljs.devtools.client.env.before_load_src \x3d (function shadow$cljs$devtools$client$env$before_load_src(p__21961){\nvar map__21965 \x3d p__21961;\nvar map__21965__$1 \x3d cljs.core.__destructure_map(map__21965);\nvar src \x3d map__21965__$1;\nvar type \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21965__$1,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348));\nvar ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21965__$1,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22cljs\x22,\x22cljs\x22,1492417629),type)){\nvar seq__21966 \x3d cljs.core.seq(goog.global.SHADOW_NS_RESET);\nvar chunk__21968 \x3d null;\nvar count__21969 \x3d (0);\nvar i__21970 \x3d (0);\nwhile(true){\nif((i__21970 \x3c count__21969)){\nvar x \x3d chunk__21968.cljs$core$IIndexed$_nth$arity$2(null, i__21970);\n(x.cljs$core$IFn$_invoke$arity$1 ? x.cljs$core$IFn$_invoke$arity$1(ns) : x.call(null, ns));\n\n\nvar G__22335 \x3d seq__21966;\nvar G__22336 \x3d chunk__21968;\nvar G__22337 \x3d count__21969;\nvar G__22338 \x3d (i__21970 + (1));\nseq__21966 \x3d G__22335;\nchunk__21968 \x3d G__22336;\ncount__21969 \x3d G__22337;\ni__21970 \x3d G__22338;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__21966);\nif(temp__5804__auto__){\nvar seq__21966__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__21966__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__21966__$1);\nvar G__22344 \x3d cljs.core.chunk_rest(seq__21966__$1);\nvar G__22345 \x3d c__5525__auto__;\nvar G__22346 \x3d cljs.core.count(c__5525__auto__);\nvar G__22347 \x3d (0);\nseq__21966 \x3d G__22344;\nchunk__21968 \x3d G__22345;\ncount__21969 \x3d G__22346;\ni__21970 \x3d G__22347;\ncontinue;\n} else {\nvar x \x3d cljs.core.first(seq__21966__$1);\n(x.cljs$core$IFn$_invoke$arity$1 ? x.cljs$core$IFn$_invoke$arity$1(ns) : x.call(null, ns));\n\n\nvar G__22348 \x3d cljs.core.next(seq__21966__$1);\nvar G__22349 \x3d null;\nvar G__22350 \x3d (0);\nvar G__22351 \x3d (0);\nseq__21966 \x3d G__22348;\nchunk__21968 \x3d G__22349;\ncount__21969 \x3d G__22350;\ni__21970 \x3d G__22351;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.env.goog_is_loaded_QMARK_ \x3d (function shadow$cljs$devtools$client$env$goog_is_loaded_QMARK_(name){\nreturn $CLJS.SHADOW_ENV.isLoaded(name);\n});\nshadow.cljs.devtools.client.env.goog_base_rc \x3d new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22shadow.build.classpath\x22,\x22resource\x22,\x22shadow.build.classpath/resource\x22,-879517823),\x22goog/base.js\x22], null);\nshadow.cljs.devtools.client.env.src_is_loaded_QMARK_ \x3d (function shadow$cljs$devtools$client$env$src_is_loaded_QMARK_(p__21985){\nvar map__21987 \x3d p__21985;\nvar map__21987__$1 \x3d cljs.core.__destructure_map(map__21987);\nvar src \x3d map__21987__$1;\nvar resource_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21987__$1,new cljs.core.Keyword(null,\x22resource-id\x22,\x22resource-id\x22,-1308422582));\nvar output_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21987__$1,new cljs.core.Keyword(null,\x22output-name\x22,\x22output-name\x22,-1769107767));\nvar or__5002__auto__ \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(shadow.cljs.devtools.client.env.goog_base_rc,resource_id);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn shadow.cljs.devtools.client.env.goog_is_loaded_QMARK_(output_name);\n}\n});\nshadow.cljs.devtools.client.env.prefilter_sources \x3d (function shadow$cljs$devtools$client$env$prefilter_sources(reload_info,sources){\nreturn cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p__21990){\nvar map__21992 \x3d p__21990;\nvar map__21992__$1 \x3d cljs.core.__destructure_map(map__21992);\nvar ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21992__$1,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760));\nreturn cljs.core.contains_QMARK_(new cljs.core.Keyword(null,\x22never-load\x22,\x22never-load\x22,1300896819).cljs$core$IFn$_invoke$arity$1(reload_info),ns);\n}),cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p__21997){\nvar map__22001 \x3d p__21997;\nvar map__22001__$1 \x3d cljs.core.__destructure_map(map__22001);\nvar rc \x3d map__22001__$1;\nvar module__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22001__$1,new cljs.core.Keyword(null,\x22module\x22,\x22module\x22,1424618191));\nreturn ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22js\x22,shadow.cljs.devtools.client.env.module_format)) || (shadow.cljs.devtools.client.env.module_is_active_QMARK_(module__$1)));\n}),sources));\n});\nshadow.cljs.devtools.client.env.filter_sources_to_get_optimized \x3d (function shadow$cljs$devtools$client$env$filter_sources_to_get_optimized(p__22008,reload_info){\nvar map__22009 \x3d p__22008;\nvar map__22009__$1 \x3d cljs.core.__destructure_map(map__22009);\nvar info \x3d map__22009__$1;\nvar sources \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22009__$1,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424));\nvar compiled \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22009__$1,new cljs.core.Keyword(null,\x22compiled\x22,\x22compiled\x22,850043082));\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p__22015){\nvar map__22016 \x3d p__22015;\nvar map__22016__$1 \x3d cljs.core.__destructure_map(map__22016);\nvar src \x3d map__22016__$1;\nvar ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22016__$1,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760));\nvar resource_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22016__$1,new cljs.core.Keyword(null,\x22resource-id\x22,\x22resource-id\x22,-1308422582));\nreturn ((cljs.core.contains_QMARK_(new cljs.core.Keyword(null,\x22always-load\x22,\x22always-load\x22,66405637).cljs$core$IFn$_invoke$arity$1(reload_info),ns)) || (((cljs.core.not(shadow.cljs.devtools.client.env.src_is_loaded_QMARK_(src))) || (((cljs.core.contains_QMARK_(compiled,resource_id)) \x26\x26 (cljs.core.not(new cljs.core.Keyword(null,\x22from-jar\x22,\x22from-jar\x22,1050932827).cljs$core$IFn$_invoke$arity$1(src))))))));\n}),shadow.cljs.devtools.client.env.prefilter_sources(reload_info,sources)));\n});\nshadow.cljs.devtools.client.env.filter_sources_to_get_full \x3d (function shadow$cljs$devtools$client$env$filter_sources_to_get_full(p__22035,reload_info){\nvar map__22036 \x3d p__22035;\nvar map__22036__$1 \x3d cljs.core.__destructure_map(map__22036);\nvar info \x3d map__22036__$1;\nvar sources \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22036__$1,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424));\nvar compiled \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22036__$1,new cljs.core.Keyword(null,\x22compiled\x22,\x22compiled\x22,850043082));\nvar affected \x3d cljs.core.PersistentHashSet.EMPTY;\nvar sources_to_get \x3d cljs.core.PersistentVector.EMPTY;\nvar G__22040 \x3d shadow.cljs.devtools.client.env.prefilter_sources(reload_info,sources);\nvar vec__22045 \x3d G__22040;\nvar seq__22046 \x3d cljs.core.seq(vec__22045);\nvar first__22047 \x3d cljs.core.first(seq__22046);\nvar seq__22046__$1 \x3d cljs.core.next(seq__22046);\nvar src \x3d first__22047;\nvar more \x3d seq__22046__$1;\nvar affected__$1 \x3d affected;\nvar sources_to_get__$1 \x3d sources_to_get;\nvar G__22040__$1 \x3d G__22040;\nwhile(true){\nvar affected__$2 \x3d affected__$1;\nvar sources_to_get__$2 \x3d sources_to_get__$1;\nvar vec__22096 \x3d G__22040__$1;\nvar seq__22097 \x3d cljs.core.seq(vec__22096);\nvar first__22098 \x3d cljs.core.first(seq__22097);\nvar seq__22097__$1 \x3d cljs.core.next(seq__22097);\nvar src__$1 \x3d first__22098;\nvar more__$1 \x3d seq__22097__$1;\nif(cljs.core.not(src__$1)){\nreturn sources_to_get__$2;\n} else {\nvar map__22112 \x3d src__$1;\nvar map__22112__$1 \x3d cljs.core.__destructure_map(map__22112);\nvar ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22112__$1,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760));\nvar resource_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22112__$1,new cljs.core.Keyword(null,\x22resource-id\x22,\x22resource-id\x22,-1308422582));\nvar deps \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22112__$1,new cljs.core.Keyword(null,\x22deps\x22,\x22deps\x22,1883360319));\nvar provides \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22112__$1,new cljs.core.Keyword(null,\x22provides\x22,\x22provides\x22,-1634397992));\nvar should_reload_QMARK_ \x3d (function (){var or__5002__auto__ \x3d cljs.core.contains_QMARK_(new cljs.core.Keyword(null,\x22always-load\x22,\x22always-load\x22,66405637).cljs$core$IFn$_invoke$arity$1(reload_info),ns);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d cljs.core.not(shadow.cljs.devtools.client.env.src_is_loaded_QMARK_(src__$1));\nif(or__5002__auto____$1){\nreturn or__5002__auto____$1;\n} else {\nvar and__5000__auto__ \x3d (function (){var or__5002__auto____$2 \x3d cljs.core.contains_QMARK_(compiled,resource_id);\nif(or__5002__auto____$2){\nreturn or__5002__auto____$2;\n} else {\nreturn cljs.core.some(affected__$2,deps);\n}\n})();\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.not(new cljs.core.Keyword(null,\x22from-jar\x22,\x22from-jar\x22,1050932827).cljs$core$IFn$_invoke$arity$1(src__$1));\n} else {\nreturn and__5000__auto__;\n}\n}\n}\n})();\nif(cljs.core.not(should_reload_QMARK_)){\nvar G__22369 \x3d affected__$2;\nvar G__22370 \x3d sources_to_get__$2;\nvar G__22371 \x3d more__$1;\naffected__$1 \x3d G__22369;\nsources_to_get__$1 \x3d G__22370;\nG__22040__$1 \x3d G__22371;\ncontinue;\n} else {\nvar G__22372 \x3d clojure.set.union.cljs$core$IFn$_invoke$arity$2(affected__$2,provides);\nvar G__22373 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(sources_to_get__$2,src__$1);\nvar G__22374 \x3d more__$1;\naffected__$1 \x3d G__22372;\nsources_to_get__$1 \x3d G__22373;\nG__22040__$1 \x3d G__22374;\ncontinue;\n}\n}\nbreak;\n}\n});\nshadow.cljs.devtools.client.env.filter_reload_sources \x3d (function shadow$cljs$devtools$client$env$filter_reload_sources(info,reload_info){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22full\x22,shadow.cljs.devtools.client.env.reload_strategy)){\nreturn shadow.cljs.devtools.client.env.filter_sources_to_get_full(info,reload_info);\n} else {\nreturn shadow.cljs.devtools.client.env.filter_sources_to_get_optimized(info,reload_info);\n}\n});\n");
SHADOW_ENV.evalLoad("goog.dom.inputtype.js", true, "goog.provide(\x22goog.dom.InputType\x22);\ngoog.dom.InputType \x3d {BUTTON:\x22button\x22, CHECKBOX:\x22checkbox\x22, COLOR:\x22color\x22, DATE:\x22date\x22, DATETIME:\x22datetime\x22, DATETIME_LOCAL:\x22datetime-local\x22, EMAIL:\x22email\x22, FILE:\x22file\x22, HIDDEN:\x22hidden\x22, IMAGE:\x22image\x22, MENU:\x22menu\x22, MONTH:\x22month\x22, NUMBER:\x22number\x22, PASSWORD:\x22password\x22, RADIO:\x22radio\x22, RANGE:\x22range\x22, RESET:\x22reset\x22, SEARCH:\x22search\x22, SELECT_MULTIPLE:\x22select-multiple\x22, SELECT_ONE:\x22select-one\x22, SUBMIT:\x22submit\x22, TEL:\x22tel\x22, TEXT:\x22text\x22, TEXTAREA:\x22textarea\x22, TIME:\x22time\x22, URL:\x22url\x22, WEEK:\x22week\x22};\n");
SHADOW_ENV.evalLoad("goog.collections.iters.js", true, "goog.loadModule(function(exports) {\n  function getIterator(iterable) {\n    return iterable[goog.global.Symbol.iterator]();\n  }\n  function forEach(iterator, f) {\n    let result;\n    for (; !(result \x3d iterator.next()).done;) {\n      f(result.value);\n    }\n  }\n  \x22use strict\x22;\n  goog.module(\x22goog.collections.iters\x22);\n  goog.module.declareLegacyNamespace();\n  exports.getIterator \x3d getIterator;\n  exports.forEach \x3d forEach;\n  class MapIterator {\n    constructor(childIter, mapFn) {\n      this.childIterator_ \x3d getIterator(childIter);\n      this.mapFn_ \x3d mapFn;\n    }\n    [Symbol.iterator]() {\n      return this;\n    }\n    next() {\n      const childResult \x3d this.childIterator_.next();\n      return {value:childResult.done ? undefined : this.mapFn_.call(undefined, childResult.value), done:childResult.done};\n    }\n  }\n  exports.map \x3d function(iterable, f) {\n    return new MapIterator(iterable, f);\n  };\n  class FilterIterator {\n    constructor(childIter, filterFn) {\n      this.childIter_ \x3d getIterator(childIter);\n      this.filterFn_ \x3d filterFn;\n    }\n    [Symbol.iterator]() {\n      return this;\n    }\n    next() {\n      for (; true;) {\n        const childResult \x3d this.childIter_.next();\n        if (childResult.done) {\n          return {done:true, value:undefined};\n        }\n        const passesFilter \x3d this.filterFn_.call(undefined, childResult.value);\n        if (passesFilter) {\n          return childResult;\n        }\n      }\n    }\n  }\n  exports.filter \x3d function(iterable, f) {\n    return new FilterIterator(iterable, f);\n  };\n  class ConcatIterator {\n    constructor(iterators) {\n      this.iterators_ \x3d iterators;\n      this.iterIndex_ \x3d 0;\n    }\n    [Symbol.iterator]() {\n      return this;\n    }\n    next() {\n      for (; this.iterIndex_ \x3c this.iterators_.length;) {\n        const result \x3d this.iterators_[this.iterIndex_].next();\n        if (!result.done) {\n          return result;\n        }\n        this.iterIndex_++;\n      }\n      return {done:true};\n    }\n  }\n  exports.concat \x3d function(...iterables) {\n    return new ConcatIterator(iterables.map(getIterator));\n  };\n  exports.toArray \x3d function(iterator) {\n    const arr \x3d [];\n    forEach(iterator, e \x3d\x3e {\n      return arr.push(e);\n    });\n    return arr;\n  };\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.debug.errorcontext.js", true, "goog.provide(\x22goog.debug.errorcontext\x22);\ngoog.debug.errorcontext.addErrorContext \x3d function(err, contextKey, contextValue) {\n  if (!err[goog.debug.errorcontext.CONTEXT_KEY_]) {\n    err[goog.debug.errorcontext.CONTEXT_KEY_] \x3d {};\n  }\n  err[goog.debug.errorcontext.CONTEXT_KEY_][contextKey] \x3d contextValue;\n};\ngoog.debug.errorcontext.getErrorContext \x3d function(err) {\n  return err[goog.debug.errorcontext.CONTEXT_KEY_] || {};\n};\ngoog.debug.errorcontext.CONTEXT_KEY_ \x3d \x22__closure__error__context__984382\x22;\n");
SHADOW_ENV.evalLoad("goog.debug.debug.js", true, "goog.provide(\x22goog.debug\x22);\ngoog.require(\x22goog.array\x22);\ngoog.require(\x22goog.debug.errorcontext\x22);\ngoog.debug.LOGGING_ENABLED \x3d goog.define(\x22goog.debug.LOGGING_ENABLED\x22, goog.DEBUG);\ngoog.debug.FORCE_SLOPPY_STACKS \x3d goog.define(\x22goog.debug.FORCE_SLOPPY_STACKS\x22, false);\ngoog.debug.CHECK_FOR_THROWN_EVENT \x3d goog.define(\x22goog.debug.CHECK_FOR_THROWN_EVENT\x22, false);\ngoog.debug.catchErrors \x3d function(logFunc, opt_cancel, opt_target) {\n  var target \x3d opt_target || goog.global;\n  var oldErrorHandler \x3d target.onerror;\n  var retVal \x3d !!opt_cancel;\n  target.onerror \x3d function(message, url, line, opt_col, opt_error) {\n    if (oldErrorHandler) {\n      oldErrorHandler(message, url, line, opt_col, opt_error);\n    }\n    logFunc({message:message, fileName:url, line:line, lineNumber:line, col:opt_col, error:opt_error});\n    return retVal;\n  };\n};\ngoog.debug.expose \x3d function(obj, opt_showFn) {\n  if (typeof obj \x3d\x3d \x22undefined\x22) {\n    return \x22undefined\x22;\n  }\n  if (obj \x3d\x3d null) {\n    return \x22NULL\x22;\n  }\n  var str \x3d [];\n  var x;\n  for (x in obj) {\n    if (!opt_showFn \x26\x26 typeof obj[x] \x3d\x3d\x3d \x22function\x22) {\n      continue;\n    }\n    var s \x3d x + \x22 \\x3d \x22;\n    try {\n      s \x3d s + obj[x];\n    } catch (e) {\n      s \x3d s + (\x22*** \x22 + e + \x22 ***\x22);\n    }\n    str.push(s);\n  }\n  return str.join(\x22\\n\x22);\n};\ngoog.debug.deepExpose \x3d function(obj, opt_showFn) {\n  var str \x3d [];\n  var uidsToCleanup \x3d [];\n  var ancestorUids \x3d {};\n  var helper \x3d function(obj, space) {\n    var nestspace \x3d space + \x22  \x22;\n    var indentMultiline \x3d function(str) {\n      return str.replace(/\\n/g, \x22\\n\x22 + space);\n    };\n    try {\n      if (obj \x3d\x3d\x3d undefined) {\n        str.push(\x22undefined\x22);\n      } else if (obj \x3d\x3d\x3d null) {\n        str.push(\x22NULL\x22);\n      } else if (typeof obj \x3d\x3d\x3d \x22string\x22) {\n        str.push(\x27\x22\x27 + indentMultiline(obj) + \x27\x22\x27);\n      } else if (typeof obj \x3d\x3d\x3d \x22function\x22) {\n        str.push(indentMultiline(String(obj)));\n      } else if (goog.isObject(obj)) {\n        if (!goog.hasUid(obj)) {\n          uidsToCleanup.push(obj);\n        }\n        var uid \x3d goog.getUid(obj);\n        if (ancestorUids[uid]) {\n          str.push(\x22*** reference loop detected (id\\x3d\x22 + uid + \x22) ***\x22);\n        } else {\n          ancestorUids[uid] \x3d true;\n          str.push(\x22{\x22);\n          var x;\n          for (x in obj) {\n            if (!opt_showFn \x26\x26 typeof obj[x] \x3d\x3d\x3d \x22function\x22) {\n              continue;\n            }\n            str.push(\x22\\n\x22);\n            str.push(nestspace);\n            str.push(x + \x22 \\x3d \x22);\n            helper(obj[x], nestspace);\n          }\n          str.push(\x22\\n\x22 + space + \x22}\x22);\n          delete ancestorUids[uid];\n        }\n      } else {\n        str.push(obj);\n      }\n    } catch (e) {\n      str.push(\x22*** \x22 + e + \x22 ***\x22);\n    }\n  };\n  helper(obj, \x22\x22);\n  var i \x3d 0;\n  for (; i \x3c uidsToCleanup.length; i++) {\n    goog.removeUid(uidsToCleanup[i]);\n  }\n  return str.join(\x22\x22);\n};\ngoog.debug.exposeArray \x3d function(arr) {\n  var str \x3d [];\n  var i \x3d 0;\n  for (; i \x3c arr.length; i++) {\n    if (Array.isArray(arr[i])) {\n      str.push(goog.debug.exposeArray(arr[i]));\n    } else {\n      str.push(arr[i]);\n    }\n  }\n  return \x22[ \x22 + str.join(\x22, \x22) + \x22 ]\x22;\n};\ngoog.debug.normalizeErrorObject \x3d function(err) {\n  var href \x3d goog.getObjectByName(\x22window.location.href\x22);\n  if (err \x3d\x3d null) {\n    err \x3d \x27Unknown Error of type \x22null/undefined\x22\x27;\n  }\n  if (typeof err \x3d\x3d\x3d \x22string\x22) {\n    return {\x22message\x22:err, \x22name\x22:\x22Unknown error\x22, \x22lineNumber\x22:\x22Not available\x22, \x22fileName\x22:href, \x22stack\x22:\x22Not available\x22};\n  }\n  var lineNumber;\n  var fileName;\n  var threwError \x3d false;\n  try {\n    lineNumber \x3d err.lineNumber || err.line || \x22Not available\x22;\n  } catch (e) {\n    lineNumber \x3d \x22Not available\x22;\n    threwError \x3d true;\n  }\n  try {\n    fileName \x3d err.fileName || err.filename || err.sourceURL || goog.global[\x22$googDebugFname\x22] || href;\n  } catch (e) {\n    fileName \x3d \x22Not available\x22;\n    threwError \x3d true;\n  }\n  var stack \x3d goog.debug.serializeErrorStack_(err);\n  if (threwError || !err.lineNumber || !err.fileName || !err.stack || !err.message || !err.name) {\n    var message \x3d err.message;\n    if (message \x3d\x3d null) {\n      if (err.constructor \x26\x26 err.constructor instanceof Function) {\n        var ctorName \x3d err.constructor.name ? err.constructor.name : goog.debug.getFunctionName(err.constructor);\n        message \x3d \x27Unknown Error of type \x22\x27 + ctorName + \x27\x22\x27;\n        if (goog.debug.CHECK_FOR_THROWN_EVENT \x26\x26 ctorName \x3d\x3d \x22Event\x22) {\n          try {\n            message \x3d message + \x27 with Event.type \x22\x27 + (err.type || \x22\x22) + \x27\x22\x27;\n          } catch (e) {\n          }\n        }\n      } else {\n        message \x3d \x22Unknown Error of unknown type\x22;\n      }\n      if (typeof err.toString \x3d\x3d\x3d \x22function\x22 \x26\x26 Object.prototype.toString !\x3d\x3d err.toString) {\n        message \x3d message + (\x22: \x22 + err.toString());\n      }\n    }\n    return {\x22message\x22:message, \x22name\x22:err.name || \x22UnknownError\x22, \x22lineNumber\x22:lineNumber, \x22fileName\x22:fileName, \x22stack\x22:stack || \x22Not available\x22};\n  }\n  err.stack \x3d stack;\n  return {\x22message\x22:err.message, \x22name\x22:err.name, \x22lineNumber\x22:err.lineNumber, \x22fileName\x22:err.fileName, \x22stack\x22:err.stack};\n};\ngoog.debug.serializeErrorStack_ \x3d function(e, seen) {\n  if (!seen) {\n    seen \x3d {};\n  }\n  seen[goog.debug.serializeErrorAsKey_(e)] \x3d true;\n  var stack \x3d e[\x22stack\x22] || \x22\x22;\n  var cause \x3d e.cause;\n  if (cause \x26\x26 !seen[goog.debug.serializeErrorAsKey_(cause)]) {\n    stack \x3d stack + \x22\\nCaused by: \x22;\n    if (!cause.stack || cause.stack.indexOf(cause.toString()) !\x3d 0) {\n      stack \x3d stack + (typeof cause \x3d\x3d\x3d \x22string\x22 ? cause : cause.message + \x22\\n\x22);\n    }\n    stack \x3d stack + goog.debug.serializeErrorStack_(cause, seen);\n  }\n  return stack;\n};\ngoog.debug.serializeErrorAsKey_ \x3d function(e) {\n  var keyPrefix \x3d \x22\x22;\n  if (typeof e.toString \x3d\x3d\x3d \x22function\x22) {\n    keyPrefix \x3d \x22\x22 + e;\n  }\n  return keyPrefix + e[\x22stack\x22];\n};\ngoog.debug.enhanceError \x3d function(err, opt_message) {\n  var error;\n  if (!(err instanceof Error)) {\n    error \x3d Error(err);\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(error, goog.debug.enhanceError);\n    }\n  } else {\n    error \x3d err;\n  }\n  if (!error.stack) {\n    error.stack \x3d goog.debug.getStacktrace(goog.debug.enhanceError);\n  }\n  if (opt_message) {\n    var x \x3d 0;\n    for (; error[\x22message\x22 + x];) {\n      ++x;\n    }\n    error[\x22message\x22 + x] \x3d String(opt_message);\n  }\n  return error;\n};\ngoog.debug.enhanceErrorWithContext \x3d function(err, opt_context) {\n  var error \x3d goog.debug.enhanceError(err);\n  if (opt_context) {\n    var key;\n    for (key in opt_context) {\n      goog.debug.errorcontext.addErrorContext(error, key, opt_context[key]);\n    }\n  }\n  return error;\n};\ngoog.debug.getStacktraceSimple \x3d function(opt_depth) {\n  if (!goog.debug.FORCE_SLOPPY_STACKS) {\n    var stack \x3d goog.debug.getNativeStackTrace_(goog.debug.getStacktraceSimple);\n    if (stack) {\n      return stack;\n    }\n  }\n  var sb \x3d [];\n  var fn \x3d arguments.callee.caller;\n  var depth \x3d 0;\n  for (; fn \x26\x26 (!opt_depth || depth \x3c opt_depth);) {\n    sb.push(goog.debug.getFunctionName(fn));\n    sb.push(\x22()\\n\x22);\n    try {\n      fn \x3d fn.caller;\n    } catch (e) {\n      sb.push(\x22[exception trying to get caller]\\n\x22);\n      break;\n    }\n    depth++;\n    if (depth \x3e\x3d goog.debug.MAX_STACK_DEPTH) {\n      sb.push(\x22[...long stack...]\x22);\n      break;\n    }\n  }\n  if (opt_depth \x26\x26 depth \x3e\x3d opt_depth) {\n    sb.push(\x22[...reached max depth limit...]\x22);\n  } else {\n    sb.push(\x22[end]\x22);\n  }\n  return sb.join(\x22\x22);\n};\ngoog.debug.MAX_STACK_DEPTH \x3d 50;\ngoog.debug.getNativeStackTrace_ \x3d function(fn) {\n  var tempErr \x3d new Error();\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(tempErr, fn);\n    return String(tempErr.stack);\n  } else {\n    try {\n      throw tempErr;\n    } catch (e) {\n      tempErr \x3d e;\n    }\n    var stack \x3d tempErr.stack;\n    if (stack) {\n      return String(stack);\n    }\n  }\n  return null;\n};\ngoog.debug.getStacktrace \x3d function(fn) {\n  var stack;\n  if (!goog.debug.FORCE_SLOPPY_STACKS) {\n    var contextFn \x3d fn || goog.debug.getStacktrace;\n    stack \x3d goog.debug.getNativeStackTrace_(contextFn);\n  }\n  if (!stack) {\n    stack \x3d goog.debug.getStacktraceHelper_(fn || arguments.callee.caller, []);\n  }\n  return stack;\n};\ngoog.debug.getStacktraceHelper_ \x3d function(fn, visited) {\n  var sb \x3d [];\n  if (goog.array.contains(visited, fn)) {\n    sb.push(\x22[...circular reference...]\x22);\n  } else if (fn \x26\x26 visited.length \x3c goog.debug.MAX_STACK_DEPTH) {\n    sb.push(goog.debug.getFunctionName(fn) + \x22(\x22);\n    var args \x3d fn.arguments;\n    var i \x3d 0;\n    for (; args \x26\x26 i \x3c args.length; i++) {\n      if (i \x3e 0) {\n        sb.push(\x22, \x22);\n      }\n      var argDesc;\n      var arg \x3d args[i];\n      switch(typeof arg) {\n        case \x22object\x22:\n          argDesc \x3d arg ? \x22object\x22 : \x22null\x22;\n          break;\n        case \x22string\x22:\n          argDesc \x3d arg;\n          break;\n        case \x22number\x22:\n          argDesc \x3d String(arg);\n          break;\n        case \x22boolean\x22:\n          argDesc \x3d arg ? \x22true\x22 : \x22false\x22;\n          break;\n        case \x22function\x22:\n          argDesc \x3d goog.debug.getFunctionName(arg);\n          argDesc \x3d argDesc ? argDesc : \x22[fn]\x22;\n          break;\n        case \x22undefined\x22:\n        default:\n          argDesc \x3d typeof arg;\n          break;\n      }\n      if (argDesc.length \x3e 40) {\n        argDesc \x3d argDesc.slice(0, 40) + \x22...\x22;\n      }\n      sb.push(argDesc);\n    }\n    visited.push(fn);\n    sb.push(\x22)\\n\x22);\n    try {\n      sb.push(goog.debug.getStacktraceHelper_(fn.caller, visited));\n    } catch (e) {\n      sb.push(\x22[exception trying to get caller]\\n\x22);\n    }\n  } else if (fn) {\n    sb.push(\x22[...long stack...]\x22);\n  } else {\n    sb.push(\x22[end]\x22);\n  }\n  return sb.join(\x22\x22);\n};\ngoog.debug.getFunctionName \x3d function(fn) {\n  if (goog.debug.fnNameCache_[fn]) {\n    return goog.debug.fnNameCache_[fn];\n  }\n  var functionSource \x3d String(fn);\n  if (!goog.debug.fnNameCache_[functionSource]) {\n    var matches \x3d /function\\s+([^\\(]+)/m.exec(functionSource);\n    if (matches) {\n      var method \x3d matches[1];\n      goog.debug.fnNameCache_[functionSource] \x3d method;\n    } else {\n      goog.debug.fnNameCache_[functionSource] \x3d \x22[Anonymous]\x22;\n    }\n  }\n  return goog.debug.fnNameCache_[functionSource];\n};\ngoog.debug.makeWhitespaceVisible \x3d function(string) {\n  return string.replace(/ /g, \x22[_]\x22).replace(/\\f/g, \x22[f]\x22).replace(/\\n/g, \x22[n]\\n\x22).replace(/\\r/g, \x22[r]\x22).replace(/\\t/g, \x22[t]\x22);\n};\ngoog.debug.runtimeType \x3d function(value) {\n  if (value instanceof Function) {\n    return value.displayName || value.name || \x22unknown type name\x22;\n  } else if (value instanceof Object) {\n    return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);\n  } else {\n    return value \x3d\x3d\x3d null ? \x22null\x22 : typeof value;\n  }\n};\ngoog.debug.fnNameCache_ \x3d {};\ngoog.debug.freezeInternal_ \x3d goog.DEBUG \x26\x26 Object.freeze || function(arg) {\n  return arg;\n};\ngoog.debug.freeze \x3d function(arg) {\n  return {valueOf:function() {\n    return goog.debug.freezeInternal_(arg);\n  }}.valueOf();\n};\n");
SHADOW_ENV.evalLoad("goog.iter.iter.js", true, "goog.provide(\x22goog.iter\x22);\ngoog.provide(\x22goog.iter.Iterable\x22);\ngoog.provide(\x22goog.iter.Iterator\x22);\ngoog.require(\x22goog.array\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.debug\x22);\ngoog.require(\x22goog.functions\x22);\ngoog.require(\x22goog.math\x22);\ngoog.iter.Iterable;\ngoog.iter.Iterator \x3d function() {\n};\ngoog.iter.Iterator.prototype.next \x3d function() {\n  return goog.iter.ES6_ITERATOR_DONE;\n};\ngoog.iter.ES6_ITERATOR_DONE \x3d goog.debug.freeze({done:true, value:undefined});\ngoog.iter.createEs6IteratorYield \x3d function(value) {\n  return {value, done:false};\n};\ngoog.iter.Iterator.prototype.__iterator__ \x3d function(opt_keys) {\n  return this;\n};\ngoog.iter.toIterator \x3d function(iterable) {\n  if (iterable instanceof goog.iter.Iterator) {\n    return iterable;\n  }\n  if (typeof iterable.__iterator__ \x3d\x3d \x22function\x22) {\n    return iterable.__iterator__(false);\n  }\n  if (goog.isArrayLike(iterable)) {\n    const like \x3d iterable;\n    let i \x3d 0;\n    const newIter \x3d new goog.iter.Iterator();\n    newIter.next \x3d function() {\n      for (; true;) {\n        if (i \x3e\x3d like.length) {\n          return goog.iter.ES6_ITERATOR_DONE;\n        }\n        if (!(i in like)) {\n          i++;\n          continue;\n        }\n        return goog.iter.createEs6IteratorYield(like[i++]);\n      }\n    };\n    return newIter;\n  }\n  throw new Error(\x22Not implemented\x22);\n};\ngoog.iter.forEach \x3d function(iterable, f, opt_obj) {\n  if (goog.isArrayLike(iterable)) {\n    goog.array.forEach(iterable, f, opt_obj);\n  } else {\n    const iterator \x3d goog.iter.toIterator(iterable);\n    for (; true;) {\n      const {done, value} \x3d iterator.next();\n      if (done) {\n        return;\n      }\n      f.call(opt_obj, value, undefined, iterator);\n    }\n  }\n};\ngoog.iter.filter \x3d function(iterable, f, opt_obj) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const newIter \x3d new goog.iter.Iterator();\n  newIter.next \x3d function() {\n    for (; true;) {\n      const {done, value} \x3d iterator.next();\n      if (done) {\n        return goog.iter.ES6_ITERATOR_DONE;\n      }\n      if (f.call(opt_obj, value, undefined, iterator)) {\n        return goog.iter.createEs6IteratorYield(value);\n      }\n    }\n  };\n  return newIter;\n};\ngoog.iter.filterFalse \x3d function(iterable, f, opt_obj) {\n  return goog.iter.filter(iterable, goog.functions.not(f), opt_obj);\n};\ngoog.iter.range \x3d function(startOrStop, opt_stop, opt_step) {\n  let start \x3d 0;\n  let stop \x3d startOrStop;\n  let step \x3d opt_step || 1;\n  if (arguments.length \x3e 1) {\n    start \x3d startOrStop;\n    stop \x3d +opt_stop;\n  }\n  if (step \x3d\x3d 0) {\n    throw new Error(\x22Range step argument must not be zero\x22);\n  }\n  const newIter \x3d new goog.iter.Iterator();\n  newIter.next \x3d function() {\n    if (step \x3e 0 \x26\x26 start \x3e\x3d stop || step \x3c 0 \x26\x26 start \x3c\x3d stop) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    const rv \x3d start;\n    start \x3d start + step;\n    return goog.iter.createEs6IteratorYield(rv);\n  };\n  return newIter;\n};\ngoog.iter.join \x3d function(iterable, deliminator) {\n  return goog.iter.toArray(iterable).join(deliminator);\n};\ngoog.iter.map \x3d function(iterable, f, opt_obj) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const newIter \x3d new goog.iter.Iterator();\n  newIter.next \x3d function() {\n    const {done, value} \x3d iterator.next();\n    if (done) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    const mappedVal \x3d f.call(opt_obj, value, undefined, iterator);\n    return goog.iter.createEs6IteratorYield(mappedVal);\n  };\n  return newIter;\n};\ngoog.iter.reduce \x3d function(iterable, f, val, opt_obj) {\n  let rval \x3d val;\n  goog.iter.forEach(iterable, function(val) {\n    rval \x3d f.call(opt_obj, rval, val);\n  });\n  return rval;\n};\ngoog.iter.some \x3d function(iterable, f, opt_obj) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  for (; true;) {\n    const {done, value} \x3d iterator.next();\n    if (done) {\n      return false;\n    }\n    if (f.call(opt_obj, value, undefined, iterator)) {\n      return true;\n    }\n  }\n};\ngoog.iter.every \x3d function(iterable, f, opt_obj) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  for (; true;) {\n    const {done, value} \x3d iterator.next();\n    if (done) {\n      return true;\n    }\n    if (!f.call(opt_obj, value, undefined, iterator)) {\n      return false;\n    }\n  }\n};\ngoog.iter.chain \x3d function(var_args) {\n  return goog.iter.chainFromIterable(arguments);\n};\ngoog.iter.chainFromIterable \x3d function(iterable) {\n  const iteratorOfIterators \x3d goog.iter.toIterator(iterable);\n  const iter \x3d new goog.iter.Iterator();\n  let current \x3d null;\n  iter.next \x3d function() {\n    for (; true;) {\n      if (current \x3d\x3d null) {\n        const it \x3d iteratorOfIterators.next();\n        if (it.done) {\n          return goog.iter.ES6_ITERATOR_DONE;\n        }\n        const value \x3d it.value;\n        current \x3d goog.iter.toIterator(value);\n      }\n      const it \x3d current.next();\n      if (it.done) {\n        current \x3d null;\n        continue;\n      }\n      const value \x3d it.value;\n      return goog.iter.createEs6IteratorYield(value);\n    }\n  };\n  return iter;\n};\ngoog.iter.dropWhile \x3d function(iterable, f, opt_obj) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const newIter \x3d new goog.iter.Iterator();\n  let dropping \x3d true;\n  newIter.next \x3d function() {\n    for (; true;) {\n      const {done, value} \x3d iterator.next();\n      if (done) {\n        return goog.iter.ES6_ITERATOR_DONE;\n      }\n      if (dropping \x26\x26 f.call(opt_obj, value, undefined, iterator)) {\n        continue;\n      } else {\n        dropping \x3d false;\n      }\n      return goog.iter.createEs6IteratorYield(value);\n    }\n  };\n  return newIter;\n};\ngoog.iter.takeWhile \x3d function(iterable, f, opt_obj) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const iter \x3d new goog.iter.Iterator();\n  iter.next \x3d function() {\n    const {done, value} \x3d iterator.next();\n    if (done) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    if (f.call(opt_obj, value, undefined, iterator)) {\n      return goog.iter.createEs6IteratorYield(value);\n    }\n    return goog.iter.ES6_ITERATOR_DONE;\n  };\n  return iter;\n};\ngoog.iter.toArray \x3d function(iterable) {\n  if (goog.isArrayLike(iterable)) {\n    return goog.array.toArray(iterable);\n  }\n  iterable \x3d goog.iter.toIterator(iterable);\n  const array \x3d [];\n  goog.iter.forEach(iterable, function(val) {\n    array.push(val);\n  });\n  return array;\n};\ngoog.iter.equals \x3d function(iterable1, iterable2, opt_equalsFn) {\n  const fillValue \x3d {};\n  const pairs \x3d goog.iter.zipLongest(fillValue, iterable1, iterable2);\n  const equalsFn \x3d opt_equalsFn || goog.array.defaultCompareEquality;\n  return goog.iter.every(pairs, function(pair) {\n    return equalsFn(pair[0], pair[1]);\n  });\n};\ngoog.iter.nextOrValue \x3d function(iterable, defaultValue) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const {done, value} \x3d iterator.next();\n  if (done) {\n    return defaultValue;\n  }\n  return value;\n};\ngoog.iter.product \x3d function(var_args) {\n  const someArrayEmpty \x3d Array.prototype.some.call(arguments, function(arr) {\n    return !arr.length;\n  });\n  if (someArrayEmpty || !arguments.length) {\n    return new goog.iter.Iterator();\n  }\n  const iter \x3d new goog.iter.Iterator();\n  const arrays \x3d arguments;\n  let indices \x3d goog.array.repeat(0, arrays.length);\n  iter.next \x3d function() {\n    if (indices) {\n      const retVal \x3d goog.array.map(indices, function(valueIndex, arrayIndex) {\n        return arrays[arrayIndex][valueIndex];\n      });\n      for (let i \x3d indices.length - 1; i \x3e\x3d 0; i--) {\n        goog.asserts.assert(indices);\n        if (indices[i] \x3c arrays[i].length - 1) {\n          indices[i]++;\n          break;\n        }\n        if (i \x3d\x3d 0) {\n          indices \x3d null;\n          break;\n        }\n        indices[i] \x3d 0;\n      }\n      return goog.iter.createEs6IteratorYield(retVal);\n    }\n    return goog.iter.ES6_ITERATOR_DONE;\n  };\n  return iter;\n};\ngoog.iter.cycle \x3d function(iterable) {\n  const baseIterator \x3d goog.iter.toIterator(iterable);\n  const cache \x3d [];\n  let cacheIndex \x3d 0;\n  const iter \x3d new goog.iter.Iterator();\n  let useCache \x3d false;\n  iter.next \x3d function() {\n    let returnElement \x3d null;\n    if (!useCache) {\n      const it \x3d baseIterator.next();\n      if (it.done) {\n        if (goog.array.isEmpty(cache)) {\n          return goog.iter.ES6_ITERATOR_DONE;\n        }\n        useCache \x3d true;\n      } else {\n        cache.push(it.value);\n        return it;\n      }\n    }\n    returnElement \x3d cache[cacheIndex];\n    cacheIndex \x3d (cacheIndex + 1) % cache.length;\n    return goog.iter.createEs6IteratorYield(returnElement);\n  };\n  return iter;\n};\ngoog.iter.count \x3d function(opt_start, opt_step) {\n  let counter \x3d opt_start || 0;\n  const step \x3d opt_step !\x3d\x3d undefined ? opt_step : 1;\n  const iter \x3d new goog.iter.Iterator();\n  iter.next \x3d function() {\n    const returnValue \x3d counter;\n    counter \x3d counter + step;\n    return goog.iter.createEs6IteratorYield(returnValue);\n  };\n  return iter;\n};\ngoog.iter.repeat \x3d function(value) {\n  const iter \x3d new goog.iter.Iterator();\n  iter.next \x3d function() {\n    return goog.iter.createEs6IteratorYield(value);\n  };\n  return iter;\n};\ngoog.iter.accumulate \x3d function(iterable) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  let total \x3d 0;\n  const iter \x3d new goog.iter.Iterator();\n  iter.next \x3d function() {\n    const {done, value} \x3d iterator.next();\n    if (done) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    total \x3d total + value;\n    return goog.iter.createEs6IteratorYield(total);\n  };\n  return iter;\n};\ngoog.iter.zip \x3d function(var_args) {\n  const args \x3d arguments;\n  const iter \x3d new goog.iter.Iterator();\n  if (args.length \x3e 0) {\n    const iterators \x3d goog.array.map(args, goog.iter.toIterator);\n    let allDone \x3d false;\n    iter.next \x3d function() {\n      if (allDone) {\n        return goog.iter.ES6_ITERATOR_DONE;\n      }\n      const arr \x3d [];\n      for (let i \x3d 0, iterator; iterator \x3d iterators[i++];) {\n        const it \x3d iterator.next();\n        if (it.done) {\n          allDone \x3d true;\n          return goog.iter.ES6_ITERATOR_DONE;\n        }\n        arr.push(it.value);\n      }\n      return goog.iter.createEs6IteratorYield(arr);\n    };\n  }\n  return iter;\n};\ngoog.iter.zipLongest \x3d function(fillValue, var_args) {\n  const args \x3d Array.prototype.slice.call(arguments, 1);\n  const iter \x3d new goog.iter.Iterator();\n  if (args.length \x3e 0) {\n    const iterators \x3d goog.array.map(args, goog.iter.toIterator);\n    let allDone \x3d false;\n    iter.next \x3d function() {\n      if (allDone) {\n        return goog.iter.ES6_ITERATOR_DONE;\n      }\n      let iteratorsHaveValues \x3d false;\n      const arr \x3d [];\n      for (let i \x3d 0, iterator; iterator \x3d iterators[i++];) {\n        const it \x3d iterator.next();\n        if (it.done) {\n          arr.push(fillValue);\n          continue;\n        }\n        arr.push(it.value);\n        iteratorsHaveValues \x3d true;\n      }\n      if (!iteratorsHaveValues) {\n        allDone \x3d true;\n        return goog.iter.ES6_ITERATOR_DONE;\n      }\n      return goog.iter.createEs6IteratorYield(arr);\n    };\n  }\n  return iter;\n};\ngoog.iter.compress \x3d function(iterable, selectors) {\n  const valueIterator \x3d goog.iter.toIterator(iterable);\n  const selectorIterator \x3d goog.iter.toIterator(selectors);\n  const iter \x3d new goog.iter.Iterator();\n  let allDone \x3d false;\n  iter.next \x3d function() {\n    if (allDone) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    for (; true;) {\n      const valIt \x3d valueIterator.next();\n      if (valIt.done) {\n        allDone \x3d true;\n        return goog.iter.ES6_ITERATOR_DONE;\n      }\n      const selectorIt \x3d selectorIterator.next();\n      if (selectorIt.done) {\n        allDone \x3d true;\n        return goog.iter.ES6_ITERATOR_DONE;\n      }\n      const val \x3d valIt.value;\n      const selectorVal \x3d selectorIt.value;\n      if (selectorVal) {\n        return goog.iter.createEs6IteratorYield(val);\n      }\n    }\n  };\n  return iter;\n};\ngoog.iter.GroupByIterator_ \x3d function(iterable, opt_keyFunc) {\n  this.iterator \x3d goog.iter.toIterator(iterable);\n  this.keyFunc \x3d opt_keyFunc || goog.functions.identity;\n  this.targetKey;\n  this.currentKey;\n  this.currentValue;\n};\ngoog.inherits(goog.iter.GroupByIterator_, goog.iter.Iterator);\ngoog.iter.GroupByIterator_.prototype.next \x3d function() {\n  for (; this.currentKey \x3d\x3d this.targetKey;) {\n    const it \x3d this.iterator.next();\n    if (it.done) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    this.currentValue \x3d it.value;\n    this.currentKey \x3d this.keyFunc(this.currentValue);\n  }\n  this.targetKey \x3d this.currentKey;\n  return goog.iter.createEs6IteratorYield([this.currentKey, this.groupItems_(this.targetKey)]);\n};\ngoog.iter.GroupByIterator_.prototype.groupItems_ \x3d function(targetKey) {\n  const arr \x3d [];\n  for (; this.currentKey \x3d\x3d targetKey;) {\n    arr.push(this.currentValue);\n    const it \x3d this.iterator.next();\n    if (it.done) {\n      break;\n    }\n    this.currentValue \x3d it.value;\n    this.currentKey \x3d this.keyFunc(this.currentValue);\n  }\n  return arr;\n};\ngoog.iter.groupBy \x3d function(iterable, opt_keyFunc) {\n  return new goog.iter.GroupByIterator_(iterable, opt_keyFunc);\n};\ngoog.iter.starMap \x3d function(iterable, f, opt_obj) {\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const iter \x3d new goog.iter.Iterator();\n  iter.next \x3d function() {\n    const it \x3d iterator.next();\n    if (it.done) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    const args \x3d goog.iter.toArray(it.value);\n    const value \x3d f.apply(opt_obj, [].concat(args, undefined, iterator));\n    return goog.iter.createEs6IteratorYield(value);\n  };\n  return iter;\n};\ngoog.iter.tee \x3d function(iterable, opt_num) {\n  function addNextIteratorValueToBuffers() {\n    const {done, value} \x3d iterator.next();\n    if (done) {\n      return false;\n    }\n    for (let i \x3d 0, buffer; buffer \x3d buffers[i++];) {\n      buffer.push(value);\n    }\n    return true;\n  }\n  function createIterator(buffer) {\n    const iter \x3d new goog.iter.Iterator();\n    iter.next \x3d function() {\n      if (goog.array.isEmpty(buffer)) {\n        const added \x3d addNextIteratorValueToBuffers();\n        if (!added) {\n          return goog.iter.ES6_ITERATOR_DONE;\n        }\n      }\n      goog.asserts.assert(!goog.array.isEmpty(buffer));\n      return goog.iter.createEs6IteratorYield(buffer.shift());\n    };\n    return iter;\n  }\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const num \x3d typeof opt_num \x3d\x3d\x3d \x22number\x22 ? opt_num : 2;\n  const buffers \x3d goog.array.map(goog.array.range(num), function() {\n    return [];\n  });\n  return goog.array.map(buffers, createIterator);\n};\ngoog.iter.enumerate \x3d function(iterable, opt_start) {\n  return goog.iter.zip(goog.iter.count(opt_start), iterable);\n};\ngoog.iter.limit \x3d function(iterable, limitSize) {\n  goog.asserts.assert(goog.math.isInt(limitSize) \x26\x26 limitSize \x3e\x3d 0);\n  const iterator \x3d goog.iter.toIterator(iterable);\n  const iter \x3d new goog.iter.Iterator();\n  let remaining \x3d limitSize;\n  iter.next \x3d function() {\n    if (remaining-- \x3e 0) {\n      return iterator.next();\n    }\n    return goog.iter.ES6_ITERATOR_DONE;\n  };\n  return iter;\n};\ngoog.iter.consume \x3d function(iterable, count) {\n  goog.asserts.assert(goog.math.isInt(count) \x26\x26 count \x3e\x3d 0);\n  const iterator \x3d goog.iter.toIterator(iterable);\n  for (; count-- \x3e 0;) {\n    goog.iter.nextOrValue(iterator, null);\n  }\n  return iterator;\n};\ngoog.iter.slice \x3d function(iterable, start, opt_end) {\n  goog.asserts.assert(goog.math.isInt(start) \x26\x26 start \x3e\x3d 0);\n  let iterator \x3d goog.iter.consume(iterable, start);\n  if (typeof opt_end \x3d\x3d\x3d \x22number\x22) {\n    goog.asserts.assert(goog.math.isInt(opt_end) \x26\x26 opt_end \x3e\x3d start);\n    iterator \x3d goog.iter.limit(iterator, opt_end - start);\n  }\n  return iterator;\n};\ngoog.iter.hasDuplicates_ \x3d function(arr) {\n  const deduped \x3d [];\n  goog.array.removeDuplicates(arr, deduped);\n  return arr.length !\x3d deduped.length;\n};\ngoog.iter.permutations \x3d function(iterable, opt_length) {\n  const elements \x3d goog.iter.toArray(iterable);\n  const length \x3d typeof opt_length \x3d\x3d\x3d \x22number\x22 ? opt_length : elements.length;\n  const sets \x3d goog.array.repeat(elements, length);\n  const product \x3d goog.iter.product.apply(undefined, sets);\n  return goog.iter.filter(product, function(arr) {\n    return !goog.iter.hasDuplicates_(arr);\n  });\n};\ngoog.iter.combinations \x3d function(iterable, length) {\n  function getIndexFromElements(index) {\n    return elements[index];\n  }\n  const elements \x3d goog.iter.toArray(iterable);\n  const indexes \x3d goog.iter.range(elements.length);\n  const indexIterator \x3d goog.iter.permutations(indexes, length);\n  const sortedIndexIterator \x3d goog.iter.filter(indexIterator, function(arr) {\n    return goog.array.isSorted(arr);\n  });\n  const iter \x3d new goog.iter.Iterator();\n  iter.next \x3d function() {\n    const {done, value} \x3d sortedIndexIterator.next();\n    if (done) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    return goog.iter.createEs6IteratorYield(goog.array.map(value, getIndexFromElements));\n  };\n  return iter;\n};\ngoog.iter.combinationsWithReplacement \x3d function(iterable, length) {\n  function getIndexFromElements(index) {\n    return elements[index];\n  }\n  const elements \x3d goog.iter.toArray(iterable);\n  const indexes \x3d goog.array.range(elements.length);\n  const sets \x3d goog.array.repeat(indexes, length);\n  const indexIterator \x3d goog.iter.product.apply(undefined, sets);\n  const sortedIndexIterator \x3d goog.iter.filter(indexIterator, function(arr) {\n    return goog.array.isSorted(arr);\n  });\n  const iter \x3d new goog.iter.Iterator();\n  iter.next \x3d function() {\n    const {done, value} \x3d sortedIndexIterator.next();\n    if (done) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    return goog.iter.createEs6IteratorYield(goog.array.map(value, getIndexFromElements));\n  };\n  return iter;\n};\n");
SHADOW_ENV.evalLoad("goog.iter.es6.js", true, "goog.loadModule(function(exports) {\n  \x22use strict\x22;\n  goog.module(\x22goog.iter.es6\x22);\n  goog.module.declareLegacyNamespace();\n  const GoogIterable \x3d goog.require(\x22goog.iter.Iterable\x22);\n  const GoogIterator \x3d goog.require(\x22goog.iter.Iterator\x22);\n  class ShimIterable {\n    __iterator__() {\n    }\n    toGoog() {\n    }\n    toEs6() {\n    }\n    static of(iter) {\n      if (iter instanceof ShimIterableImpl || iter instanceof ShimGoogIterator || iter instanceof ShimEs6Iterator) {\n        return iter;\n      } else if (typeof iter.next \x3d\x3d \x22function\x22) {\n        return new ShimIterableImpl(() \x3d\x3e {\n          return iter;\n        });\n      } else if (typeof iter[Symbol.iterator] \x3d\x3d \x22function\x22) {\n        return new ShimIterableImpl(() \x3d\x3e {\n          return iter[Symbol.iterator]();\n        });\n      } else if (typeof iter.__iterator__ \x3d\x3d \x22function\x22) {\n        return new ShimIterableImpl(() \x3d\x3e {\n          return iter.__iterator__();\n        });\n      }\n      throw new Error(\x22Not an iterator or iterable.\x22);\n    }\n  }\n  class ShimIterableImpl {\n    constructor(func) {\n      this.func_ \x3d func;\n    }\n    __iterator__() {\n      return new ShimGoogIterator(this.func_());\n    }\n    toGoog() {\n      return new ShimGoogIterator(this.func_());\n    }\n    [Symbol.iterator]() {\n      return new ShimEs6Iterator(this.func_());\n    }\n    toEs6() {\n      return new ShimEs6Iterator(this.func_());\n    }\n  }\n  class ShimGoogIterator extends GoogIterator {\n    constructor(iter) {\n      super();\n      this.iter_ \x3d iter;\n    }\n    next() {\n      return this.iter_.next();\n    }\n    toGoog() {\n      return this;\n    }\n    [Symbol.iterator]() {\n      return new ShimEs6Iterator(this.iter_);\n    }\n    toEs6() {\n      return new ShimEs6Iterator(this.iter_);\n    }\n  }\n  class ShimEs6Iterator extends ShimIterableImpl {\n    constructor(iter) {\n      super(() \x3d\x3e {\n        return iter;\n      });\n      this.iter_ \x3d iter;\n    }\n    next() {\n      return this.iter_.next();\n    }\n  }\n  exports \x3d {ShimIterable, ShimEs6Iterator, ShimGoogIterator};\n  return exports;\n});\n");
SHADOW_ENV.evalLoad("goog.structs.map.js", true, "goog.provide(\x22goog.structs.Map\x22);\ngoog.require(\x22goog.collections.iters\x22);\ngoog.require(\x22goog.iter\x22);\ngoog.require(\x22goog.iter.Iterator\x22);\ngoog.require(\x22goog.iter.es6\x22);\ngoog.structs.Map \x3d function(opt_map, var_args) {\n  this.map_ \x3d {};\n  this.keys_ \x3d [];\n  this.size \x3d 0;\n  this.version_ \x3d 0;\n  var argLength \x3d arguments.length;\n  if (argLength \x3e 1) {\n    if (argLength % 2) {\n      throw new Error(\x22Uneven number of arguments\x22);\n    }\n    var i \x3d 0;\n    for (; i \x3c argLength; i \x3d i + 2) {\n      this.set(arguments[i], arguments[i + 1]);\n    }\n  } else if (opt_map) {\n    this.addAll(opt_map);\n  }\n};\ngoog.structs.Map.prototype.getCount \x3d function() {\n  return this.size;\n};\ngoog.structs.Map.prototype.getValues \x3d function() {\n  this.cleanupKeysArray_();\n  var rv \x3d [];\n  var i \x3d 0;\n  for (; i \x3c this.keys_.length; i++) {\n    var key \x3d this.keys_[i];\n    rv.push(this.map_[key]);\n  }\n  return rv;\n};\ngoog.structs.Map.prototype.getKeys \x3d function() {\n  this.cleanupKeysArray_();\n  return this.keys_.concat();\n};\ngoog.structs.Map.prototype.containsKey \x3d function(key) {\n  return this.has(key);\n};\ngoog.structs.Map.prototype.has \x3d function(key) {\n  return goog.structs.Map.hasKey_(this.map_, key);\n};\ngoog.structs.Map.prototype.containsValue \x3d function(val) {\n  var i \x3d 0;\n  for (; i \x3c this.keys_.length; i++) {\n    var key \x3d this.keys_[i];\n    if (goog.structs.Map.hasKey_(this.map_, key) \x26\x26 this.map_[key] \x3d\x3d val) {\n      return true;\n    }\n  }\n  return false;\n};\ngoog.structs.Map.prototype.equals \x3d function(otherMap, opt_equalityFn) {\n  if (this \x3d\x3d\x3d otherMap) {\n    return true;\n  }\n  if (this.size !\x3d otherMap.getCount()) {\n    return false;\n  }\n  var equalityFn \x3d opt_equalityFn || goog.structs.Map.defaultEquals;\n  this.cleanupKeysArray_();\n  var key;\n  var i \x3d 0;\n  for (; key \x3d this.keys_[i]; i++) {\n    if (!equalityFn(this.get(key), otherMap.get(key))) {\n      return false;\n    }\n  }\n  return true;\n};\ngoog.structs.Map.defaultEquals \x3d function(a, b) {\n  return a \x3d\x3d\x3d b;\n};\ngoog.structs.Map.prototype.isEmpty \x3d function() {\n  return this.size \x3d\x3d 0;\n};\ngoog.structs.Map.prototype.clear \x3d function() {\n  this.map_ \x3d {};\n  this.keys_.length \x3d 0;\n  this.setSizeInternal_(0);\n  this.version_ \x3d 0;\n};\ngoog.structs.Map.prototype.remove \x3d function(key) {\n  return this.delete(key);\n};\ngoog.structs.Map.prototype.delete \x3d function(key) {\n  if (goog.structs.Map.hasKey_(this.map_, key)) {\n    delete this.map_[key];\n    this.setSizeInternal_(this.size - 1);\n    this.version_++;\n    if (this.keys_.length \x3e 2 * this.size) {\n      this.cleanupKeysArray_();\n    }\n    return true;\n  }\n  return false;\n};\ngoog.structs.Map.prototype.cleanupKeysArray_ \x3d function() {\n  if (this.size !\x3d this.keys_.length) {\n    var srcIndex \x3d 0;\n    var destIndex \x3d 0;\n    for (; srcIndex \x3c this.keys_.length;) {\n      var key \x3d this.keys_[srcIndex];\n      if (goog.structs.Map.hasKey_(this.map_, key)) {\n        this.keys_[destIndex++] \x3d key;\n      }\n      srcIndex++;\n    }\n    this.keys_.length \x3d destIndex;\n  }\n  if (this.size !\x3d this.keys_.length) {\n    var seen \x3d {};\n    srcIndex \x3d 0;\n    destIndex \x3d 0;\n    for (; srcIndex \x3c this.keys_.length;) {\n      key \x3d this.keys_[srcIndex];\n      if (!goog.structs.Map.hasKey_(seen, key)) {\n        this.keys_[destIndex++] \x3d key;\n        seen[key] \x3d 1;\n      }\n      srcIndex++;\n    }\n    this.keys_.length \x3d destIndex;\n  }\n};\ngoog.structs.Map.prototype.get \x3d function(key, opt_val) {\n  if (goog.structs.Map.hasKey_(this.map_, key)) {\n    return this.map_[key];\n  }\n  return opt_val;\n};\ngoog.structs.Map.prototype.set \x3d function(key, value) {\n  if (!goog.structs.Map.hasKey_(this.map_, key)) {\n    this.setSizeInternal_(this.size + 1);\n    this.keys_.push(key);\n    this.version_++;\n  }\n  this.map_[key] \x3d value;\n};\ngoog.structs.Map.prototype.addAll \x3d function(map) {\n  if (map instanceof goog.structs.Map) {\n    var keys \x3d map.getKeys();\n    var i \x3d 0;\n    for (; i \x3c keys.length; i++) {\n      this.set(keys[i], map.get(keys[i]));\n    }\n  } else {\n    var key;\n    for (key in map) {\n      this.set(key, map[key]);\n    }\n  }\n};\ngoog.structs.Map.prototype.forEach \x3d function(f, opt_obj) {\n  var keys \x3d this.getKeys();\n  var i \x3d 0;\n  for (; i \x3c keys.length; i++) {\n    var key \x3d keys[i];\n    var value \x3d this.get(key);\n    f.call(opt_obj, value, key, this);\n  }\n};\ngoog.structs.Map.prototype.clone \x3d function() {\n  return new goog.structs.Map(this);\n};\ngoog.structs.Map.prototype.transpose \x3d function() {\n  var transposed \x3d new goog.structs.Map();\n  var i \x3d 0;\n  for (; i \x3c this.keys_.length; i++) {\n    var key \x3d this.keys_[i];\n    var value \x3d this.map_[key];\n    transposed.set(value, key);\n  }\n  return transposed;\n};\ngoog.structs.Map.prototype.toObject \x3d function() {\n  this.cleanupKeysArray_();\n  var obj \x3d {};\n  var i \x3d 0;\n  for (; i \x3c this.keys_.length; i++) {\n    var key \x3d this.keys_[i];\n    obj[key] \x3d this.map_[key];\n  }\n  return obj;\n};\ngoog.structs.Map.prototype.getKeyIterator \x3d function() {\n  return this.__iterator__(true);\n};\ngoog.structs.Map.prototype.keys \x3d function() {\n  return goog.iter.es6.ShimIterable.of(this.getKeyIterator()).toEs6();\n};\ngoog.structs.Map.prototype.getValueIterator \x3d function() {\n  return this.__iterator__(false);\n};\ngoog.structs.Map.prototype.values \x3d function() {\n  return goog.iter.es6.ShimIterable.of(this.getValueIterator()).toEs6();\n};\ngoog.structs.Map.prototype.entries \x3d function() {\n  const self \x3d this;\n  return goog.collections.iters.map(this.keys(), function(key) {\n    return [key, self.get(key)];\n  });\n};\ngoog.structs.Map.prototype.__iterator__ \x3d function(opt_keys) {\n  this.cleanupKeysArray_();\n  var i \x3d 0;\n  var version \x3d this.version_;\n  var selfObj \x3d this;\n  var newIter \x3d new goog.iter.Iterator();\n  newIter.next \x3d function() {\n    if (version !\x3d selfObj.version_) {\n      throw new Error(\x22The map has changed since the iterator was created\x22);\n    }\n    if (i \x3e\x3d selfObj.keys_.length) {\n      return goog.iter.ES6_ITERATOR_DONE;\n    }\n    var key \x3d selfObj.keys_[i++];\n    return goog.iter.createEs6IteratorYield(opt_keys ? key : selfObj.map_[key]);\n  };\n  return newIter;\n};\ngoog.structs.Map.prototype.setSizeInternal_ \x3d function(newSize) {\n  this.size \x3d newSize;\n};\ngoog.structs.Map.hasKey_ \x3d function(obj, key) {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n};\n");
SHADOW_ENV.evalLoad("goog.window.window.js", true, "goog.provide(\x22goog.window\x22);\ngoog.require(\x22goog.dom\x22);\ngoog.require(\x22goog.dom.TagName\x22);\ngoog.require(\x22goog.dom.safe\x22);\ngoog.require(\x22goog.html.SafeUrl\x22);\ngoog.require(\x22goog.html.uncheckedconversions\x22);\ngoog.require(\x22goog.labs.userAgent.platform\x22);\ngoog.require(\x22goog.string\x22);\ngoog.require(\x22goog.string.Const\x22);\ngoog.require(\x22goog.userAgent\x22);\ngoog.requireType(\x22goog.string.TypedString\x22);\ngoog.window.DEFAULT_POPUP_HEIGHT \x3d 500;\ngoog.window.DEFAULT_POPUP_WIDTH \x3d 690;\ngoog.window.DEFAULT_POPUP_TARGET \x3d \x22google_popup\x22;\ngoog.window.createFakeWindow_ \x3d function() {\n  return {};\n};\ngoog.window.open \x3d function(linkRef, opt_options, opt_parentWin) {\n  if (!opt_options) {\n    opt_options \x3d {};\n  }\n  var parentWin \x3d opt_parentWin || window;\n  var safeLinkRef;\n  if (linkRef instanceof goog.html.SafeUrl) {\n    safeLinkRef \x3d linkRef;\n  } else {\n    var url \x3d typeof linkRef.href !\x3d \x22undefined\x22 ? linkRef.href : String(linkRef);\n    safeLinkRef \x3d goog.html.SafeUrl.sanitize(url);\n  }\n  const browserSupportsCoop \x3d self.crossOriginIsolated !\x3d\x3d undefined;\n  let referrerPolicy \x3d \x22strict-origin-when-cross-origin\x22;\n  if (window.Request) {\n    referrerPolicy \x3d (new Request(\x22/\x22)).referrerPolicy;\n  }\n  const pageSetsUnsafeReferrerPolicy \x3d referrerPolicy \x3d\x3d\x3d \x22unsafe-url\x22;\n  let noReferrerOption \x3d opt_options[\x22noreferrer\x22];\n  if (browserSupportsCoop \x26\x26 noReferrerOption) {\n    if (pageSetsUnsafeReferrerPolicy) {\n      throw new Error(\x22Cannot use the noreferrer option on a page that sets a referrer-policy of `unsafe-url` in modern browsers!\x22);\n    }\n    noReferrerOption \x3d false;\n  }\n  var target \x3d opt_options.target || linkRef.target;\n  var sb \x3d [];\n  var option;\n  for (option in opt_options) {\n    switch(option) {\n      case \x22width\x22:\n      case \x22height\x22:\n      case \x22top\x22:\n      case \x22left\x22:\n        sb.push(option + \x22\\x3d\x22 + opt_options[option]);\n        break;\n      case \x22target\x22:\n      case \x22noopener\x22:\n      case \x22noreferrer\x22:\n        break;\n      default:\n        sb.push(option + \x22\\x3d\x22 + (opt_options[option] ? 1 : 0));\n    }\n  }\n  var optionString \x3d sb.join(\x22,\x22);\n  var newWin;\n  if (goog.labs.userAgent.platform.isIos() \x26\x26 parentWin.navigator \x26\x26 parentWin.navigator[\x22standalone\x22] \x26\x26 target \x26\x26 target !\x3d \x22_self\x22) {\n    var a \x3d goog.dom.createElement(goog.dom.TagName.A);\n    goog.dom.safe.setAnchorHref(a, safeLinkRef);\n    a.target \x3d target;\n    if (noReferrerOption) {\n      a.rel \x3d \x22noreferrer\x22;\n    }\n    var click \x3d document.createEvent(\x22MouseEvent\x22);\n    click.initMouseEvent(\x22click\x22, true, true, parentWin, 1);\n    a.dispatchEvent(click);\n    newWin \x3d goog.window.createFakeWindow_();\n  } else if (noReferrerOption) {\n    newWin \x3d goog.dom.safe.openInWindow(\x22\x22, parentWin, target, optionString);\n    var sanitizedLinkRef \x3d goog.html.SafeUrl.unwrap(safeLinkRef);\n    if (newWin) {\n      if (goog.userAgent.EDGE_OR_IE) {\n        if (goog.string.contains(sanitizedLinkRef, \x22;\x22)) {\n          sanitizedLinkRef \x3d \x22\x27\x22 + sanitizedLinkRef.replace(/\x27/g, \x22%27\x22) + \x22\x27\x22;\n        }\n      }\n      newWin.opener \x3d null;\n      if (sanitizedLinkRef \x3d\x3d\x3d \x22\x22) {\n        sanitizedLinkRef \x3d \x22javascript:\x27\x27\x22;\n      }\n      var safeHtml \x3d goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from(\x22b/12014412, meta tag with sanitized URL\x22), \x27\\x3cmeta name\\x3d\x22referrer\x22 content\\x3d\x22no-referrer\x22\\x3e\x27 + \x27\\x3cmeta http-equiv\\x3d\x22refresh\x22 content\\x3d\x220; url\\x3d\x27 + goog.string.htmlEscape(sanitizedLinkRef) + \x27\x22\\x3e\x27);\n      var newDoc \x3d newWin.document;\n      if (newDoc \x26\x26 newDoc.write) {\n        goog.dom.safe.documentWrite(newDoc, safeHtml);\n        newDoc.close();\n      }\n    }\n  } else {\n    newWin \x3d goog.dom.safe.openInWindow(safeLinkRef, parentWin, target, optionString);\n    if (newWin \x26\x26 opt_options[\x22noopener\x22]) {\n      newWin.opener \x3d null;\n    }\n    if (newWin \x26\x26 opt_options[\x22noreferrer\x22]) {\n      newWin.opener \x3d null;\n    }\n  }\n  return newWin;\n};\ngoog.window.openBlank \x3d function(opt_message, opt_options, opt_parentWin) {\n  const win \x3d goog.window.open(\x22\x22, opt_options, opt_parentWin);\n  if (win \x26\x26 opt_message) {\n    const body \x3d win.document.body;\n    if (body) {\n      body.textContent \x3d opt_message;\n    }\n  }\n  return win;\n};\ngoog.window.popup \x3d function(linkRef, opt_options) {\n  if (!opt_options) {\n    opt_options \x3d {};\n  }\n  opt_options[\x22target\x22] \x3d opt_options[\x22target\x22] || linkRef[\x22target\x22] || goog.window.DEFAULT_POPUP_TARGET;\n  opt_options[\x22width\x22] \x3d opt_options[\x22width\x22] || goog.window.DEFAULT_POPUP_WIDTH;\n  opt_options[\x22height\x22] \x3d opt_options[\x22height\x22] || goog.window.DEFAULT_POPUP_HEIGHT;\n  var newWin \x3d goog.window.open(linkRef, opt_options);\n  if (!newWin) {\n    return true;\n  }\n  newWin.focus();\n  return false;\n};\n");
SHADOW_ENV.evalLoad("goog.dom.forms.js", true, "goog.provide(\x22goog.dom.forms\x22);\ngoog.require(\x22goog.dom.InputType\x22);\ngoog.require(\x22goog.dom.TagName\x22);\ngoog.require(\x22goog.dom.safe\x22);\ngoog.require(\x22goog.structs.Map\x22);\ngoog.require(\x22goog.window\x22);\ngoog.dom.forms.submitFormInNewWindow \x3d function(form, opt_submitElement) {\n  var formData \x3d goog.dom.forms.getFormDataMap(form);\n  var action \x3d form.action;\n  var method \x3d form.method;\n  if (opt_submitElement) {\n    if (goog.dom.InputType.SUBMIT !\x3d opt_submitElement.type.toLowerCase()) {\n      throw new Error(\x22opt_submitElement does not have a valid type.\x22);\n    }\n    var submitValue \x3d goog.dom.forms.getValue(opt_submitElement);\n    if (submitValue !\x3d null) {\n      goog.dom.forms.addFormDataToMap_(formData, opt_submitElement.name, submitValue);\n    }\n    if (opt_submitElement.getAttribute(\x22formaction\x22)) {\n      action \x3d opt_submitElement.getAttribute(\x22formaction\x22);\n    }\n    if (opt_submitElement.getAttribute(\x22formmethod\x22)) {\n      method \x3d opt_submitElement.getAttribute(\x22formmethod\x22);\n    }\n  }\n  return goog.dom.forms.submitFormDataInNewWindow(action, method, formData);\n};\ngoog.dom.forms.submitFormDataInNewWindow \x3d function(actionUri, method, formData) {\n  var newWin \x3d goog.window.openBlank(\x22\x22, {noreferrer:true});\n  if (!newWin) {\n    return false;\n  }\n  var newDocument \x3d newWin.document;\n  var newForm \x3d newDocument.createElement(\x22form\x22);\n  newForm.method \x3d method;\n  goog.dom.safe.setFormElementAction(newForm, actionUri);\n  formData.forEach(function(fieldValues, fieldName) {\n    var i \x3d 0;\n    for (; i \x3c fieldValues.length; i++) {\n      var fieldValue \x3d fieldValues[i];\n      var newInput \x3d newDocument.createElement(\x22input\x22);\n      newInput.name \x3d fieldName;\n      newInput.value \x3d fieldValue;\n      newInput.type \x3d \x22hidden\x22;\n      HTMLFormElement.prototype.appendChild.call(newForm, newInput);\n    }\n  });\n  HTMLFormElement.prototype.submit.call(newForm);\n  return true;\n};\ngoog.dom.forms.getFormDataMap \x3d function(form) {\n  var map \x3d new goog.structs.Map();\n  goog.dom.forms.getFormDataHelper_(form, map, goog.dom.forms.addFormDataToMap_);\n  return map;\n};\ngoog.dom.forms.getFormDataString \x3d function(form) {\n  var sb \x3d [];\n  goog.dom.forms.getFormDataHelper_(form, sb, goog.dom.forms.addFormDataToStringBuffer_);\n  return sb.join(\x22\\x26\x22);\n};\ngoog.dom.forms.getFormDataHelper_ \x3d function(form, result, fnAppend) {\n  var els \x3d form.elements;\n  var el;\n  var i \x3d 0;\n  for (; el \x3d els.item(i); i++) {\n    if (el.form !\x3d form || el.disabled || el.tagName \x3d\x3d goog.dom.TagName.FIELDSET) {\n      continue;\n    }\n    var name \x3d el.name;\n    switch(el.type.toLowerCase()) {\n      case goog.dom.InputType.FILE:\n      case goog.dom.InputType.SUBMIT:\n      case goog.dom.InputType.RESET:\n      case goog.dom.InputType.BUTTON:\n        break;\n      case goog.dom.InputType.SELECT_MULTIPLE:\n        var values \x3d goog.dom.forms.getValue(el);\n        if (values !\x3d null) {\n          var value;\n          var j \x3d 0;\n          for (; value \x3d values[j]; j++) {\n            fnAppend(result, name, value);\n          }\n        }\n        break;\n      default:\n        value \x3d goog.dom.forms.getValue(el);\n        if (value !\x3d null) {\n          fnAppend(result, name, value);\n        }\n    }\n  }\n  var inputs \x3d form.getElementsByTagName(String(goog.dom.TagName.INPUT));\n  var input;\n  i \x3d 0;\n  for (; input \x3d inputs[i]; i++) {\n    if (input.form \x3d\x3d form \x26\x26 input.type.toLowerCase() \x3d\x3d goog.dom.InputType.IMAGE) {\n      name \x3d input.name;\n      fnAppend(result, name, input.value);\n      fnAppend(result, name + \x22.x\x22, \x220\x22);\n      fnAppend(result, name + \x22.y\x22, \x220\x22);\n    }\n  }\n};\ngoog.dom.forms.addFormDataToMap_ \x3d function(map, name, value) {\n  var array \x3d map.get(name);\n  if (!array) {\n    array \x3d [];\n    map.set(name, array);\n  }\n  array.push(value);\n};\ngoog.dom.forms.addFormDataToStringBuffer_ \x3d function(sb, name, value) {\n  sb.push(encodeURIComponent(name) + \x22\\x3d\x22 + encodeURIComponent(value));\n};\ngoog.dom.forms.hasFileInput \x3d function(form) {\n  var els \x3d form.elements;\n  var el;\n  var i \x3d 0;\n  for (; el \x3d els[i]; i++) {\n    if (!el.disabled \x26\x26 el.type \x26\x26 el.type.toLowerCase() \x3d\x3d goog.dom.InputType.FILE) {\n      return true;\n    }\n  }\n  return false;\n};\ngoog.dom.forms.setDisabled \x3d function(el, disabled) {\n  if (el.tagName \x3d\x3d goog.dom.TagName.FORM) {\n    var els \x3d el.elements;\n    var i \x3d 0;\n    for (; el \x3d els.item(i); i++) {\n      goog.dom.forms.setDisabled(el, disabled);\n    }\n  } else {\n    if (disabled \x3d\x3d true) {\n      el.blur();\n    }\n    el.disabled \x3d disabled;\n  }\n};\ngoog.dom.forms.focusAndSelect \x3d function(el) {\n  el.focus();\n  if (el.select) {\n    el.select();\n  }\n};\ngoog.dom.forms.hasValue \x3d function(el) {\n  var value \x3d goog.dom.forms.getValue(el);\n  return !!value;\n};\ngoog.dom.forms.hasValueByName \x3d function(form, name) {\n  var value \x3d goog.dom.forms.getValueByName(form, name);\n  return !!value;\n};\ngoog.dom.forms.getValue \x3d function(input) {\n  var type \x3d input.type;\n  if (typeof type \x3d\x3d\x3d \x22string\x22) {\n    var el \x3d input;\n    switch(type.toLowerCase()) {\n      case goog.dom.InputType.CHECKBOX:\n      case goog.dom.InputType.RADIO:\n        return goog.dom.forms.getInputChecked_(el);\n      case goog.dom.InputType.SELECT_ONE:\n        return goog.dom.forms.getSelectSingle_(el);\n      case goog.dom.InputType.SELECT_MULTIPLE:\n        return goog.dom.forms.getSelectMultiple_(el);\n      default:\n    }\n  }\n  return input.value !\x3d null ? input.value : null;\n};\ngoog.dom.forms.getValueByName \x3d function(form, name) {\n  var els \x3d form.elements[name];\n  if (!els) {\n    return null;\n  } else if (els.type) {\n    return goog.dom.forms.getValue(els);\n  } else {\n    var i \x3d 0;\n    for (; i \x3c els.length; i++) {\n      var val \x3d goog.dom.forms.getValue(els[i]);\n      if (val) {\n        return val;\n      }\n    }\n    return null;\n  }\n};\ngoog.dom.forms.getInputChecked_ \x3d function(el) {\n  return el.checked ? el.value : null;\n};\ngoog.dom.forms.getSelectSingle_ \x3d function(el) {\n  var selectedIndex \x3d el.selectedIndex;\n  return selectedIndex \x3e\x3d 0 ? el.options[selectedIndex].value : null;\n};\ngoog.dom.forms.getSelectMultiple_ \x3d function(el) {\n  var values \x3d [];\n  var option;\n  var i \x3d 0;\n  for (; option \x3d el.options[i]; i++) {\n    if (option.selected) {\n      values.push(option.value);\n    }\n  }\n  return values.length ? values : null;\n};\ngoog.dom.forms.setValue \x3d function(el, opt_value) {\n  var type \x3d el.type;\n  switch(typeof type \x3d\x3d\x3d \x22string\x22 \x26\x26 type.toLowerCase()) {\n    case goog.dom.InputType.CHECKBOX:\n    case goog.dom.InputType.RADIO:\n      goog.dom.forms.setInputChecked_(el, opt_value);\n      return;\n    case goog.dom.InputType.SELECT_ONE:\n      goog.dom.forms.setSelectSingle_(el, opt_value);\n      return;\n    case goog.dom.InputType.SELECT_MULTIPLE:\n      goog.dom.forms.setSelectMultiple_(el, opt_value);\n      return;\n    default:\n      el.value \x3d opt_value !\x3d null ? opt_value : \x22\x22;\n  }\n};\ngoog.dom.forms.setInputChecked_ \x3d function(el, opt_value) {\n  el.checked \x3d opt_value;\n};\ngoog.dom.forms.setSelectSingle_ \x3d function(el, opt_value) {\n  el.selectedIndex \x3d -1;\n  if (typeof opt_value \x3d\x3d\x3d \x22string\x22) {\n    var option;\n    var i \x3d 0;\n    for (; option \x3d el.options[i]; i++) {\n      if (option.value \x3d\x3d opt_value) {\n        option.selected \x3d true;\n        break;\n      }\n    }\n  }\n};\ngoog.dom.forms.setSelectMultiple_ \x3d function(el, opt_value) {\n  if (typeof opt_value \x3d\x3d\x3d \x22string\x22) {\n    opt_value \x3d [opt_value];\n  }\n  var option;\n  var i \x3d 0;\n  for (; option \x3d el.options[i]; i++) {\n    option.selected \x3d false;\n    if (opt_value) {\n      var value;\n      var j \x3d 0;\n      for (; value \x3d opt_value[j]; j++) {\n        if (option.value \x3d\x3d value) {\n          option.selected \x3d true;\n        }\n      }\n    }\n  }\n};\n");
SHADOW_ENV.evalLoad("goog.dom.classlist.js", true, "goog.provide(\x22goog.dom.classlist\x22);\ngoog.require(\x22goog.array\x22);\ngoog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST \x3d goog.define(\x22goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST\x22, false);\ngoog.dom.classlist.getClassName_ \x3d function(element) {\n  return typeof element.className \x3d\x3d \x22string\x22 ? element.className : element.getAttribute \x26\x26 element.getAttribute(\x22class\x22) || \x22\x22;\n};\ngoog.dom.classlist.get \x3d function(element) {\n  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {\n    return element.classList;\n  }\n  return goog.dom.classlist.getClassName_(element).match(/\\S+/g) || [];\n};\ngoog.dom.classlist.set \x3d function(element, className) {\n  if (typeof element.className \x3d\x3d \x22string\x22) {\n    element.className \x3d className;\n    return;\n  } else if (element.setAttribute) {\n    element.setAttribute(\x22class\x22, className);\n  }\n};\ngoog.dom.classlist.contains \x3d function(element, className) {\n  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {\n    return element.classList.contains(className);\n  }\n  return goog.array.contains(goog.dom.classlist.get(element), className);\n};\ngoog.dom.classlist.add \x3d function(element, className) {\n  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {\n    element.classList.add(className);\n    return;\n  }\n  if (!goog.dom.classlist.contains(element, className)) {\n    var oldClassName \x3d goog.dom.classlist.getClassName_(element);\n    goog.dom.classlist.set(element, oldClassName + (oldClassName.length \x3e 0 ? \x22 \x22 + className : className));\n  }\n};\ngoog.dom.classlist.addAll \x3d function(element, classesToAdd) {\n  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {\n    Array.prototype.forEach.call(classesToAdd, function(className) {\n      goog.dom.classlist.add(element, className);\n    });\n    return;\n  }\n  var classMap \x3d {};\n  Array.prototype.forEach.call(goog.dom.classlist.get(element), function(className) {\n    classMap[className] \x3d true;\n  });\n  Array.prototype.forEach.call(classesToAdd, function(className) {\n    classMap[className] \x3d true;\n  });\n  var newClassName \x3d \x22\x22;\n  var className;\n  for (className in classMap) {\n    newClassName \x3d newClassName + (newClassName.length \x3e 0 ? \x22 \x22 + className : className);\n  }\n  goog.dom.classlist.set(element, newClassName);\n};\ngoog.dom.classlist.remove \x3d function(element, className) {\n  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {\n    element.classList.remove(className);\n    return;\n  }\n  if (goog.dom.classlist.contains(element, className)) {\n    goog.dom.classlist.set(element, Array.prototype.filter.call(goog.dom.classlist.get(element), function(c) {\n      return c !\x3d className;\n    }).join(\x22 \x22));\n  }\n};\ngoog.dom.classlist.removeAll \x3d function(element, classesToRemove) {\n  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {\n    Array.prototype.forEach.call(classesToRemove, function(className) {\n      goog.dom.classlist.remove(element, className);\n    });\n    return;\n  }\n  goog.dom.classlist.set(element, Array.prototype.filter.call(goog.dom.classlist.get(element), function(className) {\n    return !goog.array.contains(classesToRemove, className);\n  }).join(\x22 \x22));\n};\ngoog.dom.classlist.enable \x3d function(element, className, enabled) {\n  if (enabled) {\n    goog.dom.classlist.add(element, className);\n  } else {\n    goog.dom.classlist.remove(element, className);\n  }\n};\ngoog.dom.classlist.enableAll \x3d function(element, classesToEnable, enabled) {\n  var f \x3d enabled ? goog.dom.classlist.addAll : goog.dom.classlist.removeAll;\n  f(element, classesToEnable);\n};\ngoog.dom.classlist.swap \x3d function(element, fromClass, toClass) {\n  if (goog.dom.classlist.contains(element, fromClass)) {\n    goog.dom.classlist.remove(element, fromClass);\n    goog.dom.classlist.add(element, toClass);\n    return true;\n  }\n  return false;\n};\ngoog.dom.classlist.toggle \x3d function(element, className) {\n  var add \x3d !goog.dom.classlist.contains(element, className);\n  goog.dom.classlist.enable(element, className, add);\n  return add;\n};\ngoog.dom.classlist.addRemove \x3d function(element, classToRemove, classToAdd) {\n  goog.dom.classlist.remove(element, classToRemove);\n  goog.dom.classlist.add(element, classToAdd);\n};\n");
SHADOW_ENV.evalLoad("goog.dom.vendor.js", true, "goog.provide(\x22goog.dom.vendor\x22);\ngoog.require(\x22goog.string\x22);\ngoog.require(\x22goog.userAgent\x22);\ngoog.dom.vendor.getVendorJsPrefix \x3d function() {\n  if (goog.userAgent.WEBKIT) {\n    return \x22Webkit\x22;\n  } else if (goog.userAgent.GECKO) {\n    return \x22Moz\x22;\n  } else if (goog.userAgent.IE) {\n    return \x22ms\x22;\n  }\n  return null;\n};\ngoog.dom.vendor.getVendorPrefix \x3d function() {\n  if (goog.userAgent.WEBKIT) {\n    return \x22-webkit\x22;\n  } else if (goog.userAgent.GECKO) {\n    return \x22-moz\x22;\n  } else if (goog.userAgent.IE) {\n    return \x22-ms\x22;\n  }\n  return null;\n};\ngoog.dom.vendor.getPrefixedPropertyName \x3d function(propertyName, opt_object) {\n  if (opt_object \x26\x26 propertyName in opt_object) {\n    return propertyName;\n  }\n  var prefix \x3d goog.dom.vendor.getVendorJsPrefix();\n  if (prefix) {\n    prefix \x3d prefix.toLowerCase();\n    var prefixedPropertyName \x3d prefix + goog.string.toTitleCase(propertyName);\n    return opt_object \x3d\x3d\x3d undefined || prefixedPropertyName in opt_object ? prefixedPropertyName : null;\n  }\n  return null;\n};\ngoog.dom.vendor.getPrefixedEventType \x3d function(eventType) {\n  var prefix \x3d goog.dom.vendor.getVendorJsPrefix() || \x22\x22;\n  return (prefix + eventType).toLowerCase();\n};\n");
SHADOW_ENV.evalLoad("goog.math.box.js", true, "goog.provide(\x22goog.math.Box\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.math.Coordinate\x22);\ngoog.math.Box \x3d function(top, right, bottom, left) {\n  this.top \x3d top;\n  this.right \x3d right;\n  this.bottom \x3d bottom;\n  this.left \x3d left;\n};\ngoog.math.Box.boundingBox \x3d function(var_args) {\n  var box \x3d new goog.math.Box(arguments[0].y, arguments[0].x, arguments[0].y, arguments[0].x);\n  var i \x3d 1;\n  for (; i \x3c arguments.length; i++) {\n    box.expandToIncludeCoordinate(arguments[i]);\n  }\n  return box;\n};\ngoog.math.Box.prototype.getWidth \x3d function() {\n  return this.right - this.left;\n};\ngoog.math.Box.prototype.getHeight \x3d function() {\n  return this.bottom - this.top;\n};\ngoog.math.Box.prototype.clone \x3d function() {\n  return new goog.math.Box(this.top, this.right, this.bottom, this.left);\n};\nif (goog.DEBUG) {\n  goog.math.Box.prototype.toString \x3d function() {\n    return \x22(\x22 + this.top + \x22t, \x22 + this.right + \x22r, \x22 + this.bottom + \x22b, \x22 + this.left + \x22l)\x22;\n  };\n}\ngoog.math.Box.prototype.contains \x3d function(other) {\n  return goog.math.Box.contains(this, other);\n};\ngoog.math.Box.prototype.expand \x3d function(top, opt_right, opt_bottom, opt_left) {\n  if (goog.isObject(top)) {\n    this.top -\x3d top.top;\n    this.right +\x3d top.right;\n    this.bottom +\x3d top.bottom;\n    this.left -\x3d top.left;\n  } else {\n    this.top -\x3d top;\n    this.right +\x3d Number(opt_right);\n    this.bottom +\x3d Number(opt_bottom);\n    this.left -\x3d Number(opt_left);\n  }\n  return this;\n};\ngoog.math.Box.prototype.expandToInclude \x3d function(box) {\n  this.left \x3d Math.min(this.left, box.left);\n  this.top \x3d Math.min(this.top, box.top);\n  this.right \x3d Math.max(this.right, box.right);\n  this.bottom \x3d Math.max(this.bottom, box.bottom);\n};\ngoog.math.Box.prototype.expandToIncludeCoordinate \x3d function(coord) {\n  this.top \x3d Math.min(this.top, coord.y);\n  this.right \x3d Math.max(this.right, coord.x);\n  this.bottom \x3d Math.max(this.bottom, coord.y);\n  this.left \x3d Math.min(this.left, coord.x);\n};\ngoog.math.Box.equals \x3d function(a, b) {\n  if (a \x3d\x3d b) {\n    return true;\n  }\n  if (!a || !b) {\n    return false;\n  }\n  return a.top \x3d\x3d b.top \x26\x26 a.right \x3d\x3d b.right \x26\x26 a.bottom \x3d\x3d b.bottom \x26\x26 a.left \x3d\x3d b.left;\n};\ngoog.math.Box.contains \x3d function(box, other) {\n  if (!box || !other) {\n    return false;\n  }\n  if (other instanceof goog.math.Box) {\n    return other.left \x3e\x3d box.left \x26\x26 other.right \x3c\x3d box.right \x26\x26 other.top \x3e\x3d box.top \x26\x26 other.bottom \x3c\x3d box.bottom;\n  }\n  return other.x \x3e\x3d box.left \x26\x26 other.x \x3c\x3d box.right \x26\x26 other.y \x3e\x3d box.top \x26\x26 other.y \x3c\x3d box.bottom;\n};\ngoog.math.Box.relativePositionX \x3d function(box, coord) {\n  if (coord.x \x3c box.left) {\n    return coord.x - box.left;\n  } else if (coord.x \x3e box.right) {\n    return coord.x - box.right;\n  }\n  return 0;\n};\ngoog.math.Box.relativePositionY \x3d function(box, coord) {\n  if (coord.y \x3c box.top) {\n    return coord.y - box.top;\n  } else if (coord.y \x3e box.bottom) {\n    return coord.y - box.bottom;\n  }\n  return 0;\n};\ngoog.math.Box.distance \x3d function(box, coord) {\n  var x \x3d goog.math.Box.relativePositionX(box, coord);\n  var y \x3d goog.math.Box.relativePositionY(box, coord);\n  return Math.sqrt(x * x + y * y);\n};\ngoog.math.Box.intersects \x3d function(a, b) {\n  return a.left \x3c\x3d b.right \x26\x26 b.left \x3c\x3d a.right \x26\x26 a.top \x3c\x3d b.bottom \x26\x26 b.top \x3c\x3d a.bottom;\n};\ngoog.math.Box.intersectsWithPadding \x3d function(a, b, padding) {\n  return a.left \x3c\x3d b.right + padding \x26\x26 b.left \x3c\x3d a.right + padding \x26\x26 a.top \x3c\x3d b.bottom + padding \x26\x26 b.top \x3c\x3d a.bottom + padding;\n};\ngoog.math.Box.prototype.ceil \x3d function() {\n  this.top \x3d Math.ceil(this.top);\n  this.right \x3d Math.ceil(this.right);\n  this.bottom \x3d Math.ceil(this.bottom);\n  this.left \x3d Math.ceil(this.left);\n  return this;\n};\ngoog.math.Box.prototype.floor \x3d function() {\n  this.top \x3d Math.floor(this.top);\n  this.right \x3d Math.floor(this.right);\n  this.bottom \x3d Math.floor(this.bottom);\n  this.left \x3d Math.floor(this.left);\n  return this;\n};\ngoog.math.Box.prototype.round \x3d function() {\n  this.top \x3d Math.round(this.top);\n  this.right \x3d Math.round(this.right);\n  this.bottom \x3d Math.round(this.bottom);\n  this.left \x3d Math.round(this.left);\n  return this;\n};\ngoog.math.Box.prototype.translate \x3d function(tx, opt_ty) {\n  if (tx instanceof goog.math.Coordinate) {\n    this.left +\x3d tx.x;\n    this.right +\x3d tx.x;\n    this.top +\x3d tx.y;\n    this.bottom +\x3d tx.y;\n  } else {\n    goog.asserts.assertNumber(tx);\n    this.left +\x3d tx;\n    this.right +\x3d tx;\n    if (typeof opt_ty \x3d\x3d\x3d \x22number\x22) {\n      this.top +\x3d opt_ty;\n      this.bottom +\x3d opt_ty;\n    }\n  }\n  return this;\n};\ngoog.math.Box.prototype.scale \x3d function(sx, opt_sy) {\n  var sy \x3d typeof opt_sy \x3d\x3d\x3d \x22number\x22 ? opt_sy : sx;\n  this.left *\x3d sx;\n  this.right *\x3d sx;\n  this.top *\x3d sy;\n  this.bottom *\x3d sy;\n  return this;\n};\n");
SHADOW_ENV.evalLoad("goog.math.irect.js", true, "goog.provide(\x22goog.math.IRect\x22);\ngoog.math.IRect \x3d function() {\n};\ngoog.math.IRect.prototype.left;\ngoog.math.IRect.prototype.top;\ngoog.math.IRect.prototype.width;\ngoog.math.IRect.prototype.height;\n");
SHADOW_ENV.evalLoad("goog.math.rect.js", true, "goog.provide(\x22goog.math.Rect\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.math.Box\x22);\ngoog.require(\x22goog.math.Coordinate\x22);\ngoog.require(\x22goog.math.IRect\x22);\ngoog.require(\x22goog.math.Size\x22);\ngoog.math.Rect \x3d function(x, y, w, h) {\n  this.left \x3d x;\n  this.top \x3d y;\n  this.width \x3d w;\n  this.height \x3d h;\n};\ngoog.math.Rect.prototype.clone \x3d function() {\n  return new goog.math.Rect(this.left, this.top, this.width, this.height);\n};\ngoog.math.Rect.prototype.toBox \x3d function() {\n  var right \x3d this.left + this.width;\n  var bottom \x3d this.top + this.height;\n  return new goog.math.Box(this.top, right, bottom, this.left);\n};\ngoog.math.Rect.createFromPositionAndSize \x3d function(position, size) {\n  return new goog.math.Rect(position.x, position.y, size.width, size.height);\n};\ngoog.math.Rect.createFromBox \x3d function(box) {\n  return new goog.math.Rect(box.left, box.top, box.right - box.left, box.bottom - box.top);\n};\nif (goog.DEBUG) {\n  goog.math.Rect.prototype.toString \x3d function() {\n    return \x22(\x22 + this.left + \x22, \x22 + this.top + \x22 - \x22 + this.width + \x22w x \x22 + this.height + \x22h)\x22;\n  };\n}\ngoog.math.Rect.equals \x3d function(a, b) {\n  if (a \x3d\x3d b) {\n    return true;\n  }\n  if (!a || !b) {\n    return false;\n  }\n  return a.left \x3d\x3d b.left \x26\x26 a.width \x3d\x3d b.width \x26\x26 a.top \x3d\x3d b.top \x26\x26 a.height \x3d\x3d b.height;\n};\ngoog.math.Rect.prototype.intersection \x3d function(rect) {\n  var x0 \x3d Math.max(this.left, rect.left);\n  var x1 \x3d Math.min(this.left + this.width, rect.left + rect.width);\n  if (x0 \x3c\x3d x1) {\n    var y0 \x3d Math.max(this.top, rect.top);\n    var y1 \x3d Math.min(this.top + this.height, rect.top + rect.height);\n    if (y0 \x3c\x3d y1) {\n      this.left \x3d x0;\n      this.top \x3d y0;\n      this.width \x3d x1 - x0;\n      this.height \x3d y1 - y0;\n      return true;\n    }\n  }\n  return false;\n};\ngoog.math.Rect.intersection \x3d function(a, b) {\n  var x0 \x3d Math.max(a.left, b.left);\n  var x1 \x3d Math.min(a.left + a.width, b.left + b.width);\n  if (x0 \x3c\x3d x1) {\n    var y0 \x3d Math.max(a.top, b.top);\n    var y1 \x3d Math.min(a.top + a.height, b.top + b.height);\n    if (y0 \x3c\x3d y1) {\n      return new goog.math.Rect(x0, y0, x1 - x0, y1 - y0);\n    }\n  }\n  return null;\n};\ngoog.math.Rect.intersects \x3d function(a, b) {\n  return a.left \x3c\x3d b.left + b.width \x26\x26 b.left \x3c\x3d a.left + a.width \x26\x26 a.top \x3c\x3d b.top + b.height \x26\x26 b.top \x3c\x3d a.top + a.height;\n};\ngoog.math.Rect.prototype.intersects \x3d function(rect) {\n  return goog.math.Rect.intersects(this, rect);\n};\ngoog.math.Rect.difference \x3d function(a, b) {\n  var intersection \x3d goog.math.Rect.intersection(a, b);\n  if (!intersection || !intersection.height || !intersection.width) {\n    return [a.clone()];\n  }\n  var result \x3d [];\n  var top \x3d a.top;\n  var height \x3d a.height;\n  var ar \x3d a.left + a.width;\n  var ab \x3d a.top + a.height;\n  var br \x3d b.left + b.width;\n  var bb \x3d b.top + b.height;\n  if (b.top \x3e a.top) {\n    result.push(new goog.math.Rect(a.left, a.top, a.width, b.top - a.top));\n    top \x3d b.top;\n    height \x3d height - (b.top - a.top);\n  }\n  if (bb \x3c ab) {\n    result.push(new goog.math.Rect(a.left, bb, a.width, ab - bb));\n    height \x3d bb - top;\n  }\n  if (b.left \x3e a.left) {\n    result.push(new goog.math.Rect(a.left, top, b.left - a.left, height));\n  }\n  if (br \x3c ar) {\n    result.push(new goog.math.Rect(br, top, ar - br, height));\n  }\n  return result;\n};\ngoog.math.Rect.prototype.difference \x3d function(rect) {\n  return goog.math.Rect.difference(this, rect);\n};\ngoog.math.Rect.prototype.boundingRect \x3d function(rect) {\n  var right \x3d Math.max(this.left + this.width, rect.left + rect.width);\n  var bottom \x3d Math.max(this.top + this.height, rect.top + rect.height);\n  this.left \x3d Math.min(this.left, rect.left);\n  this.top \x3d Math.min(this.top, rect.top);\n  this.width \x3d right - this.left;\n  this.height \x3d bottom - this.top;\n};\ngoog.math.Rect.boundingRect \x3d function(a, b) {\n  if (!a || !b) {\n    return null;\n  }\n  var newRect \x3d new goog.math.Rect(a.left, a.top, a.width, a.height);\n  newRect.boundingRect(b);\n  return newRect;\n};\ngoog.math.Rect.prototype.contains \x3d function(another) {\n  if (another instanceof goog.math.Coordinate) {\n    return another.x \x3e\x3d this.left \x26\x26 another.x \x3c\x3d this.left + this.width \x26\x26 another.y \x3e\x3d this.top \x26\x26 another.y \x3c\x3d this.top + this.height;\n  } else {\n    return this.left \x3c\x3d another.left \x26\x26 this.left + this.width \x3e\x3d another.left + another.width \x26\x26 this.top \x3c\x3d another.top \x26\x26 this.top + this.height \x3e\x3d another.top + another.height;\n  }\n};\ngoog.math.Rect.prototype.squaredDistance \x3d function(point) {\n  var dx \x3d point.x \x3c this.left ? this.left - point.x : Math.max(point.x - (this.left + this.width), 0);\n  var dy \x3d point.y \x3c this.top ? this.top - point.y : Math.max(point.y - (this.top + this.height), 0);\n  return dx * dx + dy * dy;\n};\ngoog.math.Rect.prototype.distance \x3d function(point) {\n  return Math.sqrt(this.squaredDistance(point));\n};\ngoog.math.Rect.prototype.getSize \x3d function() {\n  return new goog.math.Size(this.width, this.height);\n};\ngoog.math.Rect.prototype.getTopLeft \x3d function() {\n  return new goog.math.Coordinate(this.left, this.top);\n};\ngoog.math.Rect.prototype.getCenter \x3d function() {\n  return new goog.math.Coordinate(this.left + this.width / 2, this.top + this.height / 2);\n};\ngoog.math.Rect.prototype.getBottomRight \x3d function() {\n  return new goog.math.Coordinate(this.left + this.width, this.top + this.height);\n};\ngoog.math.Rect.prototype.ceil \x3d function() {\n  this.left \x3d Math.ceil(this.left);\n  this.top \x3d Math.ceil(this.top);\n  this.width \x3d Math.ceil(this.width);\n  this.height \x3d Math.ceil(this.height);\n  return this;\n};\ngoog.math.Rect.prototype.floor \x3d function() {\n  this.left \x3d Math.floor(this.left);\n  this.top \x3d Math.floor(this.top);\n  this.width \x3d Math.floor(this.width);\n  this.height \x3d Math.floor(this.height);\n  return this;\n};\ngoog.math.Rect.prototype.round \x3d function() {\n  this.left \x3d Math.round(this.left);\n  this.top \x3d Math.round(this.top);\n  this.width \x3d Math.round(this.width);\n  this.height \x3d Math.round(this.height);\n  return this;\n};\ngoog.math.Rect.prototype.translate \x3d function(tx, opt_ty) {\n  if (tx instanceof goog.math.Coordinate) {\n    this.left +\x3d tx.x;\n    this.top +\x3d tx.y;\n  } else {\n    this.left +\x3d goog.asserts.assertNumber(tx);\n    if (typeof opt_ty \x3d\x3d\x3d \x22number\x22) {\n      this.top +\x3d opt_ty;\n    }\n  }\n  return this;\n};\ngoog.math.Rect.prototype.scale \x3d function(sx, opt_sy) {\n  var sy \x3d typeof opt_sy \x3d\x3d\x3d \x22number\x22 ? opt_sy : sx;\n  this.left *\x3d sx;\n  this.width *\x3d sx;\n  this.top *\x3d sy;\n  this.height *\x3d sy;\n  return this;\n};\n");
SHADOW_ENV.evalLoad("goog.style.style.js", true, "goog.provide(\x22goog.style\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.require(\x22goog.dom\x22);\ngoog.require(\x22goog.dom.NodeType\x22);\ngoog.require(\x22goog.dom.TagName\x22);\ngoog.require(\x22goog.dom.safe\x22);\ngoog.require(\x22goog.dom.vendor\x22);\ngoog.require(\x22goog.html.SafeStyleSheet\x22);\ngoog.require(\x22goog.math.Box\x22);\ngoog.require(\x22goog.math.Coordinate\x22);\ngoog.require(\x22goog.math.Rect\x22);\ngoog.require(\x22goog.math.Size\x22);\ngoog.require(\x22goog.object\x22);\ngoog.require(\x22goog.reflect\x22);\ngoog.require(\x22goog.string\x22);\ngoog.require(\x22goog.userAgent\x22);\ngoog.requireType(\x22goog.events.Event\x22);\ngoog.style.setStyle \x3d function(element, style, opt_value) {\n  if (typeof style \x3d\x3d\x3d \x22string\x22) {\n    goog.style.setStyle_(element, opt_value, style);\n  } else {\n    var key;\n    for (key in style) {\n      goog.style.setStyle_(element, style[key], key);\n    }\n  }\n};\ngoog.style.setStyle_ \x3d function(element, value, style) {\n  var propertyName \x3d goog.style.getVendorJsStyleName_(element, style);\n  if (propertyName) {\n    element.style[propertyName] \x3d value;\n  }\n};\ngoog.style.styleNameCache_ \x3d {};\ngoog.style.getVendorJsStyleName_ \x3d function(element, style) {\n  var propertyName \x3d goog.style.styleNameCache_[style];\n  if (!propertyName) {\n    var camelStyle \x3d goog.string.toCamelCase(style);\n    propertyName \x3d camelStyle;\n    if (element.style[camelStyle] \x3d\x3d\x3d undefined) {\n      var prefixedStyle \x3d goog.dom.vendor.getVendorJsPrefix() + goog.string.toTitleCase(camelStyle);\n      if (element.style[prefixedStyle] !\x3d\x3d undefined) {\n        propertyName \x3d prefixedStyle;\n      }\n    }\n    goog.style.styleNameCache_[style] \x3d propertyName;\n  }\n  return propertyName;\n};\ngoog.style.getVendorStyleName_ \x3d function(element, style) {\n  var camelStyle \x3d goog.string.toCamelCase(style);\n  if (element.style[camelStyle] \x3d\x3d\x3d undefined) {\n    var prefixedStyle \x3d goog.dom.vendor.getVendorJsPrefix() + goog.string.toTitleCase(camelStyle);\n    if (element.style[prefixedStyle] !\x3d\x3d undefined) {\n      return goog.dom.vendor.getVendorPrefix() + \x22-\x22 + style;\n    }\n  }\n  return style;\n};\ngoog.style.getStyle \x3d function(element, property) {\n  var styleValue \x3d element.style[goog.string.toCamelCase(property)];\n  if (typeof styleValue !\x3d\x3d \x22undefined\x22) {\n    return styleValue;\n  }\n  return element.style[goog.style.getVendorJsStyleName_(element, property)] || \x22\x22;\n};\ngoog.style.getComputedStyle \x3d function(element, property) {\n  var doc \x3d goog.dom.getOwnerDocument(element);\n  if (doc.defaultView \x26\x26 doc.defaultView.getComputedStyle) {\n    var styles \x3d doc.defaultView.getComputedStyle(element, null);\n    if (styles) {\n      return styles[property] || styles.getPropertyValue(property) || \x22\x22;\n    }\n  }\n  return \x22\x22;\n};\ngoog.style.getCascadedStyle \x3d function(element, style) {\n  return element.currentStyle ? element.currentStyle[style] : null;\n};\ngoog.style.getStyle_ \x3d function(element, style) {\n  return goog.style.getComputedStyle(element, style) || goog.style.getCascadedStyle(element, style) || element.style \x26\x26 element.style[style];\n};\ngoog.style.getComputedBoxSizing \x3d function(element) {\n  return goog.style.getStyle_(element, \x22boxSizing\x22) || goog.style.getStyle_(element, \x22MozBoxSizing\x22) || goog.style.getStyle_(element, \x22WebkitBoxSizing\x22) || null;\n};\ngoog.style.getComputedPosition \x3d function(element) {\n  return goog.style.getStyle_(element, \x22position\x22);\n};\ngoog.style.getBackgroundColor \x3d function(element) {\n  return goog.style.getStyle_(element, \x22backgroundColor\x22);\n};\ngoog.style.getComputedOverflowX \x3d function(element) {\n  return goog.style.getStyle_(element, \x22overflowX\x22);\n};\ngoog.style.getComputedOverflowY \x3d function(element) {\n  return goog.style.getStyle_(element, \x22overflowY\x22);\n};\ngoog.style.getComputedZIndex \x3d function(element) {\n  return goog.style.getStyle_(element, \x22zIndex\x22);\n};\ngoog.style.getComputedTextAlign \x3d function(element) {\n  return goog.style.getStyle_(element, \x22textAlign\x22);\n};\ngoog.style.getComputedCursor \x3d function(element) {\n  return goog.style.getStyle_(element, \x22cursor\x22);\n};\ngoog.style.getComputedTransform \x3d function(element) {\n  var property \x3d goog.style.getVendorStyleName_(element, \x22transform\x22);\n  return goog.style.getStyle_(element, property) || goog.style.getStyle_(element, \x22transform\x22);\n};\ngoog.style.setPosition \x3d function(el, arg1, opt_arg2) {\n  var x;\n  var y;\n  if (arg1 instanceof goog.math.Coordinate) {\n    x \x3d arg1.x;\n    y \x3d arg1.y;\n  } else {\n    x \x3d arg1;\n    y \x3d opt_arg2;\n  }\n  el.style.left \x3d goog.style.getPixelStyleValue_(x, false);\n  el.style.top \x3d goog.style.getPixelStyleValue_(y, false);\n};\ngoog.style.getPosition \x3d function(element) {\n  return new goog.math.Coordinate(element.offsetLeft, element.offsetTop);\n};\ngoog.style.getClientViewportElement \x3d function(opt_node) {\n  var doc;\n  if (opt_node) {\n    doc \x3d goog.dom.getOwnerDocument(opt_node);\n  } else {\n    doc \x3d goog.dom.getDocument();\n  }\n  if (goog.userAgent.IE \x26\x26 !goog.userAgent.isDocumentModeOrHigher(9) \x26\x26 !goog.dom.getDomHelper(doc).isCss1CompatMode()) {\n    return doc.body;\n  }\n  return doc.documentElement;\n};\ngoog.style.getViewportPageOffset \x3d function(doc) {\n  var body \x3d doc.body;\n  var documentElement \x3d doc.documentElement;\n  var scrollLeft \x3d body.scrollLeft || documentElement.scrollLeft;\n  var scrollTop \x3d body.scrollTop || documentElement.scrollTop;\n  return new goog.math.Coordinate(scrollLeft, scrollTop);\n};\ngoog.style.getBoundingClientRect_ \x3d function(el) {\n  try {\n    return el.getBoundingClientRect();\n  } catch (e) {\n    return {\x22left\x22:0, \x22top\x22:0, \x22right\x22:0, \x22bottom\x22:0};\n  }\n};\ngoog.style.getOffsetParent \x3d function(element) {\n  if (goog.userAgent.IE \x26\x26 !goog.userAgent.isDocumentModeOrHigher(8)) {\n    goog.asserts.assert(element \x26\x26 \x22offsetParent\x22 in element);\n    return element.offsetParent;\n  }\n  var doc \x3d goog.dom.getOwnerDocument(element);\n  var positionStyle \x3d goog.style.getStyle_(element, \x22position\x22);\n  var skipStatic \x3d positionStyle \x3d\x3d \x22fixed\x22 || positionStyle \x3d\x3d \x22absolute\x22;\n  var parent \x3d element.parentNode;\n  for (; parent \x26\x26 parent !\x3d doc; parent \x3d parent.parentNode) {\n    if (parent.nodeType \x3d\x3d goog.dom.NodeType.DOCUMENT_FRAGMENT \x26\x26 parent.host) {\n      parent \x3d parent.host;\n    }\n    positionStyle \x3d goog.style.getStyle_(parent, \x22position\x22);\n    skipStatic \x3d skipStatic \x26\x26 positionStyle \x3d\x3d \x22static\x22 \x26\x26 parent !\x3d doc.documentElement \x26\x26 parent !\x3d doc.body;\n    if (!skipStatic \x26\x26 (parent.scrollWidth \x3e parent.clientWidth || parent.scrollHeight \x3e parent.clientHeight || positionStyle \x3d\x3d \x22fixed\x22 || positionStyle \x3d\x3d \x22absolute\x22 || positionStyle \x3d\x3d \x22relative\x22)) {\n      return parent;\n    }\n  }\n  return null;\n};\ngoog.style.getVisibleRectForElement \x3d function(element) {\n  var visibleRect \x3d new goog.math.Box(0, Infinity, Infinity, 0);\n  var dom \x3d goog.dom.getDomHelper(element);\n  var body \x3d dom.getDocument().body;\n  var documentElement \x3d dom.getDocument().documentElement;\n  var scrollEl \x3d dom.getDocumentScrollElement();\n  var el \x3d element;\n  for (; el \x3d goog.style.getOffsetParent(el);) {\n    if ((!goog.userAgent.IE || el.clientWidth !\x3d 0) \x26\x26 (!goog.userAgent.WEBKIT || el.clientHeight !\x3d 0 || el !\x3d body) \x26\x26 (el !\x3d body \x26\x26 el !\x3d documentElement \x26\x26 goog.style.getStyle_(el, \x22overflow\x22) !\x3d \x22visible\x22)) {\n      var pos \x3d goog.style.getPageOffset(el);\n      var client \x3d goog.style.getClientLeftTop(el);\n      pos.x +\x3d client.x;\n      pos.y +\x3d client.y;\n      visibleRect.top \x3d Math.max(visibleRect.top, pos.y);\n      visibleRect.right \x3d Math.min(visibleRect.right, pos.x + el.clientWidth);\n      visibleRect.bottom \x3d Math.min(visibleRect.bottom, pos.y + el.clientHeight);\n      visibleRect.left \x3d Math.max(visibleRect.left, pos.x);\n    }\n  }\n  var scrollX \x3d scrollEl.scrollLeft;\n  var scrollY \x3d scrollEl.scrollTop;\n  visibleRect.left \x3d Math.max(visibleRect.left, scrollX);\n  visibleRect.top \x3d Math.max(visibleRect.top, scrollY);\n  var winSize \x3d dom.getViewportSize();\n  visibleRect.right \x3d Math.min(visibleRect.right, scrollX + winSize.width);\n  visibleRect.bottom \x3d Math.min(visibleRect.bottom, scrollY + winSize.height);\n  return visibleRect.top \x3e\x3d 0 \x26\x26 visibleRect.left \x3e\x3d 0 \x26\x26 visibleRect.bottom \x3e visibleRect.top \x26\x26 visibleRect.right \x3e visibleRect.left ? visibleRect : null;\n};\ngoog.style.getContainerOffsetToScrollInto \x3d function(element, opt_container, opt_center) {\n  var container \x3d opt_container || goog.dom.getDocumentScrollElement();\n  var elementPos \x3d goog.style.getPageOffset(element);\n  var containerPos \x3d goog.style.getPageOffset(container);\n  var containerBorder \x3d goog.style.getBorderBox(container);\n  if (container \x3d\x3d goog.dom.getDocumentScrollElement()) {\n    var relX \x3d elementPos.x - container.scrollLeft;\n    var relY \x3d elementPos.y - container.scrollTop;\n    if (goog.userAgent.IE \x26\x26 !goog.userAgent.isDocumentModeOrHigher(10)) {\n      relX \x3d relX + containerBorder.left;\n      relY \x3d relY + containerBorder.top;\n    }\n  } else {\n    relX \x3d elementPos.x - containerPos.x - containerBorder.left;\n    relY \x3d elementPos.y - containerPos.y - containerBorder.top;\n  }\n  var elementSize \x3d goog.style.getSizeWithDisplay_(element);\n  var spaceX \x3d container.clientWidth - elementSize.width;\n  var spaceY \x3d container.clientHeight - elementSize.height;\n  var scrollLeft \x3d container.scrollLeft;\n  var scrollTop \x3d container.scrollTop;\n  if (opt_center) {\n    scrollLeft \x3d scrollLeft + (relX - spaceX / 2);\n    scrollTop \x3d scrollTop + (relY - spaceY / 2);\n  } else {\n    scrollLeft \x3d scrollLeft + Math.min(relX, Math.max(relX - spaceX, 0));\n    scrollTop \x3d scrollTop + Math.min(relY, Math.max(relY - spaceY, 0));\n  }\n  return new goog.math.Coordinate(scrollLeft, scrollTop);\n};\ngoog.style.scrollIntoContainerView \x3d function(element, opt_container, opt_center) {\n  var container \x3d opt_container || goog.dom.getDocumentScrollElement();\n  var offset \x3d goog.style.getContainerOffsetToScrollInto(element, container, opt_center);\n  container.scrollLeft \x3d offset.x;\n  container.scrollTop \x3d offset.y;\n};\ngoog.style.getClientLeftTop \x3d function(el) {\n  return new goog.math.Coordinate(el.clientLeft, el.clientTop);\n};\ngoog.style.getPageOffset \x3d function(el) {\n  var doc \x3d goog.dom.getOwnerDocument(el);\n  goog.asserts.assertObject(el, \x22Parameter is required\x22);\n  var pos \x3d new goog.math.Coordinate(0, 0);\n  var viewportElement \x3d goog.style.getClientViewportElement(doc);\n  if (el \x3d\x3d viewportElement) {\n    return pos;\n  }\n  var box \x3d goog.style.getBoundingClientRect_(el);\n  var scrollCoord \x3d goog.dom.getDomHelper(doc).getDocumentScroll();\n  pos.x \x3d box.left + scrollCoord.x;\n  pos.y \x3d box.top + scrollCoord.y;\n  return pos;\n};\ngoog.style.getPageOffsetLeft \x3d function(el) {\n  return goog.style.getPageOffset(el).x;\n};\ngoog.style.getPageOffsetTop \x3d function(el) {\n  return goog.style.getPageOffset(el).y;\n};\ngoog.style.getFramedPageOffset \x3d function(el, relativeWin) {\n  var position \x3d new goog.math.Coordinate(0, 0);\n  var currentWin \x3d goog.dom.getWindow(goog.dom.getOwnerDocument(el));\n  if (!goog.reflect.canAccessProperty(currentWin, \x22parent\x22)) {\n    return position;\n  }\n  var currentEl \x3d el;\n  do {\n    var offset \x3d currentWin \x3d\x3d relativeWin ? goog.style.getPageOffset(currentEl) : goog.style.getClientPositionForElement_(goog.asserts.assert(currentEl));\n    position.x +\x3d offset.x;\n    position.y +\x3d offset.y;\n  } while (currentWin \x26\x26 currentWin !\x3d relativeWin \x26\x26 currentWin !\x3d currentWin.parent \x26\x26 (currentEl \x3d currentWin.frameElement) \x26\x26 (currentWin \x3d currentWin.parent));\n  return position;\n};\ngoog.style.translateRectForAnotherFrame \x3d function(rect, origBase, newBase) {\n  if (origBase.getDocument() !\x3d newBase.getDocument()) {\n    var body \x3d origBase.getDocument().body;\n    var pos \x3d goog.style.getFramedPageOffset(body, newBase.getWindow());\n    pos \x3d goog.math.Coordinate.difference(pos, goog.style.getPageOffset(body));\n    if (goog.userAgent.IE \x26\x26 !goog.userAgent.isDocumentModeOrHigher(9) \x26\x26 !origBase.isCss1CompatMode()) {\n      pos \x3d goog.math.Coordinate.difference(pos, origBase.getDocumentScroll());\n    }\n    rect.left +\x3d pos.x;\n    rect.top +\x3d pos.y;\n  }\n};\ngoog.style.getRelativePosition \x3d function(a, b) {\n  var ap \x3d goog.style.getClientPosition(a);\n  var bp \x3d goog.style.getClientPosition(b);\n  return new goog.math.Coordinate(ap.x - bp.x, ap.y - bp.y);\n};\ngoog.style.getClientPositionForElement_ \x3d function(el) {\n  var box \x3d goog.style.getBoundingClientRect_(el);\n  return new goog.math.Coordinate(box.left, box.top);\n};\ngoog.style.getClientPosition \x3d function(el) {\n  goog.asserts.assert(el);\n  if (el.nodeType \x3d\x3d goog.dom.NodeType.ELEMENT) {\n    return goog.style.getClientPositionForElement_(el);\n  } else {\n    var targetEvent \x3d el.changedTouches ? el.changedTouches[0] : el;\n    return new goog.math.Coordinate(targetEvent.clientX, targetEvent.clientY);\n  }\n};\ngoog.style.setPageOffset \x3d function(el, x, opt_y) {\n  var cur \x3d goog.style.getPageOffset(el);\n  if (x instanceof goog.math.Coordinate) {\n    opt_y \x3d x.y;\n    x \x3d x.x;\n  }\n  var dx \x3d goog.asserts.assertNumber(x) - cur.x;\n  var dy \x3d Number(opt_y) - cur.y;\n  goog.style.setPosition(el, el.offsetLeft + dx, el.offsetTop + dy);\n};\ngoog.style.setSize \x3d function(element, w, opt_h) {\n  var h;\n  if (w instanceof goog.math.Size) {\n    h \x3d w.height;\n    w \x3d w.width;\n  } else {\n    if (opt_h \x3d\x3d undefined) {\n      throw new Error(\x22missing height argument\x22);\n    }\n    h \x3d opt_h;\n  }\n  goog.style.setWidth(element, w);\n  goog.style.setHeight(element, h);\n};\ngoog.style.getPixelStyleValue_ \x3d function(value, round) {\n  if (typeof value \x3d\x3d \x22number\x22) {\n    value \x3d (round ? Math.round(value) : value) + \x22px\x22;\n  }\n  return value;\n};\ngoog.style.setHeight \x3d function(element, height) {\n  element.style.height \x3d goog.style.getPixelStyleValue_(height, true);\n};\ngoog.style.setWidth \x3d function(element, width) {\n  element.style.width \x3d goog.style.getPixelStyleValue_(width, true);\n};\ngoog.style.getSize \x3d function(element) {\n  return goog.style.evaluateWithTemporaryDisplay_(goog.style.getSizeWithDisplay_, element);\n};\ngoog.style.evaluateWithTemporaryDisplay_ \x3d function(fn, element) {\n  if (goog.style.getStyle_(element, \x22display\x22) !\x3d \x22none\x22) {\n    return fn(element);\n  }\n  var style \x3d element.style;\n  var originalDisplay \x3d style.display;\n  var originalVisibility \x3d style.visibility;\n  var originalPosition \x3d style.position;\n  style.visibility \x3d \x22hidden\x22;\n  style.position \x3d \x22absolute\x22;\n  style.display \x3d \x22inline\x22;\n  var retVal \x3d fn(element);\n  style.display \x3d originalDisplay;\n  style.position \x3d originalPosition;\n  style.visibility \x3d originalVisibility;\n  return retVal;\n};\ngoog.style.getSizeWithDisplay_ \x3d function(element) {\n  var offsetWidth \x3d element.offsetWidth;\n  var offsetHeight \x3d element.offsetHeight;\n  var webkitOffsetsZero \x3d goog.userAgent.WEBKIT \x26\x26 !offsetWidth \x26\x26 !offsetHeight;\n  if ((offsetWidth \x3d\x3d\x3d undefined || webkitOffsetsZero) \x26\x26 element.getBoundingClientRect) {\n    var clientRect \x3d goog.style.getBoundingClientRect_(element);\n    return new goog.math.Size(clientRect.right - clientRect.left, clientRect.bottom - clientRect.top);\n  }\n  return new goog.math.Size(offsetWidth, offsetHeight);\n};\ngoog.style.getTransformedSize \x3d function(element) {\n  if (!element.getBoundingClientRect) {\n    return null;\n  }\n  var clientRect \x3d goog.style.evaluateWithTemporaryDisplay_(goog.style.getBoundingClientRect_, element);\n  return new goog.math.Size(clientRect.right - clientRect.left, clientRect.bottom - clientRect.top);\n};\ngoog.style.getBounds \x3d function(element) {\n  var o \x3d goog.style.getPageOffset(element);\n  var s \x3d goog.style.getSize(element);\n  return new goog.math.Rect(o.x, o.y, s.width, s.height);\n};\ngoog.style.toCamelCase \x3d function(selector) {\n  return goog.string.toCamelCase(String(selector));\n};\ngoog.style.toSelectorCase \x3d function(selector) {\n  return goog.string.toSelectorCase(selector);\n};\ngoog.style.getOpacity \x3d function(el) {\n  goog.asserts.assert(el);\n  var style \x3d el.style;\n  var result \x3d \x22\x22;\n  if (\x22opacity\x22 in style) {\n    result \x3d style.opacity;\n  } else if (\x22MozOpacity\x22 in style) {\n    result \x3d style.MozOpacity;\n  } else if (\x22filter\x22 in style) {\n    var match \x3d style.filter.match(/alpha\\(opacity\x3d([\\d.]+)\\)/);\n    if (match) {\n      result \x3d String(match[1] / 100);\n    }\n  }\n  return result \x3d\x3d \x22\x22 ? result : Number(result);\n};\ngoog.style.setOpacity \x3d function(el, alpha) {\n  goog.asserts.assert(el);\n  var style \x3d el.style;\n  if (\x22opacity\x22 in style) {\n    style.opacity \x3d alpha;\n  } else if (\x22MozOpacity\x22 in style) {\n    style.MozOpacity \x3d alpha;\n  } else if (\x22filter\x22 in style) {\n    if (alpha \x3d\x3d\x3d \x22\x22) {\n      style.filter \x3d \x22\x22;\n    } else {\n      style.filter \x3d \x22alpha(opacity\\x3d\x22 + Number(alpha) * 100 + \x22)\x22;\n    }\n  }\n};\ngoog.style.setTransparentBackgroundImage \x3d function(el, src) {\n  var style \x3d el.style;\n  style.backgroundImage \x3d \x22url(\x22 + src + \x22)\x22;\n  style.backgroundPosition \x3d \x22top left\x22;\n  style.backgroundRepeat \x3d \x22no-repeat\x22;\n};\ngoog.style.clearTransparentBackgroundImage \x3d function(el) {\n  var style \x3d el.style;\n  if (\x22filter\x22 in style) {\n    style.filter \x3d \x22\x22;\n  } else {\n    style.backgroundImage \x3d \x22none\x22;\n  }\n};\ngoog.style.showElement \x3d function(el, display) {\n  goog.style.setElementShown(el, display);\n};\ngoog.style.setElementShown \x3d function(el, isShown) {\n  el.style.display \x3d isShown ? \x22\x22 : \x22none\x22;\n};\ngoog.style.isElementShown \x3d function(el) {\n  return el.style.display !\x3d \x22none\x22;\n};\ngoog.style.installSafeStyleSheet \x3d function(safeStyleSheet, opt_node) {\n  var dh \x3d goog.dom.getDomHelper(opt_node);\n  var doc \x3d dh.getDocument();\n  if (goog.userAgent.IE \x26\x26 doc.createStyleSheet) {\n    var styleSheet \x3d doc.createStyleSheet();\n    goog.style.setSafeStyleSheet(styleSheet, safeStyleSheet);\n    return styleSheet;\n  } else {\n    var head \x3d dh.getElementsByTagNameAndClass(goog.dom.TagName.HEAD)[0];\n    if (!head) {\n      var body \x3d dh.getElementsByTagNameAndClass(goog.dom.TagName.BODY)[0];\n      head \x3d dh.createDom(goog.dom.TagName.HEAD);\n      body.parentNode.insertBefore(head, body);\n    }\n    var el \x3d dh.createDom(goog.dom.TagName.STYLE);\n    const nonce \x3d goog.dom.safe.getStyleNonce();\n    if (nonce) {\n      el.setAttribute(\x22nonce\x22, nonce);\n    }\n    goog.style.setSafeStyleSheet(el, safeStyleSheet);\n    dh.appendChild(head, el);\n    return el;\n  }\n};\ngoog.style.uninstallStyles \x3d function(styleSheet) {\n  var node \x3d styleSheet.ownerNode || styleSheet.owningElement || styleSheet;\n  goog.dom.removeNode(node);\n};\ngoog.style.setSafeStyleSheet \x3d function(element, safeStyleSheet) {\n  var stylesString \x3d goog.html.SafeStyleSheet.unwrap(safeStyleSheet);\n  if (goog.userAgent.IE \x26\x26 element.cssText !\x3d\x3d undefined) {\n    element.cssText \x3d stylesString;\n  } else if (goog.global.trustedTypes) {\n    goog.dom.setTextContent(element, stylesString);\n  } else {\n    element.innerHTML \x3d stylesString;\n  }\n};\ngoog.style.setPreWrap \x3d function(el) {\n  var style \x3d el.style;\n  if (goog.userAgent.GECKO) {\n    style.whiteSpace \x3d \x22-moz-pre-wrap\x22;\n  } else {\n    style.whiteSpace \x3d \x22pre-wrap\x22;\n  }\n};\ngoog.style.setInlineBlock \x3d function(el) {\n  var style \x3d el.style;\n  style.position \x3d \x22relative\x22;\n  style.display \x3d \x22inline-block\x22;\n};\ngoog.style.isRightToLeft \x3d function(el) {\n  return \x22rtl\x22 \x3d\x3d goog.style.getStyle_(el, \x22direction\x22);\n};\ngoog.style.unselectableStyle_ \x3d goog.userAgent.GECKO ? \x22MozUserSelect\x22 : goog.userAgent.WEBKIT || goog.userAgent.EDGE ? \x22WebkitUserSelect\x22 : null;\ngoog.style.isUnselectable \x3d function(el) {\n  if (goog.style.unselectableStyle_) {\n    return el.style[goog.style.unselectableStyle_].toLowerCase() \x3d\x3d \x22none\x22;\n  } else if (goog.userAgent.IE) {\n    return el.getAttribute(\x22unselectable\x22) \x3d\x3d \x22on\x22;\n  }\n  return false;\n};\ngoog.style.setUnselectable \x3d function(el, unselectable, opt_noRecurse) {\n  var descendants \x3d !opt_noRecurse ? el.getElementsByTagName(\x22*\x22) : null;\n  var name \x3d goog.style.unselectableStyle_;\n  if (name) {\n    var value \x3d unselectable ? \x22none\x22 : \x22\x22;\n    if (el.style) {\n      el.style[name] \x3d value;\n    }\n    if (descendants) {\n      var i \x3d 0;\n      var descendant;\n      for (; descendant \x3d descendants[i]; i++) {\n        if (descendant.style) {\n          descendant.style[name] \x3d value;\n        }\n      }\n    }\n  } else if (goog.userAgent.IE) {\n    value \x3d unselectable ? \x22on\x22 : \x22\x22;\n    el.setAttribute(\x22unselectable\x22, value);\n    if (descendants) {\n      i \x3d 0;\n      for (; descendant \x3d descendants[i]; i++) {\n        descendant.setAttribute(\x22unselectable\x22, value);\n      }\n    }\n  }\n};\ngoog.style.getBorderBoxSize \x3d function(element) {\n  return new goog.math.Size(element.offsetWidth, element.offsetHeight);\n};\ngoog.style.setBorderBoxSize \x3d function(element, size) {\n  goog.style.setBoxSizingSize_(element, size, \x22border-box\x22);\n};\ngoog.style.getContentBoxSize \x3d function(element) {\n  var doc \x3d goog.dom.getOwnerDocument(element);\n  var ieCurrentStyle \x3d goog.userAgent.IE \x26\x26 element.currentStyle;\n  if (ieCurrentStyle \x26\x26 goog.dom.getDomHelper(doc).isCss1CompatMode() \x26\x26 ieCurrentStyle.width !\x3d \x22auto\x22 \x26\x26 ieCurrentStyle.height !\x3d \x22auto\x22 \x26\x26 !ieCurrentStyle.boxSizing) {\n    var width \x3d goog.style.getIePixelValue_(element, ieCurrentStyle.width, \x22width\x22, \x22pixelWidth\x22);\n    var height \x3d goog.style.getIePixelValue_(element, ieCurrentStyle.height, \x22height\x22, \x22pixelHeight\x22);\n    return new goog.math.Size(width, height);\n  } else {\n    var borderBoxSize \x3d goog.style.getBorderBoxSize(element);\n    var paddingBox \x3d goog.style.getPaddingBox(element);\n    var borderBox \x3d goog.style.getBorderBox(element);\n    return new goog.math.Size(borderBoxSize.width - borderBox.left - paddingBox.left - paddingBox.right - borderBox.right, borderBoxSize.height - borderBox.top - paddingBox.top - paddingBox.bottom - borderBox.bottom);\n  }\n};\ngoog.style.setContentBoxSize \x3d function(element, size) {\n  goog.style.setBoxSizingSize_(element, size, \x22content-box\x22);\n};\ngoog.style.setBoxSizingSize_ \x3d function(element, size, boxSizing) {\n  var style \x3d element.style;\n  if (goog.userAgent.GECKO) {\n    style.MozBoxSizing \x3d boxSizing;\n  } else if (goog.userAgent.WEBKIT) {\n    style.WebkitBoxSizing \x3d boxSizing;\n  } else {\n    style.boxSizing \x3d boxSizing;\n  }\n  style.width \x3d Math.max(size.width, 0) + \x22px\x22;\n  style.height \x3d Math.max(size.height, 0) + \x22px\x22;\n};\ngoog.style.getIePixelValue_ \x3d function(element, value, name, pixelName) {\n  if (/^\\d+px?$/.test(value)) {\n    return parseInt(value, 10);\n  } else {\n    var oldStyleValue \x3d element.style[name];\n    var oldRuntimeValue \x3d element.runtimeStyle[name];\n    element.runtimeStyle[name] \x3d element.currentStyle[name];\n    element.style[name] \x3d value;\n    var pixelValue \x3d element.style[pixelName];\n    element.style[name] \x3d oldStyleValue;\n    element.runtimeStyle[name] \x3d oldRuntimeValue;\n    return +pixelValue;\n  }\n};\ngoog.style.getIePixelDistance_ \x3d function(element, propName) {\n  var value \x3d goog.style.getCascadedStyle(element, propName);\n  return value ? goog.style.getIePixelValue_(element, value, \x22left\x22, \x22pixelLeft\x22) : 0;\n};\ngoog.style.getBox_ \x3d function(element, stylePrefix) {\n  if (goog.userAgent.IE) {\n    var left \x3d goog.style.getIePixelDistance_(element, stylePrefix + \x22Left\x22);\n    var right \x3d goog.style.getIePixelDistance_(element, stylePrefix + \x22Right\x22);\n    var top \x3d goog.style.getIePixelDistance_(element, stylePrefix + \x22Top\x22);\n    var bottom \x3d goog.style.getIePixelDistance_(element, stylePrefix + \x22Bottom\x22);\n    return new goog.math.Box(top, right, bottom, left);\n  } else {\n    left \x3d goog.style.getComputedStyle(element, stylePrefix + \x22Left\x22);\n    right \x3d goog.style.getComputedStyle(element, stylePrefix + \x22Right\x22);\n    top \x3d goog.style.getComputedStyle(element, stylePrefix + \x22Top\x22);\n    bottom \x3d goog.style.getComputedStyle(element, stylePrefix + \x22Bottom\x22);\n    return new goog.math.Box(parseFloat(top), parseFloat(right), parseFloat(bottom), parseFloat(left));\n  }\n};\ngoog.style.getPaddingBox \x3d function(element) {\n  return goog.style.getBox_(element, \x22padding\x22);\n};\ngoog.style.getMarginBox \x3d function(element) {\n  return goog.style.getBox_(element, \x22margin\x22);\n};\ngoog.style.ieBorderWidthKeywords_ \x3d {\x22thin\x22:2, \x22medium\x22:4, \x22thick\x22:6};\ngoog.style.getIePixelBorder_ \x3d function(element, prop) {\n  if (goog.style.getCascadedStyle(element, prop + \x22Style\x22) \x3d\x3d \x22none\x22) {\n    return 0;\n  }\n  var width \x3d goog.style.getCascadedStyle(element, prop + \x22Width\x22);\n  if (width in goog.style.ieBorderWidthKeywords_) {\n    return goog.style.ieBorderWidthKeywords_[width];\n  }\n  return goog.style.getIePixelValue_(element, width, \x22left\x22, \x22pixelLeft\x22);\n};\ngoog.style.getBorderBox \x3d function(element) {\n  if (goog.userAgent.IE \x26\x26 !goog.userAgent.isDocumentModeOrHigher(9)) {\n    var left \x3d goog.style.getIePixelBorder_(element, \x22borderLeft\x22);\n    var right \x3d goog.style.getIePixelBorder_(element, \x22borderRight\x22);\n    var top \x3d goog.style.getIePixelBorder_(element, \x22borderTop\x22);\n    var bottom \x3d goog.style.getIePixelBorder_(element, \x22borderBottom\x22);\n    return new goog.math.Box(top, right, bottom, left);\n  } else {\n    left \x3d goog.style.getComputedStyle(element, \x22borderLeftWidth\x22);\n    right \x3d goog.style.getComputedStyle(element, \x22borderRightWidth\x22);\n    top \x3d goog.style.getComputedStyle(element, \x22borderTopWidth\x22);\n    bottom \x3d goog.style.getComputedStyle(element, \x22borderBottomWidth\x22);\n    return new goog.math.Box(parseFloat(top), parseFloat(right), parseFloat(bottom), parseFloat(left));\n  }\n};\ngoog.style.getFontFamily \x3d function(el) {\n  var doc \x3d goog.dom.getOwnerDocument(el);\n  var font \x3d \x22\x22;\n  if (doc.body.createTextRange \x26\x26 goog.dom.contains(doc, el)) {\n    var range \x3d doc.body.createTextRange();\n    range.moveToElementText(el);\n    try {\n      font \x3d range.queryCommandValue(\x22FontName\x22);\n    } catch (e) {\n      font \x3d \x22\x22;\n    }\n  }\n  if (!font) {\n    font \x3d goog.style.getStyle_(el, \x22fontFamily\x22);\n  }\n  var fontsArray \x3d font.split(\x22,\x22);\n  if (fontsArray.length \x3e 1) {\n    font \x3d fontsArray[0];\n  }\n  return goog.string.stripQuotes(font, \x22\\\x22\x27\x22);\n};\ngoog.style.lengthUnitRegex_ \x3d /[^\\d]+$/;\ngoog.style.getLengthUnits \x3d function(value) {\n  var units \x3d value.match(goog.style.lengthUnitRegex_);\n  return units \x26\x26 units[0] || null;\n};\ngoog.style.ABSOLUTE_CSS_LENGTH_UNITS_ \x3d {\x22cm\x22:1, \x22in\x22:1, \x22mm\x22:1, \x22pc\x22:1, \x22pt\x22:1};\ngoog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_ \x3d {\x22em\x22:1, \x22ex\x22:1};\ngoog.style.getFontSize \x3d function(el) {\n  var fontSize \x3d goog.style.getStyle_(el, \x22fontSize\x22);\n  var sizeUnits \x3d goog.style.getLengthUnits(fontSize);\n  if (fontSize \x26\x26 \x22px\x22 \x3d\x3d sizeUnits) {\n    return parseInt(fontSize, 10);\n  }\n  if (goog.userAgent.IE) {\n    if (String(sizeUnits) in goog.style.ABSOLUTE_CSS_LENGTH_UNITS_) {\n      return goog.style.getIePixelValue_(el, fontSize, \x22left\x22, \x22pixelLeft\x22);\n    } else if (el.parentNode \x26\x26 el.parentNode.nodeType \x3d\x3d goog.dom.NodeType.ELEMENT \x26\x26 String(sizeUnits) in goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_) {\n      var parentElement \x3d el.parentNode;\n      var parentSize \x3d goog.style.getStyle_(parentElement, \x22fontSize\x22);\n      return goog.style.getIePixelValue_(parentElement, fontSize \x3d\x3d parentSize ? \x221em\x22 : fontSize, \x22left\x22, \x22pixelLeft\x22);\n    }\n  }\n  var sizeElement \x3d goog.dom.createDom(goog.dom.TagName.SPAN, {\x22style\x22:\x22visibility:hidden;position:absolute;\x22 + \x22line-height:0;padding:0;margin:0;border:0;height:1em;\x22});\n  goog.dom.appendChild(el, sizeElement);\n  fontSize \x3d sizeElement.offsetHeight;\n  goog.dom.removeNode(sizeElement);\n  return fontSize;\n};\ngoog.style.parseStyleAttribute \x3d function(value) {\n  var result \x3d {};\n  value.split(/\\s*;\\s*/).forEach(function(pair) {\n    var keyValue \x3d pair.match(/\\s*([\\w-]+)\\s*:(.+)/);\n    if (keyValue) {\n      var styleName \x3d keyValue[1];\n      var styleValue \x3d goog.string.trim(keyValue[2]);\n      result[goog.string.toCamelCase(styleName.toLowerCase())] \x3d styleValue;\n    }\n  });\n  return result;\n};\ngoog.style.toStyleAttribute \x3d function(obj) {\n  var buffer \x3d [];\n  goog.object.forEach(obj, function(value, key) {\n    buffer.push(goog.string.toSelectorCase(key), \x22:\x22, value, \x22;\x22);\n  });\n  return buffer.join(\x22\x22);\n};\ngoog.style.setFloat \x3d function(el, value) {\n  el.style[goog.userAgent.IE ? \x22styleFloat\x22 : \x22cssFloat\x22] \x3d value;\n};\ngoog.style.getFloat \x3d function(el) {\n  return el.style[goog.userAgent.IE ? \x22styleFloat\x22 : \x22cssFloat\x22] || \x22\x22;\n};\ngoog.style.getScrollbarWidth \x3d function(opt_className) {\n  var outerDiv \x3d goog.dom.createElement(goog.dom.TagName.DIV);\n  if (opt_className) {\n    outerDiv.className \x3d opt_className;\n  }\n  outerDiv.style.cssText \x3d \x22overflow:auto;\x22 + \x22position:absolute;top:0;width:100px;height:100px\x22;\n  var innerDiv \x3d goog.dom.createElement(goog.dom.TagName.DIV);\n  goog.style.setSize(innerDiv, \x22200px\x22, \x22200px\x22);\n  outerDiv.appendChild(innerDiv);\n  goog.dom.appendChild(goog.dom.getDocument().body, outerDiv);\n  var width \x3d outerDiv.offsetWidth - outerDiv.clientWidth;\n  goog.dom.removeNode(outerDiv);\n  return width;\n};\ngoog.style.MATRIX_TRANSLATION_REGEX_ \x3d new RegExp(\x22matrix\\\\([0-9\\\\.\\\\-]+, [0-9\\\\.\\\\-]+, \x22 + \x22[0-9\\\\.\\\\-]+, [0-9\\\\.\\\\-]+, \x22 + \x22([0-9\\\\.\\\\-]+)p?x?, ([0-9\\\\.\\\\-]+)p?x?\\\\)\x22);\ngoog.style.getCssTranslation \x3d function(element) {\n  var transform \x3d goog.style.getComputedTransform(element);\n  if (!transform) {\n    return new goog.math.Coordinate(0, 0);\n  }\n  var matches \x3d transform.match(goog.style.MATRIX_TRANSLATION_REGEX_);\n  if (!matches) {\n    return new goog.math.Coordinate(0, 0);\n  }\n  return new goog.math.Coordinate(parseFloat(matches[1]), parseFloat(matches[2]));\n};\n");
SHADOW_ENV.evalLoad("shadow.dom.js", true, "goog.provide(\x27shadow.dom\x27);\nshadow.dom.transition_supported_QMARK_ \x3d true;\n\n/**\n * @interface\n */\nshadow.dom.IElement \x3d function(){};\n\nvar shadow$dom$IElement$_to_dom$dyn_23464 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.dom._to_dom[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.dom._to_dom[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22IElement.-to-dom\x22,this$);\n}\n}\n});\nshadow.dom._to_dom \x3d (function shadow$dom$_to_dom(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$dom$IElement$_to_dom$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$dom$IElement$_to_dom$arity$1(this$);\n} else {\nreturn shadow$dom$IElement$_to_dom$dyn_23464(this$);\n}\n});\n\n\n/**\n * @interface\n */\nshadow.dom.SVGElement \x3d function(){};\n\nvar shadow$dom$SVGElement$_to_svg$dyn_23473 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.dom._to_svg[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.dom._to_svg[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22SVGElement.-to-svg\x22,this$);\n}\n}\n});\nshadow.dom._to_svg \x3d (function shadow$dom$_to_svg(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$dom$SVGElement$_to_svg$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$dom$SVGElement$_to_svg$arity$1(this$);\n} else {\nreturn shadow$dom$SVGElement$_to_svg$dyn_23473(this$);\n}\n});\n\nshadow.dom.lazy_native_coll_seq \x3d (function shadow$dom$lazy_native_coll_seq(coll,idx){\nif((idx \x3c coll.length)){\nreturn (new cljs.core.LazySeq(null,(function (){\nreturn cljs.core.cons((coll[idx]),(function (){var G__21744 \x3d coll;\nvar G__21745 \x3d (idx + (1));\nreturn (shadow.dom.lazy_native_coll_seq.cljs$core$IFn$_invoke$arity$2 ? shadow.dom.lazy_native_coll_seq.cljs$core$IFn$_invoke$arity$2(G__21744,G__21745) : shadow.dom.lazy_native_coll_seq.call(null, G__21744,G__21745));\n})());\n}),null,null));\n} else {\nreturn null;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IIndexed}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IDeref}\n * @implements {shadow.dom.IElement}\n*/\nshadow.dom.NativeColl \x3d (function (coll){\nthis.coll \x3d coll;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 8421394;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.dom.NativeColl.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.coll;\n}));\n\n(shadow.dom.NativeColl.prototype.cljs$core$IIndexed$_nth$arity$2 \x3d (function (this$,n){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (self__.coll[n]);\n}));\n\n(shadow.dom.NativeColl.prototype.cljs$core$IIndexed$_nth$arity$3 \x3d (function (this$,n,not_found){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar or__5002__auto__ \x3d (self__.coll[n]);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn not_found;\n}\n}));\n\n(shadow.dom.NativeColl.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.coll.length;\n}));\n\n(shadow.dom.NativeColl.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn shadow.dom.lazy_native_coll_seq(self__.coll,(0));\n}));\n\n(shadow.dom.NativeColl.prototype.shadow$dom$IElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.dom.NativeColl.prototype.shadow$dom$IElement$_to_dom$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.coll;\n}));\n\n(shadow.dom.NativeColl.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22coll\x22,\x22coll\x22,-1006698606,null)], null);\n}));\n\n(shadow.dom.NativeColl.cljs$lang$type \x3d true);\n\n(shadow.dom.NativeColl.cljs$lang$ctorStr \x3d \x22shadow.dom/NativeColl\x22);\n\n(shadow.dom.NativeColl.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.dom/NativeColl\x22);\n}));\n\n/**\n * Positional factory function for shadow.dom/NativeColl.\n */\nshadow.dom.__GT_NativeColl \x3d (function shadow$dom$__GT_NativeColl(coll){\nreturn (new shadow.dom.NativeColl(coll));\n});\n\nshadow.dom.native_coll \x3d (function shadow$dom$native_coll(coll){\nreturn (new shadow.dom.NativeColl(coll));\n});\nshadow.dom.dom_node \x3d (function shadow$dom$dom_node(el){\nif((el \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((el \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d el.shadow$dom$IElement$))))?true:false):false)){\nreturn el.shadow$dom$IElement$_to_dom$arity$1(null, );\n} else {\nif(typeof el \x3d\x3d\x3d \x27string\x27){\nreturn document.createTextNode(el);\n} else {\nif(typeof el \x3d\x3d\x3d \x27number\x27){\nreturn document.createTextNode(cljs.core.str.cljs$core$IFn$_invoke$arity$1(el));\n} else {\nreturn el;\n\n}\n}\n}\n}\n});\nshadow.dom.query_one \x3d (function shadow$dom$query_one(var_args){\nvar G__21801 \x3d arguments.length;\nswitch (G__21801) {\ncase 1:\nreturn shadow.dom.query_one.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.dom.query_one.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.query_one.cljs$core$IFn$_invoke$arity$1 \x3d (function (sel){\nreturn document.querySelector(sel);\n}));\n\n(shadow.dom.query_one.cljs$core$IFn$_invoke$arity$2 \x3d (function (sel,root){\nreturn shadow.dom.dom_node(root).querySelector(sel);\n}));\n\n(shadow.dom.query_one.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.query \x3d (function shadow$dom$query(var_args){\nvar G__21810 \x3d arguments.length;\nswitch (G__21810) {\ncase 1:\nreturn shadow.dom.query.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.dom.query.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.query.cljs$core$IFn$_invoke$arity$1 \x3d (function (sel){\nreturn (new shadow.dom.NativeColl(document.querySelectorAll(sel)));\n}));\n\n(shadow.dom.query.cljs$core$IFn$_invoke$arity$2 \x3d (function (sel,root){\nreturn (new shadow.dom.NativeColl(shadow.dom.dom_node(root).querySelectorAll(sel)));\n}));\n\n(shadow.dom.query.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.by_id \x3d (function shadow$dom$by_id(var_args){\nvar G__21834 \x3d arguments.length;\nswitch (G__21834) {\ncase 2:\nreturn shadow.dom.by_id.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 1:\nreturn shadow.dom.by_id.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.by_id.cljs$core$IFn$_invoke$arity$2 \x3d (function (id,el){\nreturn shadow.dom.dom_node(el).getElementById(id);\n}));\n\n(shadow.dom.by_id.cljs$core$IFn$_invoke$arity$1 \x3d (function (id){\nreturn document.getElementById(id);\n}));\n\n(shadow.dom.by_id.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.build \x3d shadow.dom.dom_node;\nshadow.dom.ev_stop \x3d (function shadow$dom$ev_stop(var_args){\nvar G__21852 \x3d arguments.length;\nswitch (G__21852) {\ncase 1:\nreturn shadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 4:\nreturn shadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$1 \x3d (function (e){\nif(cljs.core.truth_(e.stopPropagation)){\ne.stopPropagation();\n\ne.preventDefault();\n} else {\n(e.cancelBubble \x3d true);\n\n(e.returnValue \x3d false);\n}\n\nreturn e;\n}));\n\n(shadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$2 \x3d (function (e,el){\nshadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$1(e);\n\nreturn el;\n}));\n\n(shadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$4 \x3d (function (e,el,scope,owner){\nshadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$1(e);\n\nreturn el;\n}));\n\n(shadow.dom.ev_stop.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * check wether a parent node (or the document) contains the child\n */\nshadow.dom.contains_QMARK_ \x3d (function shadow$dom$contains_QMARK_(var_args){\nvar G__21872 \x3d arguments.length;\nswitch (G__21872) {\ncase 1:\nreturn shadow.dom.contains_QMARK_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.dom.contains_QMARK_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.contains_QMARK_.cljs$core$IFn$_invoke$arity$1 \x3d (function (el){\nreturn goog.dom.contains(document,shadow.dom.dom_node(el));\n}));\n\n(shadow.dom.contains_QMARK_.cljs$core$IFn$_invoke$arity$2 \x3d (function (parent,el){\nreturn goog.dom.contains(shadow.dom.dom_node(parent),shadow.dom.dom_node(el));\n}));\n\n(shadow.dom.contains_QMARK_.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.add_class \x3d (function shadow$dom$add_class(el,cls){\nreturn goog.dom.classlist.add(shadow.dom.dom_node(el),cls);\n});\nshadow.dom.remove_class \x3d (function shadow$dom$remove_class(el,cls){\nreturn goog.dom.classlist.remove(shadow.dom.dom_node(el),cls);\n});\nshadow.dom.toggle_class \x3d (function shadow$dom$toggle_class(var_args){\nvar G__21910 \x3d arguments.length;\nswitch (G__21910) {\ncase 2:\nreturn shadow.dom.toggle_class.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn shadow.dom.toggle_class.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.toggle_class.cljs$core$IFn$_invoke$arity$2 \x3d (function (el,cls){\nreturn goog.dom.classlist.toggle(shadow.dom.dom_node(el),cls);\n}));\n\n(shadow.dom.toggle_class.cljs$core$IFn$_invoke$arity$3 \x3d (function (el,cls,v){\nif(cljs.core.truth_(v)){\nreturn shadow.dom.add_class(el,cls);\n} else {\nreturn shadow.dom.remove_class(el,cls);\n}\n}));\n\n(shadow.dom.toggle_class.cljs$lang$maxFixedArity \x3d 3);\n\nshadow.dom.dom_listen \x3d (cljs.core.truth_((function (){var or__5002__auto__ \x3d (!((typeof document !\x3d\x3d \x27undefined\x27)));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn document.addEventListener;\n}\n})())?(function shadow$dom$dom_listen_good(el,ev,handler){\nreturn el.addEventListener(ev,handler,false);\n}):(function shadow$dom$dom_listen_ie(el,ev,handler){\ntry{return el.attachEvent([\x22on\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(ev)].join(\x27\x27),(function (e){\nreturn (handler.cljs$core$IFn$_invoke$arity$2 ? handler.cljs$core$IFn$_invoke$arity$2(e,el) : handler.call(null, e,el));\n}));\n}catch (e21933){if((e21933 instanceof Object)){\nvar e \x3d e21933;\nreturn console.log(\x22didnt support attachEvent\x22,el,e);\n} else {\nthrow e21933;\n\n}\n}}));\nshadow.dom.dom_listen_remove \x3d (cljs.core.truth_((function (){var or__5002__auto__ \x3d (!((typeof document !\x3d\x3d \x27undefined\x27)));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn document.removeEventListener;\n}\n})())?(function shadow$dom$dom_listen_remove_good(el,ev,handler){\nreturn el.removeEventListener(ev,handler,false);\n}):(function shadow$dom$dom_listen_remove_ie(el,ev,handler){\nreturn el.detachEvent([\x22on\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(ev)].join(\x27\x27),handler);\n}));\nshadow.dom.on_query \x3d (function shadow$dom$on_query(root_el,ev,selector,handler){\nvar seq__21951 \x3d cljs.core.seq(shadow.dom.query.cljs$core$IFn$_invoke$arity$2(selector,root_el));\nvar chunk__21952 \x3d null;\nvar count__21953 \x3d (0);\nvar i__21954 \x3d (0);\nwhile(true){\nif((i__21954 \x3c count__21953)){\nvar el \x3d chunk__21952.cljs$core$IIndexed$_nth$arity$2(null, i__21954);\nvar handler_23555__$1 \x3d ((function (seq__21951,chunk__21952,count__21953,i__21954,el){\nreturn (function (e){\nreturn (handler.cljs$core$IFn$_invoke$arity$2 ? handler.cljs$core$IFn$_invoke$arity$2(e,el) : handler.call(null, e,el));\n});})(seq__21951,chunk__21952,count__21953,i__21954,el))\n;\nshadow.dom.dom_listen(el,cljs.core.name(ev),handler_23555__$1);\n\n\nvar G__23558 \x3d seq__21951;\nvar G__23559 \x3d chunk__21952;\nvar G__23560 \x3d count__21953;\nvar G__23561 \x3d (i__21954 + (1));\nseq__21951 \x3d G__23558;\nchunk__21952 \x3d G__23559;\ncount__21953 \x3d G__23560;\ni__21954 \x3d G__23561;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__21951);\nif(temp__5804__auto__){\nvar seq__21951__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__21951__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__21951__$1);\nvar G__23565 \x3d cljs.core.chunk_rest(seq__21951__$1);\nvar G__23566 \x3d c__5525__auto__;\nvar G__23567 \x3d cljs.core.count(c__5525__auto__);\nvar G__23568 \x3d (0);\nseq__21951 \x3d G__23565;\nchunk__21952 \x3d G__23566;\ncount__21953 \x3d G__23567;\ni__21954 \x3d G__23568;\ncontinue;\n} else {\nvar el \x3d cljs.core.first(seq__21951__$1);\nvar handler_23569__$1 \x3d ((function (seq__21951,chunk__21952,count__21953,i__21954,el,seq__21951__$1,temp__5804__auto__){\nreturn (function (e){\nreturn (handler.cljs$core$IFn$_invoke$arity$2 ? handler.cljs$core$IFn$_invoke$arity$2(e,el) : handler.call(null, e,el));\n});})(seq__21951,chunk__21952,count__21953,i__21954,el,seq__21951__$1,temp__5804__auto__))\n;\nshadow.dom.dom_listen(el,cljs.core.name(ev),handler_23569__$1);\n\n\nvar G__23579 \x3d cljs.core.next(seq__21951__$1);\nvar G__23580 \x3d null;\nvar G__23581 \x3d (0);\nvar G__23582 \x3d (0);\nseq__21951 \x3d G__23579;\nchunk__21952 \x3d G__23580;\ncount__21953 \x3d G__23581;\ni__21954 \x3d G__23582;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.dom.on \x3d (function shadow$dom$on(var_args){\nvar G__21982 \x3d arguments.length;\nswitch (G__21982) {\ncase 3:\nreturn shadow.dom.on.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.dom.on.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.on.cljs$core$IFn$_invoke$arity$3 \x3d (function (el,ev,handler){\nreturn shadow.dom.on.cljs$core$IFn$_invoke$arity$4(el,ev,handler,false);\n}));\n\n(shadow.dom.on.cljs$core$IFn$_invoke$arity$4 \x3d (function (el,ev,handler,capture){\nif(cljs.core.vector_QMARK_(ev)){\nreturn shadow.dom.on_query(el,cljs.core.first(ev),cljs.core.second(ev),handler);\n} else {\nvar handler__$1 \x3d (function (e){\nreturn (handler.cljs$core$IFn$_invoke$arity$2 ? handler.cljs$core$IFn$_invoke$arity$2(e,el) : handler.call(null, e,el));\n});\nreturn shadow.dom.dom_listen(shadow.dom.dom_node(el),cljs.core.name(ev),handler__$1);\n}\n}));\n\n(shadow.dom.on.cljs$lang$maxFixedArity \x3d 4);\n\nshadow.dom.remove_event_handler \x3d (function shadow$dom$remove_event_handler(el,ev,handler){\nreturn shadow.dom.dom_listen_remove(shadow.dom.dom_node(el),cljs.core.name(ev),handler);\n});\nshadow.dom.add_event_listeners \x3d (function shadow$dom$add_event_listeners(el,events){\nvar seq__21993 \x3d cljs.core.seq(events);\nvar chunk__21994 \x3d null;\nvar count__21995 \x3d (0);\nvar i__21996 \x3d (0);\nwhile(true){\nif((i__21996 \x3c count__21995)){\nvar vec__22011 \x3d chunk__21994.cljs$core$IIndexed$_nth$arity$2(null, i__21996);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22011,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22011,(1),null);\nshadow.dom.on.cljs$core$IFn$_invoke$arity$3(el,k,v);\n\n\nvar G__23625 \x3d seq__21993;\nvar G__23626 \x3d chunk__21994;\nvar G__23627 \x3d count__21995;\nvar G__23628 \x3d (i__21996 + (1));\nseq__21993 \x3d G__23625;\nchunk__21994 \x3d G__23626;\ncount__21995 \x3d G__23627;\ni__21996 \x3d G__23628;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__21993);\nif(temp__5804__auto__){\nvar seq__21993__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__21993__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__21993__$1);\nvar G__23635 \x3d cljs.core.chunk_rest(seq__21993__$1);\nvar G__23636 \x3d c__5525__auto__;\nvar G__23637 \x3d cljs.core.count(c__5525__auto__);\nvar G__23638 \x3d (0);\nseq__21993 \x3d G__23635;\nchunk__21994 \x3d G__23636;\ncount__21995 \x3d G__23637;\ni__21996 \x3d G__23638;\ncontinue;\n} else {\nvar vec__22018 \x3d cljs.core.first(seq__21993__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22018,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22018,(1),null);\nshadow.dom.on.cljs$core$IFn$_invoke$arity$3(el,k,v);\n\n\nvar G__23641 \x3d cljs.core.next(seq__21993__$1);\nvar G__23642 \x3d null;\nvar G__23643 \x3d (0);\nvar G__23644 \x3d (0);\nseq__21993 \x3d G__23641;\nchunk__21994 \x3d G__23642;\ncount__21995 \x3d G__23643;\ni__21996 \x3d G__23644;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.dom.set_style \x3d (function shadow$dom$set_style(el,styles){\nvar dom \x3d shadow.dom.dom_node(el);\nvar seq__22027 \x3d cljs.core.seq(styles);\nvar chunk__22028 \x3d null;\nvar count__22029 \x3d (0);\nvar i__22030 \x3d (0);\nwhile(true){\nif((i__22030 \x3c count__22029)){\nvar vec__22069 \x3d chunk__22028.cljs$core$IIndexed$_nth$arity$2(null, i__22030);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22069,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22069,(1),null);\ngoog.style.setStyle(dom,cljs.core.name(k),(((v \x3d\x3d null))?\x22\x22:v));\n\n\nvar G__23656 \x3d seq__22027;\nvar G__23657 \x3d chunk__22028;\nvar G__23658 \x3d count__22029;\nvar G__23659 \x3d (i__22030 + (1));\nseq__22027 \x3d G__23656;\nchunk__22028 \x3d G__23657;\ncount__22029 \x3d G__23658;\ni__22030 \x3d G__23659;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__22027);\nif(temp__5804__auto__){\nvar seq__22027__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__22027__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__22027__$1);\nvar G__23663 \x3d cljs.core.chunk_rest(seq__22027__$1);\nvar G__23664 \x3d c__5525__auto__;\nvar G__23665 \x3d cljs.core.count(c__5525__auto__);\nvar G__23666 \x3d (0);\nseq__22027 \x3d G__23663;\nchunk__22028 \x3d G__23664;\ncount__22029 \x3d G__23665;\ni__22030 \x3d G__23666;\ncontinue;\n} else {\nvar vec__22080 \x3d cljs.core.first(seq__22027__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22080,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22080,(1),null);\ngoog.style.setStyle(dom,cljs.core.name(k),(((v \x3d\x3d null))?\x22\x22:v));\n\n\nvar G__23668 \x3d cljs.core.next(seq__22027__$1);\nvar G__23669 \x3d null;\nvar G__23670 \x3d (0);\nvar G__23671 \x3d (0);\nseq__22027 \x3d G__23668;\nchunk__22028 \x3d G__23669;\ncount__22029 \x3d G__23670;\ni__22030 \x3d G__23671;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.dom.set_attr_STAR_ \x3d (function shadow$dom$set_attr_STAR_(el,key,value){\nvar G__22106_23673 \x3d key;\nvar G__22106_23674__$1 \x3d (((G__22106_23673 instanceof cljs.core.Keyword))?G__22106_23673.fqn:null);\nswitch (G__22106_23674__$1) {\ncase \x22id\x22:\n(el.id \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(value));\n\nbreak;\ncase \x22class\x22:\n(el.className \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(value));\n\nbreak;\ncase \x22for\x22:\n(el.htmlFor \x3d value);\n\nbreak;\ncase \x22cellpadding\x22:\nel.setAttribute(\x22cellPadding\x22,value);\n\nbreak;\ncase \x22cellspacing\x22:\nel.setAttribute(\x22cellSpacing\x22,value);\n\nbreak;\ncase \x22colspan\x22:\nel.setAttribute(\x22colSpan\x22,value);\n\nbreak;\ncase \x22frameborder\x22:\nel.setAttribute(\x22frameBorder\x22,value);\n\nbreak;\ncase \x22height\x22:\nel.setAttribute(\x22height\x22,value);\n\nbreak;\ncase \x22maxlength\x22:\nel.setAttribute(\x22maxLength\x22,value);\n\nbreak;\ncase \x22role\x22:\nel.setAttribute(\x22role\x22,value);\n\nbreak;\ncase \x22rowspan\x22:\nel.setAttribute(\x22rowSpan\x22,value);\n\nbreak;\ncase \x22type\x22:\nel.setAttribute(\x22type\x22,value);\n\nbreak;\ncase \x22usemap\x22:\nel.setAttribute(\x22useMap\x22,value);\n\nbreak;\ncase \x22valign\x22:\nel.setAttribute(\x22vAlign\x22,value);\n\nbreak;\ncase \x22width\x22:\nel.setAttribute(\x22width\x22,value);\n\nbreak;\ncase \x22on\x22:\nshadow.dom.add_event_listeners(el,value);\n\nbreak;\ncase \x22style\x22:\nif((value \x3d\x3d null)){\n} else {\nif(typeof value \x3d\x3d\x3d \x27string\x27){\nel.setAttribute(\x22style\x22,value);\n} else {\nif(cljs.core.map_QMARK_(value)){\nshadow.dom.set_style(el,value);\n} else {\ngoog.style.setStyle(el,value);\n\n}\n}\n}\n\nbreak;\ndefault:\nvar ks_23684 \x3d cljs.core.name(key);\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d goog.string.startsWith(ks_23684,\x22data-\x22);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn goog.string.startsWith(ks_23684,\x22aria-\x22);\n}\n})())){\nel.setAttribute(ks_23684,value);\n} else {\n(el[ks_23684] \x3d value);\n}\n\n}\n\nreturn el;\n});\nshadow.dom.set_attrs \x3d (function shadow$dom$set_attrs(el,attrs){\nreturn cljs.core.reduce_kv((function (el__$1,key,value){\nshadow.dom.set_attr_STAR_(el__$1,key,value);\n\nreturn el__$1;\n}),shadow.dom.dom_node(el),attrs);\n});\nshadow.dom.set_attr \x3d (function shadow$dom$set_attr(el,key,value){\nreturn shadow.dom.set_attr_STAR_(shadow.dom.dom_node(el),key,value);\n});\nshadow.dom.has_class_QMARK_ \x3d (function shadow$dom$has_class_QMARK_(el,cls){\nreturn goog.dom.classlist.contains(shadow.dom.dom_node(el),cls);\n});\nshadow.dom.merge_class_string \x3d (function shadow$dom$merge_class_string(current,extra_class){\nif(cljs.core.seq(current)){\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(current),\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(extra_class)].join(\x27\x27);\n} else {\nreturn extra_class;\n}\n});\nshadow.dom.parse_tag \x3d (function shadow$dom$parse_tag(spec){\nvar spec__$1 \x3d cljs.core.name(spec);\nvar fdot \x3d spec__$1.indexOf(\x22.\x22);\nvar fhash \x3d spec__$1.indexOf(\x22#\x22);\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((-1),fdot)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((-1),fhash)))){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [spec__$1,null,null], null);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((-1),fhash)){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [spec__$1.substring((0),fdot),null,clojure.string.replace(spec__$1.substring((fdot + (1))),/\\./,\x22 \x22)], null);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((-1),fdot)){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [spec__$1.substring((0),fhash),spec__$1.substring((fhash + (1))),null], null);\n} else {\nif((fhash \x3e fdot)){\nthrow [\x22cant have id after class?\x22,spec__$1].join(\x27\x27);\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [spec__$1.substring((0),fhash),spec__$1.substring((fhash + (1)),fdot),clojure.string.replace(spec__$1.substring((fdot + (1))),/\\./,\x22 \x22)], null);\n\n}\n}\n}\n}\n});\nshadow.dom.create_dom_node \x3d (function shadow$dom$create_dom_node(tag_def,p__22160){\nvar map__22161 \x3d p__22160;\nvar map__22161__$1 \x3d cljs.core.__destructure_map(map__22161);\nvar props \x3d map__22161__$1;\nvar class$ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__22161__$1,new cljs.core.Keyword(null,\x22class\x22,\x22class\x22,-2030961996));\nvar tag_props \x3d ({});\nvar vec__22162 \x3d shadow.dom.parse_tag(tag_def);\nvar tag_name \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22162,(0),null);\nvar tag_id \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22162,(1),null);\nvar tag_classes \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22162,(2),null);\nif(cljs.core.truth_(tag_id)){\n(tag_props[\x22id\x22] \x3d tag_id);\n} else {\n}\n\nif(cljs.core.truth_(tag_classes)){\n(tag_props[\x22class\x22] \x3d shadow.dom.merge_class_string(class$,tag_classes));\n} else {\n}\n\nvar G__22166 \x3d goog.dom.createDom(tag_name,tag_props);\nshadow.dom.set_attrs(G__22166,cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(props,new cljs.core.Keyword(null,\x22class\x22,\x22class\x22,-2030961996)));\n\nreturn G__22166;\n});\nshadow.dom.append \x3d (function shadow$dom$append(var_args){\nvar G__22173 \x3d arguments.length;\nswitch (G__22173) {\ncase 1:\nreturn shadow.dom.append.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.dom.append.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.append.cljs$core$IFn$_invoke$arity$1 \x3d (function (node){\nif(cljs.core.truth_(node)){\nvar temp__5804__auto__ \x3d shadow.dom.dom_node(node);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar n \x3d temp__5804__auto__;\ndocument.body.appendChild(n);\n\nreturn n;\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}));\n\n(shadow.dom.append.cljs$core$IFn$_invoke$arity$2 \x3d (function (el,node){\nif(cljs.core.truth_(node)){\nvar temp__5804__auto__ \x3d shadow.dom.dom_node(node);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar n \x3d temp__5804__auto__;\nshadow.dom.dom_node(el).appendChild(n);\n\nreturn n;\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}));\n\n(shadow.dom.append.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.destructure_node \x3d (function shadow$dom$destructure_node(create_fn,p__22210){\nvar vec__22211 \x3d p__22210;\nvar seq__22212 \x3d cljs.core.seq(vec__22211);\nvar first__22213 \x3d cljs.core.first(seq__22212);\nvar seq__22212__$1 \x3d cljs.core.next(seq__22212);\nvar nn \x3d first__22213;\nvar first__22213__$1 \x3d cljs.core.first(seq__22212__$1);\nvar seq__22212__$2 \x3d cljs.core.next(seq__22212__$1);\nvar np \x3d first__22213__$1;\nvar nc \x3d seq__22212__$2;\nvar node \x3d vec__22211;\nif((nn instanceof cljs.core.Keyword)){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid dom node\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22node\x22,\x22node\x22,581201198),node], null));\n}\n\nif((((np \x3d\x3d null)) \x26\x26 ((nc \x3d\x3d null)))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(function (){var G__22214 \x3d nn;\nvar G__22215 \x3d cljs.core.PersistentArrayMap.EMPTY;\nreturn (create_fn.cljs$core$IFn$_invoke$arity$2 ? create_fn.cljs$core$IFn$_invoke$arity$2(G__22214,G__22215) : create_fn.call(null, G__22214,G__22215));\n})(),cljs.core.List.EMPTY], null);\n} else {\nif(cljs.core.map_QMARK_(np)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(create_fn.cljs$core$IFn$_invoke$arity$2 ? create_fn.cljs$core$IFn$_invoke$arity$2(nn,np) : create_fn.call(null, nn,np)),nc], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(function (){var G__22219 \x3d nn;\nvar G__22220 \x3d cljs.core.PersistentArrayMap.EMPTY;\nreturn (create_fn.cljs$core$IFn$_invoke$arity$2 ? create_fn.cljs$core$IFn$_invoke$arity$2(G__22219,G__22220) : create_fn.call(null, G__22219,G__22220));\n})(),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(nc,np)], null);\n\n}\n}\n});\nshadow.dom.make_dom_node \x3d (function shadow$dom$make_dom_node(structure){\nvar vec__22224 \x3d shadow.dom.destructure_node(shadow.dom.create_dom_node,structure);\nvar node \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22224,(0),null);\nvar node_children \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22224,(1),null);\nvar seq__22227_23755 \x3d cljs.core.seq(node_children);\nvar chunk__22228_23756 \x3d null;\nvar count__22229_23757 \x3d (0);\nvar i__22230_23758 \x3d (0);\nwhile(true){\nif((i__22230_23758 \x3c count__22229_23757)){\nvar child_struct_23768 \x3d chunk__22228_23756.cljs$core$IIndexed$_nth$arity$2(null, i__22230_23758);\nvar children_23770 \x3d shadow.dom.dom_node(child_struct_23768);\nif(cljs.core.seq_QMARK_(children_23770)){\nvar seq__22314_23772 \x3d cljs.core.seq(cljs.core.map.cljs$core$IFn$_invoke$arity$2(shadow.dom.dom_node,children_23770));\nvar chunk__22316_23773 \x3d null;\nvar count__22317_23774 \x3d (0);\nvar i__22318_23775 \x3d (0);\nwhile(true){\nif((i__22318_23775 \x3c count__22317_23774)){\nvar child_23777 \x3d chunk__22316_23773.cljs$core$IIndexed$_nth$arity$2(null, i__22318_23775);\nif(cljs.core.truth_(child_23777)){\nshadow.dom.append.cljs$core$IFn$_invoke$arity$2(node,child_23777);\n\n\nvar G__23778 \x3d seq__22314_23772;\nvar G__23779 \x3d chunk__22316_23773;\nvar G__23780 \x3d count__22317_23774;\nvar G__23781 \x3d (i__22318_23775 + (1));\nseq__22314_23772 \x3d G__23778;\nchunk__22316_23773 \x3d G__23779;\ncount__22317_23774 \x3d G__23780;\ni__22318_23775 \x3d G__23781;\ncontinue;\n} else {\nvar G__23782 \x3d seq__22314_23772;\nvar G__23783 \x3d chunk__22316_23773;\nvar G__23784 \x3d count__22317_23774;\nvar G__23785 \x3d (i__22318_23775 + (1));\nseq__22314_23772 \x3d G__23782;\nchunk__22316_23773 \x3d G__23783;\ncount__22317_23774 \x3d G__23784;\ni__22318_23775 \x3d G__23785;\ncontinue;\n}\n} else {\nvar temp__5804__auto___23787 \x3d cljs.core.seq(seq__22314_23772);\nif(temp__5804__auto___23787){\nvar seq__22314_23788__$1 \x3d temp__5804__auto___23787;\nif(cljs.core.chunked_seq_QMARK_(seq__22314_23788__$1)){\nvar c__5525__auto___23789 \x3d cljs.core.chunk_first(seq__22314_23788__$1);\nvar G__23790 \x3d cljs.core.chunk_rest(seq__22314_23788__$1);\nvar G__23791 \x3d c__5525__auto___23789;\nvar G__23792 \x3d cljs.core.count(c__5525__auto___23789);\nvar G__23793 \x3d (0);\nseq__22314_23772 \x3d G__23790;\nchunk__22316_23773 \x3d G__23791;\ncount__22317_23774 \x3d G__23792;\ni__22318_23775 \x3d G__23793;\ncontinue;\n} else {\nvar child_23794 \x3d cljs.core.first(seq__22314_23788__$1);\nif(cljs.core.truth_(child_23794)){\nshadow.dom.append.cljs$core$IFn$_invoke$arity$2(node,child_23794);\n\n\nvar G__23795 \x3d cljs.core.next(seq__22314_23788__$1);\nvar G__23796 \x3d null;\nvar G__23797 \x3d (0);\nvar G__23798 \x3d (0);\nseq__22314_23772 \x3d G__23795;\nchunk__22316_23773 \x3d G__23796;\ncount__22317_23774 \x3d G__23797;\ni__22318_23775 \x3d G__23798;\ncontinue;\n} else {\nvar G__23803 \x3d cljs.core.next(seq__22314_23788__$1);\nvar G__23804 \x3d null;\nvar G__23805 \x3d (0);\nvar G__23806 \x3d (0);\nseq__22314_23772 \x3d G__23803;\nchunk__22316_23773 \x3d G__23804;\ncount__22317_23774 \x3d G__23805;\ni__22318_23775 \x3d G__23806;\ncontinue;\n}\n}\n} else {\n}\n}\nbreak;\n}\n} else {\nshadow.dom.append.cljs$core$IFn$_invoke$arity$2(node,children_23770);\n}\n\n\nvar G__23808 \x3d seq__22227_23755;\nvar G__23809 \x3d chunk__22228_23756;\nvar G__23810 \x3d count__22229_23757;\nvar G__23811 \x3d (i__22230_23758 + (1));\nseq__22227_23755 \x3d G__23808;\nchunk__22228_23756 \x3d G__23809;\ncount__22229_23757 \x3d G__23810;\ni__22230_23758 \x3d G__23811;\ncontinue;\n} else {\nvar temp__5804__auto___23812 \x3d cljs.core.seq(seq__22227_23755);\nif(temp__5804__auto___23812){\nvar seq__22227_23817__$1 \x3d temp__5804__auto___23812;\nif(cljs.core.chunked_seq_QMARK_(seq__22227_23817__$1)){\nvar c__5525__auto___23819 \x3d cljs.core.chunk_first(seq__22227_23817__$1);\nvar G__23821 \x3d cljs.core.chunk_rest(seq__22227_23817__$1);\nvar G__23822 \x3d c__5525__auto___23819;\nvar G__23823 \x3d cljs.core.count(c__5525__auto___23819);\nvar G__23824 \x3d (0);\nseq__22227_23755 \x3d G__23821;\nchunk__22228_23756 \x3d G__23822;\ncount__22229_23757 \x3d G__23823;\ni__22230_23758 \x3d G__23824;\ncontinue;\n} else {\nvar child_struct_23829 \x3d cljs.core.first(seq__22227_23817__$1);\nvar children_23830 \x3d shadow.dom.dom_node(child_struct_23829);\nif(cljs.core.seq_QMARK_(children_23830)){\nvar seq__22329_23831 \x3d cljs.core.seq(cljs.core.map.cljs$core$IFn$_invoke$arity$2(shadow.dom.dom_node,children_23830));\nvar chunk__22331_23832 \x3d null;\nvar count__22332_23833 \x3d (0);\nvar i__22333_23834 \x3d (0);\nwhile(true){\nif((i__22333_23834 \x3c count__22332_23833)){\nvar child_23837 \x3d chunk__22331_23832.cljs$core$IIndexed$_nth$arity$2(null, i__22333_23834);\nif(cljs.core.truth_(child_23837)){\nshadow.dom.append.cljs$core$IFn$_invoke$arity$2(node,child_23837);\n\n\nvar G__23839 \x3d seq__22329_23831;\nvar G__23840 \x3d chunk__22331_23832;\nvar G__23841 \x3d count__22332_23833;\nvar G__23842 \x3d (i__22333_23834 + (1));\nseq__22329_23831 \x3d G__23839;\nchunk__22331_23832 \x3d G__23840;\ncount__22332_23833 \x3d G__23841;\ni__22333_23834 \x3d G__23842;\ncontinue;\n} else {\nvar G__23843 \x3d seq__22329_23831;\nvar G__23844 \x3d chunk__22331_23832;\nvar G__23845 \x3d count__22332_23833;\nvar G__23846 \x3d (i__22333_23834 + (1));\nseq__22329_23831 \x3d G__23843;\nchunk__22331_23832 \x3d G__23844;\ncount__22332_23833 \x3d G__23845;\ni__22333_23834 \x3d G__23846;\ncontinue;\n}\n} else {\nvar temp__5804__auto___23847__$1 \x3d cljs.core.seq(seq__22329_23831);\nif(temp__5804__auto___23847__$1){\nvar seq__22329_23848__$1 \x3d temp__5804__auto___23847__$1;\nif(cljs.core.chunked_seq_QMARK_(seq__22329_23848__$1)){\nvar c__5525__auto___23849 \x3d cljs.core.chunk_first(seq__22329_23848__$1);\nvar G__23850 \x3d cljs.core.chunk_rest(seq__22329_23848__$1);\nvar G__23851 \x3d c__5525__auto___23849;\nvar G__23852 \x3d cljs.core.count(c__5525__auto___23849);\nvar G__23853 \x3d (0);\nseq__22329_23831 \x3d G__23850;\nchunk__22331_23832 \x3d G__23851;\ncount__22332_23833 \x3d G__23852;\ni__22333_23834 \x3d G__23853;\ncontinue;\n} else {\nvar child_23856 \x3d cljs.core.first(seq__22329_23848__$1);\nif(cljs.core.truth_(child_23856)){\nshadow.dom.append.cljs$core$IFn$_invoke$arity$2(node,child_23856);\n\n\nvar G__23860 \x3d cljs.core.next(seq__22329_23848__$1);\nvar G__23861 \x3d null;\nvar G__23862 \x3d (0);\nvar G__23863 \x3d (0);\nseq__22329_23831 \x3d G__23860;\nchunk__22331_23832 \x3d G__23861;\ncount__22332_23833 \x3d G__23862;\ni__22333_23834 \x3d G__23863;\ncontinue;\n} else {\nvar G__23866 \x3d cljs.core.next(seq__22329_23848__$1);\nvar G__23867 \x3d null;\nvar G__23868 \x3d (0);\nvar G__23869 \x3d (0);\nseq__22329_23831 \x3d G__23866;\nchunk__22331_23832 \x3d G__23867;\ncount__22332_23833 \x3d G__23868;\ni__22333_23834 \x3d G__23869;\ncontinue;\n}\n}\n} else {\n}\n}\nbreak;\n}\n} else {\nshadow.dom.append.cljs$core$IFn$_invoke$arity$2(node,children_23830);\n}\n\n\nvar G__23871 \x3d cljs.core.next(seq__22227_23817__$1);\nvar G__23872 \x3d null;\nvar G__23873 \x3d (0);\nvar G__23874 \x3d (0);\nseq__22227_23755 \x3d G__23871;\nchunk__22228_23756 \x3d G__23872;\ncount__22229_23757 \x3d G__23873;\ni__22230_23758 \x3d G__23874;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn node;\n});\n(cljs.core.Keyword.prototype.shadow$dom$IElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Keyword.prototype.shadow$dom$IElement$_to_dom$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn shadow.dom.make_dom_node(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [this$__$1], null));\n}));\n\n(cljs.core.PersistentVector.prototype.shadow$dom$IElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentVector.prototype.shadow$dom$IElement$_to_dom$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn shadow.dom.make_dom_node(this$__$1);\n}));\n\n(cljs.core.LazySeq.prototype.shadow$dom$IElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.LazySeq.prototype.shadow$dom$IElement$_to_dom$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2(shadow.dom._to_dom,this$__$1);\n}));\nif(cljs.core.truth_(((typeof HTMLElement) !\x3d \x27undefined\x27))){\n(HTMLElement.prototype.shadow$dom$IElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(HTMLElement.prototype.shadow$dom$IElement$_to_dom$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn this$__$1;\n}));\n} else {\n}\nif(cljs.core.truth_(((typeof DocumentFragment) !\x3d \x27undefined\x27))){\n(DocumentFragment.prototype.shadow$dom$IElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(DocumentFragment.prototype.shadow$dom$IElement$_to_dom$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn this$__$1;\n}));\n} else {\n}\n/**\n * clear node children\n */\nshadow.dom.reset \x3d (function shadow$dom$reset(node){\nreturn goog.dom.removeChildren(shadow.dom.dom_node(node));\n});\nshadow.dom.remove \x3d (function shadow$dom$remove(node){\nif((((!((node \x3d\x3d null))))?(((((node.cljs$lang$protocol_mask$partition0$ \x26 (8388608))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d node.cljs$core$ISeqable$))))?true:false):false)){\nvar seq__22376 \x3d cljs.core.seq(node);\nvar chunk__22377 \x3d null;\nvar count__22378 \x3d (0);\nvar i__22379 \x3d (0);\nwhile(true){\nif((i__22379 \x3c count__22378)){\nvar n \x3d chunk__22377.cljs$core$IIndexed$_nth$arity$2(null, i__22379);\n(shadow.dom.remove.cljs$core$IFn$_invoke$arity$1 ? shadow.dom.remove.cljs$core$IFn$_invoke$arity$1(n) : shadow.dom.remove.call(null, n));\n\n\nvar G__23880 \x3d seq__22376;\nvar G__23881 \x3d chunk__22377;\nvar G__23882 \x3d count__22378;\nvar G__23883 \x3d (i__22379 + (1));\nseq__22376 \x3d G__23880;\nchunk__22377 \x3d G__23881;\ncount__22378 \x3d G__23882;\ni__22379 \x3d G__23883;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__22376);\nif(temp__5804__auto__){\nvar seq__22376__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__22376__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__22376__$1);\nvar G__23884 \x3d cljs.core.chunk_rest(seq__22376__$1);\nvar G__23885 \x3d c__5525__auto__;\nvar G__23886 \x3d cljs.core.count(c__5525__auto__);\nvar G__23887 \x3d (0);\nseq__22376 \x3d G__23884;\nchunk__22377 \x3d G__23885;\ncount__22378 \x3d G__23886;\ni__22379 \x3d G__23887;\ncontinue;\n} else {\nvar n \x3d cljs.core.first(seq__22376__$1);\n(shadow.dom.remove.cljs$core$IFn$_invoke$arity$1 ? shadow.dom.remove.cljs$core$IFn$_invoke$arity$1(n) : shadow.dom.remove.call(null, n));\n\n\nvar G__23889 \x3d cljs.core.next(seq__22376__$1);\nvar G__23890 \x3d null;\nvar G__23891 \x3d (0);\nvar G__23892 \x3d (0);\nseq__22376 \x3d G__23889;\nchunk__22377 \x3d G__23890;\ncount__22378 \x3d G__23891;\ni__22379 \x3d G__23892;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n} else {\nreturn goog.dom.removeNode(node);\n}\n});\nshadow.dom.replace_node \x3d (function shadow$dom$replace_node(old,new$){\nreturn goog.dom.replaceNode(shadow.dom.dom_node(new$),shadow.dom.dom_node(old));\n});\nshadow.dom.text \x3d (function shadow$dom$text(var_args){\nvar G__22391 \x3d arguments.length;\nswitch (G__22391) {\ncase 2:\nreturn shadow.dom.text.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 1:\nreturn shadow.dom.text.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.text.cljs$core$IFn$_invoke$arity$2 \x3d (function (el,new_text){\nreturn (shadow.dom.dom_node(el).innerText \x3d new_text);\n}));\n\n(shadow.dom.text.cljs$core$IFn$_invoke$arity$1 \x3d (function (el){\nreturn shadow.dom.dom_node(el).innerText;\n}));\n\n(shadow.dom.text.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.check \x3d (function shadow$dom$check(var_args){\nvar G__22398 \x3d arguments.length;\nswitch (G__22398) {\ncase 1:\nreturn shadow.dom.check.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.dom.check.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.check.cljs$core$IFn$_invoke$arity$1 \x3d (function (el){\nreturn shadow.dom.check.cljs$core$IFn$_invoke$arity$2(el,true);\n}));\n\n(shadow.dom.check.cljs$core$IFn$_invoke$arity$2 \x3d (function (el,checked){\nreturn (shadow.dom.dom_node(el).checked \x3d checked);\n}));\n\n(shadow.dom.check.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.checked_QMARK_ \x3d (function shadow$dom$checked_QMARK_(el){\nreturn shadow.dom.dom_node(el).checked;\n});\nshadow.dom.form_elements \x3d (function shadow$dom$form_elements(el){\nreturn (new shadow.dom.NativeColl(shadow.dom.dom_node(el).elements));\n});\nshadow.dom.children \x3d (function shadow$dom$children(el){\nreturn (new shadow.dom.NativeColl(shadow.dom.dom_node(el).children));\n});\nshadow.dom.child_nodes \x3d (function shadow$dom$child_nodes(el){\nreturn (new shadow.dom.NativeColl(shadow.dom.dom_node(el).childNodes));\n});\nshadow.dom.attr \x3d (function shadow$dom$attr(var_args){\nvar G__22419 \x3d arguments.length;\nswitch (G__22419) {\ncase 2:\nreturn shadow.dom.attr.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn shadow.dom.attr.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.attr.cljs$core$IFn$_invoke$arity$2 \x3d (function (el,key){\nreturn shadow.dom.dom_node(el).getAttribute(cljs.core.name(key));\n}));\n\n(shadow.dom.attr.cljs$core$IFn$_invoke$arity$3 \x3d (function (el,key,default$){\nvar or__5002__auto__ \x3d shadow.dom.dom_node(el).getAttribute(cljs.core.name(key));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn default$;\n}\n}));\n\n(shadow.dom.attr.cljs$lang$maxFixedArity \x3d 3);\n\nshadow.dom.del_attr \x3d (function shadow$dom$del_attr(el,key){\nreturn shadow.dom.dom_node(el).removeAttribute(cljs.core.name(key));\n});\nshadow.dom.data \x3d (function shadow$dom$data(el,key){\nreturn shadow.dom.dom_node(el).getAttribute([\x22data-\x22,cljs.core.name(key)].join(\x27\x27));\n});\nshadow.dom.set_data \x3d (function shadow$dom$set_data(el,key,value){\nreturn shadow.dom.dom_node(el).setAttribute([\x22data-\x22,cljs.core.name(key)].join(\x27\x27),cljs.core.str.cljs$core$IFn$_invoke$arity$1(value));\n});\nshadow.dom.set_html \x3d (function shadow$dom$set_html(node,text){\nreturn (shadow.dom.dom_node(node).innerHTML \x3d text);\n});\nshadow.dom.get_html \x3d (function shadow$dom$get_html(node){\nreturn shadow.dom.dom_node(node).innerHTML;\n});\nshadow.dom.fragment \x3d (function shadow$dom$fragment(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23920 \x3d arguments.length;\nvar i__5727__auto___23921 \x3d (0);\nwhile(true){\nif((i__5727__auto___23921 \x3c len__5726__auto___23920)){\nargs__5732__auto__.push((arguments[i__5727__auto___23921]));\n\nvar G__23922 \x3d (i__5727__auto___23921 + (1));\ni__5727__auto___23921 \x3d G__23922;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn shadow.dom.fragment.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(shadow.dom.fragment.cljs$core$IFn$_invoke$arity$variadic \x3d (function (nodes){\nvar fragment \x3d document.createDocumentFragment();\nvar seq__22472_23923 \x3d cljs.core.seq(nodes);\nvar chunk__22473_23924 \x3d null;\nvar count__22474_23925 \x3d (0);\nvar i__22475_23926 \x3d (0);\nwhile(true){\nif((i__22475_23926 \x3c count__22474_23925)){\nvar node_23927 \x3d chunk__22473_23924.cljs$core$IIndexed$_nth$arity$2(null, i__22475_23926);\nfragment.appendChild(shadow.dom._to_dom(node_23927));\n\n\nvar G__23928 \x3d seq__22472_23923;\nvar G__23929 \x3d chunk__22473_23924;\nvar G__23930 \x3d count__22474_23925;\nvar G__23931 \x3d (i__22475_23926 + (1));\nseq__22472_23923 \x3d G__23928;\nchunk__22473_23924 \x3d G__23929;\ncount__22474_23925 \x3d G__23930;\ni__22475_23926 \x3d G__23931;\ncontinue;\n} else {\nvar temp__5804__auto___23932 \x3d cljs.core.seq(seq__22472_23923);\nif(temp__5804__auto___23932){\nvar seq__22472_23934__$1 \x3d temp__5804__auto___23932;\nif(cljs.core.chunked_seq_QMARK_(seq__22472_23934__$1)){\nvar c__5525__auto___23935 \x3d cljs.core.chunk_first(seq__22472_23934__$1);\nvar G__23936 \x3d cljs.core.chunk_rest(seq__22472_23934__$1);\nvar G__23937 \x3d c__5525__auto___23935;\nvar G__23938 \x3d cljs.core.count(c__5525__auto___23935);\nvar G__23939 \x3d (0);\nseq__22472_23923 \x3d G__23936;\nchunk__22473_23924 \x3d G__23937;\ncount__22474_23925 \x3d G__23938;\ni__22475_23926 \x3d G__23939;\ncontinue;\n} else {\nvar node_23940 \x3d cljs.core.first(seq__22472_23934__$1);\nfragment.appendChild(shadow.dom._to_dom(node_23940));\n\n\nvar G__23944 \x3d cljs.core.next(seq__22472_23934__$1);\nvar G__23945 \x3d null;\nvar G__23946 \x3d (0);\nvar G__23947 \x3d (0);\nseq__22472_23923 \x3d G__23944;\nchunk__22473_23924 \x3d G__23945;\ncount__22474_23925 \x3d G__23946;\ni__22475_23926 \x3d G__23947;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn (new shadow.dom.NativeColl(fragment));\n}));\n\n(shadow.dom.fragment.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(shadow.dom.fragment.cljs$lang$applyTo \x3d (function (seq22453){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22453));\n}));\n\n/**\n * given a html string, eval all \x3cscript\x3e tags and return the html without the scripts\n * don\x27t do this for everything, only content you trust.\n */\nshadow.dom.eval_scripts \x3d (function shadow$dom$eval_scripts(s){\nvar scripts \x3d cljs.core.re_seq(/\x3cscript[^\x3e]*?\x3e(.+?)\x3c\\/script\x3e/,s);\nvar seq__22533_23950 \x3d cljs.core.seq(scripts);\nvar chunk__22534_23951 \x3d null;\nvar count__22535_23952 \x3d (0);\nvar i__22536_23953 \x3d (0);\nwhile(true){\nif((i__22536_23953 \x3c count__22535_23952)){\nvar vec__22571_23954 \x3d chunk__22534_23951.cljs$core$IIndexed$_nth$arity$2(null, i__22536_23953);\nvar script_tag_23955 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22571_23954,(0),null);\nvar script_body_23956 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22571_23954,(1),null);\neval(script_body_23956);\n\n\nvar G__23958 \x3d seq__22533_23950;\nvar G__23959 \x3d chunk__22534_23951;\nvar G__23960 \x3d count__22535_23952;\nvar G__23961 \x3d (i__22536_23953 + (1));\nseq__22533_23950 \x3d G__23958;\nchunk__22534_23951 \x3d G__23959;\ncount__22535_23952 \x3d G__23960;\ni__22536_23953 \x3d G__23961;\ncontinue;\n} else {\nvar temp__5804__auto___23962 \x3d cljs.core.seq(seq__22533_23950);\nif(temp__5804__auto___23962){\nvar seq__22533_23963__$1 \x3d temp__5804__auto___23962;\nif(cljs.core.chunked_seq_QMARK_(seq__22533_23963__$1)){\nvar c__5525__auto___23964 \x3d cljs.core.chunk_first(seq__22533_23963__$1);\nvar G__23965 \x3d cljs.core.chunk_rest(seq__22533_23963__$1);\nvar G__23966 \x3d c__5525__auto___23964;\nvar G__23967 \x3d cljs.core.count(c__5525__auto___23964);\nvar G__23968 \x3d (0);\nseq__22533_23950 \x3d G__23965;\nchunk__22534_23951 \x3d G__23966;\ncount__22535_23952 \x3d G__23967;\ni__22536_23953 \x3d G__23968;\ncontinue;\n} else {\nvar vec__22590_23969 \x3d cljs.core.first(seq__22533_23963__$1);\nvar script_tag_23970 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22590_23969,(0),null);\nvar script_body_23971 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22590_23969,(1),null);\neval(script_body_23971);\n\n\nvar G__23972 \x3d cljs.core.next(seq__22533_23963__$1);\nvar G__23973 \x3d null;\nvar G__23974 \x3d (0);\nvar G__23975 \x3d (0);\nseq__22533_23950 \x3d G__23972;\nchunk__22534_23951 \x3d G__23973;\ncount__22535_23952 \x3d G__23974;\ni__22536_23953 \x3d G__23975;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (s__$1,p__22603){\nvar vec__22604 \x3d p__22603;\nvar script_tag \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22604,(0),null);\nvar script_body \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22604,(1),null);\nreturn clojure.string.replace(s__$1,script_tag,\x22\x22);\n}),s,scripts);\n});\nshadow.dom.str__GT_fragment \x3d (function shadow$dom$str__GT_fragment(s){\nvar el \x3d document.createElement(\x22div\x22);\n(el.innerHTML \x3d s);\n\nreturn (new shadow.dom.NativeColl(goog.dom.childrenToNode_(document,el)));\n});\nshadow.dom.node_name \x3d (function shadow$dom$node_name(el){\nreturn shadow.dom.dom_node(el).nodeName;\n});\nshadow.dom.ancestor_by_class \x3d (function shadow$dom$ancestor_by_class(el,cls){\nreturn goog.dom.getAncestorByClass(shadow.dom.dom_node(el),cls);\n});\nshadow.dom.ancestor_by_tag \x3d (function shadow$dom$ancestor_by_tag(var_args){\nvar G__22644 \x3d arguments.length;\nswitch (G__22644) {\ncase 2:\nreturn shadow.dom.ancestor_by_tag.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn shadow.dom.ancestor_by_tag.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.ancestor_by_tag.cljs$core$IFn$_invoke$arity$2 \x3d (function (el,tag){\nreturn goog.dom.getAncestorByTagNameAndClass(shadow.dom.dom_node(el),cljs.core.name(tag));\n}));\n\n(shadow.dom.ancestor_by_tag.cljs$core$IFn$_invoke$arity$3 \x3d (function (el,tag,cls){\nreturn goog.dom.getAncestorByTagNameAndClass(shadow.dom.dom_node(el),cljs.core.name(tag),cljs.core.name(cls));\n}));\n\n(shadow.dom.ancestor_by_tag.cljs$lang$maxFixedArity \x3d 3);\n\nshadow.dom.get_value \x3d (function shadow$dom$get_value(dom){\nreturn goog.dom.forms.getValue(shadow.dom.dom_node(dom));\n});\nshadow.dom.set_value \x3d (function shadow$dom$set_value(dom,value){\nreturn goog.dom.forms.setValue(shadow.dom.dom_node(dom),value);\n});\nshadow.dom.px \x3d (function shadow$dom$px(value){\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1((value | (0))),\x22px\x22].join(\x27\x27);\n});\nshadow.dom.pct \x3d (function shadow$dom$pct(value){\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(value),\x22%\x22].join(\x27\x27);\n});\nshadow.dom.remove_style_STAR_ \x3d (function shadow$dom$remove_style_STAR_(el,style){\nreturn el.style.removeProperty(cljs.core.name(style));\n});\nshadow.dom.remove_style \x3d (function shadow$dom$remove_style(el,style){\nvar el__$1 \x3d shadow.dom.dom_node(el);\nreturn shadow.dom.remove_style_STAR_(el__$1,style);\n});\nshadow.dom.remove_styles \x3d (function shadow$dom$remove_styles(el,style_keys){\nvar el__$1 \x3d shadow.dom.dom_node(el);\nvar seq__22708 \x3d cljs.core.seq(style_keys);\nvar chunk__22709 \x3d null;\nvar count__22710 \x3d (0);\nvar i__22711 \x3d (0);\nwhile(true){\nif((i__22711 \x3c count__22710)){\nvar it \x3d chunk__22709.cljs$core$IIndexed$_nth$arity$2(null, i__22711);\nshadow.dom.remove_style_STAR_(el__$1,it);\n\n\nvar G__24011 \x3d seq__22708;\nvar G__24012 \x3d chunk__22709;\nvar G__24013 \x3d count__22710;\nvar G__24014 \x3d (i__22711 + (1));\nseq__22708 \x3d G__24011;\nchunk__22709 \x3d G__24012;\ncount__22710 \x3d G__24013;\ni__22711 \x3d G__24014;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__22708);\nif(temp__5804__auto__){\nvar seq__22708__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__22708__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__22708__$1);\nvar G__24015 \x3d cljs.core.chunk_rest(seq__22708__$1);\nvar G__24016 \x3d c__5525__auto__;\nvar G__24017 \x3d cljs.core.count(c__5525__auto__);\nvar G__24018 \x3d (0);\nseq__22708 \x3d G__24015;\nchunk__22709 \x3d G__24016;\ncount__22710 \x3d G__24017;\ni__22711 \x3d G__24018;\ncontinue;\n} else {\nvar it \x3d cljs.core.first(seq__22708__$1);\nshadow.dom.remove_style_STAR_(el__$1,it);\n\n\nvar G__24019 \x3d cljs.core.next(seq__22708__$1);\nvar G__24020 \x3d null;\nvar G__24021 \x3d (0);\nvar G__24022 \x3d (0);\nseq__22708 \x3d G__24019;\nchunk__22709 \x3d G__24020;\ncount__22710 \x3d G__24021;\ni__22711 \x3d G__24022;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\nshadow.dom.Coordinate \x3d (function (x,y,__meta,__extmap,__hash){\nthis.x \x3d x;\nthis.y \x3d y;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(shadow.dom.Coordinate.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k22735,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__22747 \x3d k22735;\nvar G__22747__$1 \x3d (((G__22747 instanceof cljs.core.Keyword))?G__22747.fqn:null);\nswitch (G__22747__$1) {\ncase \x22x\x22:\nreturn self__.x;\n\nbreak;\ncase \x22y\x22:\nreturn self__.y;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k22735,else__5303__auto__);\n\n}\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__22748){\nvar vec__22749 \x3d p__22748;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22749,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22749,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#shadow.dom.Coordinate{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185),self__.x],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776),self__.y],null))], null),self__.__extmap));\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__22734){\nvar self__ \x3d this;\nvar G__22734__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__22734__$1,2,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185),new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new shadow.dom.Coordinate(self__.x,self__.y,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (2 + cljs.core.count(self__.__extmap));\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (145542109 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this22736,other22737){\nvar self__ \x3d this;\nvar this22736__$1 \x3d this;\nreturn (((!((other22737 \x3d\x3d null)))) \x26\x26 ((((this22736__$1.constructor \x3d\x3d\x3d other22737.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22736__$1.x,other22737.x)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22736__$1.y,other22737.y)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22736__$1.__extmap,other22737.__extmap)))))))));\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776),null,new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new shadow.dom.Coordinate(self__.x,self__.y,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k22735){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__22766 \x3d k22735;\nvar G__22766__$1 \x3d (((G__22766 instanceof cljs.core.Keyword))?G__22766.fqn:null);\nswitch (G__22766__$1) {\ncase \x22x\x22:\ncase \x22y\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k22735);\n\n}\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__22734){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__22767 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__22768 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__22767.cljs$core$IFn$_invoke$arity$2 ? pred__22767.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185),expr__22768) : pred__22767.call(null, new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185),expr__22768)))){\nreturn (new shadow.dom.Coordinate(G__22734,self__.y,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22767.cljs$core$IFn$_invoke$arity$2 ? pred__22767.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776),expr__22768) : pred__22767.call(null, new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776),expr__22768)))){\nreturn (new shadow.dom.Coordinate(self__.x,G__22734,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new shadow.dom.Coordinate(self__.x,self__.y,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__22734),null));\n}\n}\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185),self__.x,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776),self__.y,null))], null),self__.__extmap));\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__22734){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new shadow.dom.Coordinate(self__.x,self__.y,G__22734,self__.__extmap,self__.__hash));\n}));\n\n(shadow.dom.Coordinate.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(shadow.dom.Coordinate.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22x\x22,\x22x\x22,-555367584,null),new cljs.core.Symbol(null,\x22y\x22,\x22y\x22,-117328249,null)], null);\n}));\n\n(shadow.dom.Coordinate.cljs$lang$type \x3d true);\n\n(shadow.dom.Coordinate.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22shadow.dom/Coordinate\x22,null,(1),null));\n}));\n\n(shadow.dom.Coordinate.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22shadow.dom/Coordinate\x22);\n}));\n\n/**\n * Positional factory function for shadow.dom/Coordinate.\n */\nshadow.dom.__GT_Coordinate \x3d (function shadow$dom$__GT_Coordinate(x,y){\nreturn (new shadow.dom.Coordinate(x,y,null,null,null));\n});\n\n/**\n * Factory function for shadow.dom/Coordinate, taking a map of keywords to field values.\n */\nshadow.dom.map__GT_Coordinate \x3d (function shadow$dom$map__GT_Coordinate(G__22741){\nvar extmap__5342__auto__ \x3d (function (){var G__22777 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__22741,new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776)], 0));\nif(cljs.core.record_QMARK_(G__22741)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__22777);\n} else {\nreturn G__22777;\n}\n})();\nreturn (new shadow.dom.Coordinate(new cljs.core.Keyword(null,\x22x\x22,\x22x\x22,2099068185).cljs$core$IFn$_invoke$arity$1(G__22741),new cljs.core.Keyword(null,\x22y\x22,\x22y\x22,-1757859776).cljs$core$IFn$_invoke$arity$1(G__22741),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\nshadow.dom.get_position \x3d (function shadow$dom$get_position(el){\nvar pos \x3d goog.style.getPosition(shadow.dom.dom_node(el));\nreturn shadow.dom.__GT_Coordinate(pos.x,pos.y);\n});\nshadow.dom.get_client_position \x3d (function shadow$dom$get_client_position(el){\nvar pos \x3d goog.style.getClientPosition(shadow.dom.dom_node(el));\nreturn shadow.dom.__GT_Coordinate(pos.x,pos.y);\n});\nshadow.dom.get_page_offset \x3d (function shadow$dom$get_page_offset(el){\nvar pos \x3d goog.style.getPageOffset(shadow.dom.dom_node(el));\nreturn shadow.dom.__GT_Coordinate(pos.x,pos.y);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\nshadow.dom.Size \x3d (function (w,h,__meta,__extmap,__hash){\nthis.w \x3d w;\nthis.h \x3d h;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(shadow.dom.Size.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(shadow.dom.Size.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k22791,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__22812 \x3d k22791;\nvar G__22812__$1 \x3d (((G__22812 instanceof cljs.core.Keyword))?G__22812.fqn:null);\nswitch (G__22812__$1) {\ncase \x22w\x22:\nreturn self__.w;\n\nbreak;\ncase \x22h\x22:\nreturn self__.h;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k22791,else__5303__auto__);\n\n}\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__22819){\nvar vec__22821 \x3d p__22819;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22821,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22821,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#shadow.dom.Size{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),self__.w],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740),self__.h],null))], null),self__.__extmap));\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__22790){\nvar self__ \x3d this;\nvar G__22790__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__22790__$1,2,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(shadow.dom.Size.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new shadow.dom.Size(self__.w,self__.h,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(shadow.dom.Size.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (2 + cljs.core.count(self__.__extmap));\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (-1228019642 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this22792,other22793){\nvar self__ \x3d this;\nvar this22792__$1 \x3d this;\nreturn (((!((other22793 \x3d\x3d null)))) \x26\x26 ((((this22792__$1.constructor \x3d\x3d\x3d other22793.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22792__$1.w,other22793.w)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22792__$1.h,other22793.h)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22792__$1.__extmap,other22793.__extmap)))))))));\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),null,new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new shadow.dom.Size(self__.w,self__.h,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k22791){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__22864 \x3d k22791;\nvar G__22864__$1 \x3d (((G__22864 instanceof cljs.core.Keyword))?G__22864.fqn:null);\nswitch (G__22864__$1) {\ncase \x22w\x22:\ncase \x22h\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k22791);\n\n}\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__22790){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__22871 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__22872 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__22871.cljs$core$IFn$_invoke$arity$2 ? pred__22871.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),expr__22872) : pred__22871.call(null, new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),expr__22872)))){\nreturn (new shadow.dom.Size(G__22790,self__.h,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22871.cljs$core$IFn$_invoke$arity$2 ? pred__22871.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740),expr__22872) : pred__22871.call(null, new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740),expr__22872)))){\nreturn (new shadow.dom.Size(self__.w,G__22790,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new shadow.dom.Size(self__.w,self__.h,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__22790),null));\n}\n}\n}));\n\n(shadow.dom.Size.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),self__.w,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740),self__.h,null))], null),self__.__extmap));\n}));\n\n(shadow.dom.Size.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__22790){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new shadow.dom.Size(self__.w,self__.h,G__22790,self__.__extmap,self__.__hash));\n}));\n\n(shadow.dom.Size.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(shadow.dom.Size.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22w\x22,\x22w\x22,1994700528,null),new cljs.core.Symbol(null,\x22h\x22,\x22h\x22,-1544777029,null)], null);\n}));\n\n(shadow.dom.Size.cljs$lang$type \x3d true);\n\n(shadow.dom.Size.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22shadow.dom/Size\x22,null,(1),null));\n}));\n\n(shadow.dom.Size.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22shadow.dom/Size\x22);\n}));\n\n/**\n * Positional factory function for shadow.dom/Size.\n */\nshadow.dom.__GT_Size \x3d (function shadow$dom$__GT_Size(w,h){\nreturn (new shadow.dom.Size(w,h,null,null,null));\n});\n\n/**\n * Factory function for shadow.dom/Size, taking a map of keywords to field values.\n */\nshadow.dom.map__GT_Size \x3d (function shadow$dom$map__GT_Size(G__22794){\nvar extmap__5342__auto__ \x3d (function (){var G__22904 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__22794,new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740)], 0));\nif(cljs.core.record_QMARK_(G__22794)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__22904);\n} else {\nreturn G__22904;\n}\n})();\nreturn (new shadow.dom.Size(new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001).cljs$core$IFn$_invoke$arity$1(G__22794),new cljs.core.Keyword(null,\x22h\x22,\x22h\x22,1109658740).cljs$core$IFn$_invoke$arity$1(G__22794),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\nshadow.dom.size__GT_clj \x3d (function shadow$dom$size__GT_clj(size){\nreturn (new shadow.dom.Size(size.width,size.height,null,null,null));\n});\nshadow.dom.get_size \x3d (function shadow$dom$get_size(el){\nreturn shadow.dom.size__GT_clj(goog.style.getSize(shadow.dom.dom_node(el)));\n});\nshadow.dom.get_height \x3d (function shadow$dom$get_height(el){\nreturn shadow.dom.get_size(el).h;\n});\nshadow.dom.get_viewport_size \x3d (function shadow$dom$get_viewport_size(){\nreturn shadow.dom.size__GT_clj(goog.dom.getViewportSize());\n});\nshadow.dom.first_child \x3d (function shadow$dom$first_child(el){\nreturn (shadow.dom.dom_node(el).children[(0)]);\n});\nshadow.dom.select_option_values \x3d (function shadow$dom$select_option_values(el){\nvar native$ \x3d shadow.dom.dom_node(el);\nvar opts \x3d (native$[\x22options\x22]);\nvar a__5590__auto__ \x3d opts;\nvar l__5591__auto__ \x3d a__5590__auto__.length;\nvar i \x3d (0);\nvar ret \x3d cljs.core.PersistentVector.EMPTY;\nwhile(true){\nif((i \x3c l__5591__auto__)){\nvar G__24159 \x3d (i + (1));\nvar G__24160 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ret,(opts[i][\x22value\x22]));\ni \x3d G__24159;\nret \x3d G__24160;\ncontinue;\n} else {\nreturn ret;\n}\nbreak;\n}\n});\nshadow.dom.build_url \x3d (function shadow$dom$build_url(path,query_params){\nif(cljs.core.empty_QMARK_(query_params)){\nreturn path;\n} else {\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(path),\x22?\x22,clojure.string.join.cljs$core$IFn$_invoke$arity$2(\x22\x26\x22,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p__22961){\nvar vec__22962 \x3d p__22961;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22962,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22962,(1),null);\nreturn [cljs.core.name(k),\x22\x3d\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(encodeURIComponent(cljs.core.str.cljs$core$IFn$_invoke$arity$1(v)))].join(\x27\x27);\n}),query_params))].join(\x27\x27);\n}\n});\nshadow.dom.redirect \x3d (function shadow$dom$redirect(var_args){\nvar G__22970 \x3d arguments.length;\nswitch (G__22970) {\ncase 1:\nreturn shadow.dom.redirect.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.dom.redirect.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.dom.redirect.cljs$core$IFn$_invoke$arity$1 \x3d (function (path){\nreturn shadow.dom.redirect.cljs$core$IFn$_invoke$arity$2(path,cljs.core.PersistentArrayMap.EMPTY);\n}));\n\n(shadow.dom.redirect.cljs$core$IFn$_invoke$arity$2 \x3d (function (path,query_params){\nreturn (document[\x22location\x22][\x22href\x22] \x3d shadow.dom.build_url(path,query_params));\n}));\n\n(shadow.dom.redirect.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.dom.reload_BANG_ \x3d (function shadow$dom$reload_BANG_(){\nreturn (document.location.href \x3d document.location.href);\n});\nshadow.dom.tag_name \x3d (function shadow$dom$tag_name(el){\nvar dom \x3d shadow.dom.dom_node(el);\nreturn dom.tagName;\n});\nshadow.dom.insert_after \x3d (function shadow$dom$insert_after(ref,new$){\nvar new_node \x3d shadow.dom.dom_node(new$);\ngoog.dom.insertSiblingAfter(new_node,shadow.dom.dom_node(ref));\n\nreturn new_node;\n});\nshadow.dom.insert_before \x3d (function shadow$dom$insert_before(ref,new$){\nvar new_node \x3d shadow.dom.dom_node(new$);\ngoog.dom.insertSiblingBefore(new_node,shadow.dom.dom_node(ref));\n\nreturn new_node;\n});\nshadow.dom.insert_first \x3d (function shadow$dom$insert_first(ref,new$){\nvar temp__5802__auto__ \x3d shadow.dom.dom_node(ref).firstChild;\nif(cljs.core.truth_(temp__5802__auto__)){\nvar child \x3d temp__5802__auto__;\nreturn shadow.dom.insert_before(child,new$);\n} else {\nreturn shadow.dom.append.cljs$core$IFn$_invoke$arity$2(ref,new$);\n}\n});\nshadow.dom.index_of \x3d (function shadow$dom$index_of(el){\nvar el__$1 \x3d shadow.dom.dom_node(el);\nvar i \x3d (0);\nwhile(true){\nvar ps \x3d el__$1.previousSibling;\nif((ps \x3d\x3d null)){\nreturn i;\n} else {\nvar G__24181 \x3d ps;\nvar G__24182 \x3d (i + (1));\nel__$1 \x3d G__24181;\ni \x3d G__24182;\ncontinue;\n}\nbreak;\n}\n});\nshadow.dom.get_parent \x3d (function shadow$dom$get_parent(el){\nreturn goog.dom.getParentElement(shadow.dom.dom_node(el));\n});\nshadow.dom.parents \x3d (function shadow$dom$parents(el){\nvar parent \x3d shadow.dom.get_parent(el);\nif(cljs.core.truth_(parent)){\nreturn cljs.core.cons(parent,(new cljs.core.LazySeq(null,(function (){\nreturn (shadow.dom.parents.cljs$core$IFn$_invoke$arity$1 ? shadow.dom.parents.cljs$core$IFn$_invoke$arity$1(parent) : shadow.dom.parents.call(null, parent));\n}),null,null)));\n} else {\nreturn null;\n}\n});\nshadow.dom.matches \x3d (function shadow$dom$matches(el,sel){\nreturn shadow.dom.dom_node(el).matches(sel);\n});\nshadow.dom.get_next_sibling \x3d (function shadow$dom$get_next_sibling(el){\nreturn goog.dom.getNextElementSibling(shadow.dom.dom_node(el));\n});\nshadow.dom.get_previous_sibling \x3d (function shadow$dom$get_previous_sibling(el){\nreturn goog.dom.getPreviousElementSibling(shadow.dom.dom_node(el));\n});\nshadow.dom.xmlns \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentArrayMap(null, 2, [\x22svg\x22,\x22http://www.w3.org/2000/svg\x22,\x22xlink\x22,\x22http://www.w3.org/1999/xlink\x22], null));\nshadow.dom.create_svg_node \x3d (function shadow$dom$create_svg_node(tag_def,props){\nvar vec__23058 \x3d shadow.dom.parse_tag(tag_def);\nvar tag_name \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23058,(0),null);\nvar tag_id \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23058,(1),null);\nvar tag_classes \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23058,(2),null);\nvar el \x3d document.createElementNS(\x22http://www.w3.org/2000/svg\x22,tag_name);\nif(cljs.core.truth_(tag_id)){\nel.setAttribute(\x22id\x22,tag_id);\n} else {\n}\n\nif(cljs.core.truth_(tag_classes)){\nel.setAttribute(\x22class\x22,shadow.dom.merge_class_string(new cljs.core.Keyword(null,\x22class\x22,\x22class\x22,-2030961996).cljs$core$IFn$_invoke$arity$1(props),tag_classes));\n} else {\n}\n\nvar seq__23072_24190 \x3d cljs.core.seq(props);\nvar chunk__23073_24191 \x3d null;\nvar count__23074_24192 \x3d (0);\nvar i__23075_24193 \x3d (0);\nwhile(true){\nif((i__23075_24193 \x3c count__23074_24192)){\nvar vec__23108_24196 \x3d chunk__23073_24191.cljs$core$IIndexed$_nth$arity$2(null, i__23075_24193);\nvar k_24197 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23108_24196,(0),null);\nvar v_24198 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23108_24196,(1),null);\nel.setAttributeNS((function (){var temp__5804__auto__ \x3d cljs.core.namespace(k_24197);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar ns \x3d temp__5804__auto__;\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.dom.xmlns),ns);\n} else {\nreturn null;\n}\n})(),cljs.core.name(k_24197),v_24198);\n\n\nvar G__24201 \x3d seq__23072_24190;\nvar G__24202 \x3d chunk__23073_24191;\nvar G__24203 \x3d count__23074_24192;\nvar G__24204 \x3d (i__23075_24193 + (1));\nseq__23072_24190 \x3d G__24201;\nchunk__23073_24191 \x3d G__24202;\ncount__23074_24192 \x3d G__24203;\ni__23075_24193 \x3d G__24204;\ncontinue;\n} else {\nvar temp__5804__auto___24205 \x3d cljs.core.seq(seq__23072_24190);\nif(temp__5804__auto___24205){\nvar seq__23072_24206__$1 \x3d temp__5804__auto___24205;\nif(cljs.core.chunked_seq_QMARK_(seq__23072_24206__$1)){\nvar c__5525__auto___24207 \x3d cljs.core.chunk_first(seq__23072_24206__$1);\nvar G__24208 \x3d cljs.core.chunk_rest(seq__23072_24206__$1);\nvar G__24209 \x3d c__5525__auto___24207;\nvar G__24210 \x3d cljs.core.count(c__5525__auto___24207);\nvar G__24211 \x3d (0);\nseq__23072_24190 \x3d G__24208;\nchunk__23073_24191 \x3d G__24209;\ncount__23074_24192 \x3d G__24210;\ni__23075_24193 \x3d G__24211;\ncontinue;\n} else {\nvar vec__23129_24212 \x3d cljs.core.first(seq__23072_24206__$1);\nvar k_24213 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23129_24212,(0),null);\nvar v_24214 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23129_24212,(1),null);\nel.setAttributeNS((function (){var temp__5804__auto____$1 \x3d cljs.core.namespace(k_24213);\nif(cljs.core.truth_(temp__5804__auto____$1)){\nvar ns \x3d temp__5804__auto____$1;\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.dom.xmlns),ns);\n} else {\nreturn null;\n}\n})(),cljs.core.name(k_24213),v_24214);\n\n\nvar G__24216 \x3d cljs.core.next(seq__23072_24206__$1);\nvar G__24217 \x3d null;\nvar G__24218 \x3d (0);\nvar G__24219 \x3d (0);\nseq__23072_24190 \x3d G__24216;\nchunk__23073_24191 \x3d G__24217;\ncount__23074_24192 \x3d G__24218;\ni__23075_24193 \x3d G__24219;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn el;\n});\nshadow.dom.svg_node \x3d (function shadow$dom$svg_node(el){\nif((el \x3d\x3d null)){\nreturn null;\n} else {\nif((((!((el \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d el.shadow$dom$SVGElement$))))?true:false):false)){\nreturn el.shadow$dom$SVGElement$_to_svg$arity$1(null, );\n} else {\nreturn el;\n\n}\n}\n});\nshadow.dom.make_svg_node \x3d (function shadow$dom$make_svg_node(structure){\nvar vec__23155 \x3d shadow.dom.destructure_node(shadow.dom.create_svg_node,structure);\nvar node \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23155,(0),null);\nvar node_children \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23155,(1),null);\nvar seq__23161_24221 \x3d cljs.core.seq(node_children);\nvar chunk__23163_24222 \x3d null;\nvar count__23164_24223 \x3d (0);\nvar i__23165_24224 \x3d (0);\nwhile(true){\nif((i__23165_24224 \x3c count__23164_24223)){\nvar child_struct_24225 \x3d chunk__23163_24222.cljs$core$IIndexed$_nth$arity$2(null, i__23165_24224);\nif((!((child_struct_24225 \x3d\x3d null)))){\nif(typeof child_struct_24225 \x3d\x3d\x3d \x27string\x27){\nvar text_24226 \x3d (node[\x22textContent\x22]);\n(node[\x22textContent\x22] \x3d [cljs.core.str.cljs$core$IFn$_invoke$arity$1(text_24226),child_struct_24225].join(\x27\x27));\n} else {\nvar children_24229 \x3d shadow.dom.svg_node(child_struct_24225);\nif(cljs.core.seq_QMARK_(children_24229)){\nvar seq__23279_24230 \x3d cljs.core.seq(children_24229);\nvar chunk__23281_24231 \x3d null;\nvar count__23282_24232 \x3d (0);\nvar i__23283_24233 \x3d (0);\nwhile(true){\nif((i__23283_24233 \x3c count__23282_24232)){\nvar child_24236 \x3d chunk__23281_24231.cljs$core$IIndexed$_nth$arity$2(null, i__23283_24233);\nif(cljs.core.truth_(child_24236)){\nnode.appendChild(child_24236);\n\n\nvar G__24237 \x3d seq__23279_24230;\nvar G__24238 \x3d chunk__23281_24231;\nvar G__24239 \x3d count__23282_24232;\nvar G__24240 \x3d (i__23283_24233 + (1));\nseq__23279_24230 \x3d G__24237;\nchunk__23281_24231 \x3d G__24238;\ncount__23282_24232 \x3d G__24239;\ni__23283_24233 \x3d G__24240;\ncontinue;\n} else {\nvar G__24241 \x3d seq__23279_24230;\nvar G__24242 \x3d chunk__23281_24231;\nvar G__24243 \x3d count__23282_24232;\nvar G__24244 \x3d (i__23283_24233 + (1));\nseq__23279_24230 \x3d G__24241;\nchunk__23281_24231 \x3d G__24242;\ncount__23282_24232 \x3d G__24243;\ni__23283_24233 \x3d G__24244;\ncontinue;\n}\n} else {\nvar temp__5804__auto___24246 \x3d cljs.core.seq(seq__23279_24230);\nif(temp__5804__auto___24246){\nvar seq__23279_24249__$1 \x3d temp__5804__auto___24246;\nif(cljs.core.chunked_seq_QMARK_(seq__23279_24249__$1)){\nvar c__5525__auto___24250 \x3d cljs.core.chunk_first(seq__23279_24249__$1);\nvar G__24252 \x3d cljs.core.chunk_rest(seq__23279_24249__$1);\nvar G__24253 \x3d c__5525__auto___24250;\nvar G__24254 \x3d cljs.core.count(c__5525__auto___24250);\nvar G__24255 \x3d (0);\nseq__23279_24230 \x3d G__24252;\nchunk__23281_24231 \x3d G__24253;\ncount__23282_24232 \x3d G__24254;\ni__23283_24233 \x3d G__24255;\ncontinue;\n} else {\nvar child_24256 \x3d cljs.core.first(seq__23279_24249__$1);\nif(cljs.core.truth_(child_24256)){\nnode.appendChild(child_24256);\n\n\nvar G__24259 \x3d cljs.core.next(seq__23279_24249__$1);\nvar G__24260 \x3d null;\nvar G__24261 \x3d (0);\nvar G__24262 \x3d (0);\nseq__23279_24230 \x3d G__24259;\nchunk__23281_24231 \x3d G__24260;\ncount__23282_24232 \x3d G__24261;\ni__23283_24233 \x3d G__24262;\ncontinue;\n} else {\nvar G__24263 \x3d cljs.core.next(seq__23279_24249__$1);\nvar G__24264 \x3d null;\nvar G__24265 \x3d (0);\nvar G__24266 \x3d (0);\nseq__23279_24230 \x3d G__24263;\nchunk__23281_24231 \x3d G__24264;\ncount__23282_24232 \x3d G__24265;\ni__23283_24233 \x3d G__24266;\ncontinue;\n}\n}\n} else {\n}\n}\nbreak;\n}\n} else {\nnode.appendChild(children_24229);\n}\n}\n\n\nvar G__24269 \x3d seq__23161_24221;\nvar G__24270 \x3d chunk__23163_24222;\nvar G__24271 \x3d count__23164_24223;\nvar G__24272 \x3d (i__23165_24224 + (1));\nseq__23161_24221 \x3d G__24269;\nchunk__23163_24222 \x3d G__24270;\ncount__23164_24223 \x3d G__24271;\ni__23165_24224 \x3d G__24272;\ncontinue;\n} else {\nvar G__24279 \x3d seq__23161_24221;\nvar G__24280 \x3d chunk__23163_24222;\nvar G__24281 \x3d count__23164_24223;\nvar G__24282 \x3d (i__23165_24224 + (1));\nseq__23161_24221 \x3d G__24279;\nchunk__23163_24222 \x3d G__24280;\ncount__23164_24223 \x3d G__24281;\ni__23165_24224 \x3d G__24282;\ncontinue;\n}\n} else {\nvar temp__5804__auto___24283 \x3d cljs.core.seq(seq__23161_24221);\nif(temp__5804__auto___24283){\nvar seq__23161_24291__$1 \x3d temp__5804__auto___24283;\nif(cljs.core.chunked_seq_QMARK_(seq__23161_24291__$1)){\nvar c__5525__auto___24293 \x3d cljs.core.chunk_first(seq__23161_24291__$1);\nvar G__24296 \x3d cljs.core.chunk_rest(seq__23161_24291__$1);\nvar G__24297 \x3d c__5525__auto___24293;\nvar G__24298 \x3d cljs.core.count(c__5525__auto___24293);\nvar G__24299 \x3d (0);\nseq__23161_24221 \x3d G__24296;\nchunk__23163_24222 \x3d G__24297;\ncount__23164_24223 \x3d G__24298;\ni__23165_24224 \x3d G__24299;\ncontinue;\n} else {\nvar child_struct_24306 \x3d cljs.core.first(seq__23161_24291__$1);\nif((!((child_struct_24306 \x3d\x3d null)))){\nif(typeof child_struct_24306 \x3d\x3d\x3d \x27string\x27){\nvar text_24310 \x3d (node[\x22textContent\x22]);\n(node[\x22textContent\x22] \x3d [cljs.core.str.cljs$core$IFn$_invoke$arity$1(text_24310),child_struct_24306].join(\x27\x27));\n} else {\nvar children_24317 \x3d shadow.dom.svg_node(child_struct_24306);\nif(cljs.core.seq_QMARK_(children_24317)){\nvar seq__23333_24319 \x3d cljs.core.seq(children_24317);\nvar chunk__23335_24320 \x3d null;\nvar count__23336_24321 \x3d (0);\nvar i__23337_24322 \x3d (0);\nwhile(true){\nif((i__23337_24322 \x3c count__23336_24321)){\nvar child_24328 \x3d chunk__23335_24320.cljs$core$IIndexed$_nth$arity$2(null, i__23337_24322);\nif(cljs.core.truth_(child_24328)){\nnode.appendChild(child_24328);\n\n\nvar G__24333 \x3d seq__23333_24319;\nvar G__24334 \x3d chunk__23335_24320;\nvar G__24335 \x3d count__23336_24321;\nvar G__24336 \x3d (i__23337_24322 + (1));\nseq__23333_24319 \x3d G__24333;\nchunk__23335_24320 \x3d G__24334;\ncount__23336_24321 \x3d G__24335;\ni__23337_24322 \x3d G__24336;\ncontinue;\n} else {\nvar G__24337 \x3d seq__23333_24319;\nvar G__24338 \x3d chunk__23335_24320;\nvar G__24339 \x3d count__23336_24321;\nvar G__24340 \x3d (i__23337_24322 + (1));\nseq__23333_24319 \x3d G__24337;\nchunk__23335_24320 \x3d G__24338;\ncount__23336_24321 \x3d G__24339;\ni__23337_24322 \x3d G__24340;\ncontinue;\n}\n} else {\nvar temp__5804__auto___24343__$1 \x3d cljs.core.seq(seq__23333_24319);\nif(temp__5804__auto___24343__$1){\nvar seq__23333_24344__$1 \x3d temp__5804__auto___24343__$1;\nif(cljs.core.chunked_seq_QMARK_(seq__23333_24344__$1)){\nvar c__5525__auto___24347 \x3d cljs.core.chunk_first(seq__23333_24344__$1);\nvar G__24348 \x3d cljs.core.chunk_rest(seq__23333_24344__$1);\nvar G__24349 \x3d c__5525__auto___24347;\nvar G__24350 \x3d cljs.core.count(c__5525__auto___24347);\nvar G__24351 \x3d (0);\nseq__23333_24319 \x3d G__24348;\nchunk__23335_24320 \x3d G__24349;\ncount__23336_24321 \x3d G__24350;\ni__23337_24322 \x3d G__24351;\ncontinue;\n} else {\nvar child_24354 \x3d cljs.core.first(seq__23333_24344__$1);\nif(cljs.core.truth_(child_24354)){\nnode.appendChild(child_24354);\n\n\nvar G__24358 \x3d cljs.core.next(seq__23333_24344__$1);\nvar G__24359 \x3d null;\nvar G__24360 \x3d (0);\nvar G__24361 \x3d (0);\nseq__23333_24319 \x3d G__24358;\nchunk__23335_24320 \x3d G__24359;\ncount__23336_24321 \x3d G__24360;\ni__23337_24322 \x3d G__24361;\ncontinue;\n} else {\nvar G__24367 \x3d cljs.core.next(seq__23333_24344__$1);\nvar G__24368 \x3d null;\nvar G__24369 \x3d (0);\nvar G__24370 \x3d (0);\nseq__23333_24319 \x3d G__24367;\nchunk__23335_24320 \x3d G__24368;\ncount__23336_24321 \x3d G__24369;\ni__23337_24322 \x3d G__24370;\ncontinue;\n}\n}\n} else {\n}\n}\nbreak;\n}\n} else {\nnode.appendChild(children_24317);\n}\n}\n\n\nvar G__24398 \x3d cljs.core.next(seq__23161_24291__$1);\nvar G__24399 \x3d null;\nvar G__24400 \x3d (0);\nvar G__24401 \x3d (0);\nseq__23161_24221 \x3d G__24398;\nchunk__23163_24222 \x3d G__24399;\ncount__23164_24223 \x3d G__24400;\ni__23165_24224 \x3d G__24401;\ncontinue;\n} else {\nvar G__24402 \x3d cljs.core.next(seq__23161_24291__$1);\nvar G__24403 \x3d null;\nvar G__24404 \x3d (0);\nvar G__24405 \x3d (0);\nseq__23161_24221 \x3d G__24402;\nchunk__23163_24222 \x3d G__24403;\ncount__23164_24223 \x3d G__24404;\ni__23165_24224 \x3d G__24405;\ncontinue;\n}\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn node;\n});\n(shadow.dom.SVGElement[\x22string\x22] \x3d true);\n\n(shadow.dom._to_svg[\x22string\x22] \x3d (function (this$){\nif((this$ instanceof cljs.core.Keyword)){\nreturn shadow.dom.make_svg_node(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [this$], null));\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22strings cannot be in svgs\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22this\x22,\x22this\x22,-611633625),this$], null));\n}\n}));\n\n(cljs.core.PersistentVector.prototype.shadow$dom$SVGElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentVector.prototype.shadow$dom$SVGElement$_to_svg$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn shadow.dom.make_svg_node(this$__$1);\n}));\n\n(cljs.core.LazySeq.prototype.shadow$dom$SVGElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.LazySeq.prototype.shadow$dom$SVGElement$_to_svg$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2(shadow.dom._to_svg,this$__$1);\n}));\n\n(shadow.dom.SVGElement[\x22null\x22] \x3d true);\n\n(shadow.dom._to_svg[\x22null\x22] \x3d (function (_){\nreturn null;\n}));\nshadow.dom.svg \x3d (function shadow$dom$svg(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___24443 \x3d arguments.length;\nvar i__5727__auto___24445 \x3d (0);\nwhile(true){\nif((i__5727__auto___24445 \x3c len__5726__auto___24443)){\nargs__5732__auto__.push((arguments[i__5727__auto___24445]));\n\nvar G__24449 \x3d (i__5727__auto___24445 + (1));\ni__5727__auto___24445 \x3d G__24449;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn shadow.dom.svg.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(shadow.dom.svg.cljs$core$IFn$_invoke$arity$variadic \x3d (function (attrs,children){\nreturn shadow.dom._to_svg(cljs.core.vec(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22svg\x22,\x22svg\x22,856789142),attrs], null),children)));\n}));\n\n(shadow.dom.svg.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(shadow.dom.svg.cljs$lang$applyTo \x3d (function (seq23402){\nvar G__23403 \x3d cljs.core.first(seq23402);\nvar seq23402__$1 \x3d cljs.core.next(seq23402);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__23403,seq23402__$1);\n}));\n\n");
SHADOW_ENV.evalLoad("cljs.core.async.impl.protocols.js", true, "goog.provide(\x27cljs.core.async.impl.protocols\x27);\ncljs.core.async.impl.protocols.MAX_QUEUE_SIZE \x3d (1024);\n\n/**\n * @interface\n */\ncljs.core.async.impl.protocols.ReadPort \x3d function(){};\n\nvar cljs$core$async$impl$protocols$ReadPort$take_BANG_$dyn_19810 \x3d (function (port,fn1_handler){\nvar x__5350__auto__ \x3d (((port \x3d\x3d null))?null:port);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.take_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(port,fn1_handler) : m__5351__auto__.call(null, port,fn1_handler));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.take_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(port,fn1_handler) : m__5349__auto__.call(null, port,fn1_handler));\n} else {\nthrow cljs.core.missing_protocol(\x22ReadPort.take!\x22,port);\n}\n}\n});\n/**\n * derefable val if taken, nil if take was enqueued\n */\ncljs.core.async.impl.protocols.take_BANG_ \x3d (function cljs$core$async$impl$protocols$take_BANG_(port,fn1_handler){\nif((((!((port \x3d\x3d null)))) \x26\x26 ((!((port.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2 \x3d\x3d null)))))){\nreturn port.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2(port,fn1_handler);\n} else {\nreturn cljs$core$async$impl$protocols$ReadPort$take_BANG_$dyn_19810(port,fn1_handler);\n}\n});\n\n\n/**\n * @interface\n */\ncljs.core.async.impl.protocols.WritePort \x3d function(){};\n\nvar cljs$core$async$impl$protocols$WritePort$put_BANG_$dyn_19813 \x3d (function (port,val,fn1_handler){\nvar x__5350__auto__ \x3d (((port \x3d\x3d null))?null:port);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.put_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(port,val,fn1_handler) : m__5351__auto__.call(null, port,val,fn1_handler));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.put_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(port,val,fn1_handler) : m__5349__auto__.call(null, port,val,fn1_handler));\n} else {\nthrow cljs.core.missing_protocol(\x22WritePort.put!\x22,port);\n}\n}\n});\n/**\n * derefable boolean (false if already closed) if handled, nil if put was enqueued.\n *                             Must throw on nil val.\n */\ncljs.core.async.impl.protocols.put_BANG_ \x3d (function cljs$core$async$impl$protocols$put_BANG_(port,val,fn1_handler){\nif((((!((port \x3d\x3d null)))) \x26\x26 ((!((port.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3 \x3d\x3d null)))))){\nreturn port.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3(port,val,fn1_handler);\n} else {\nreturn cljs$core$async$impl$protocols$WritePort$put_BANG_$dyn_19813(port,val,fn1_handler);\n}\n});\n\n\n/**\n * @interface\n */\ncljs.core.async.impl.protocols.Channel \x3d function(){};\n\nvar cljs$core$async$impl$protocols$Channel$close_BANG_$dyn_19819 \x3d (function (chan){\nvar x__5350__auto__ \x3d (((chan \x3d\x3d null))?null:chan);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.close_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(chan) : m__5351__auto__.call(null, chan));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.close_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(chan) : m__5349__auto__.call(null, chan));\n} else {\nthrow cljs.core.missing_protocol(\x22Channel.close!\x22,chan);\n}\n}\n});\ncljs.core.async.impl.protocols.close_BANG_ \x3d (function cljs$core$async$impl$protocols$close_BANG_(chan){\nif((((!((chan \x3d\x3d null)))) \x26\x26 ((!((chan.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1 \x3d\x3d null)))))){\nreturn chan.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1(chan);\n} else {\nreturn cljs$core$async$impl$protocols$Channel$close_BANG_$dyn_19819(chan);\n}\n});\n\nvar cljs$core$async$impl$protocols$Channel$closed_QMARK_$dyn_19831 \x3d (function (chan){\nvar x__5350__auto__ \x3d (((chan \x3d\x3d null))?null:chan);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.closed_QMARK_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(chan) : m__5351__auto__.call(null, chan));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.closed_QMARK_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(chan) : m__5349__auto__.call(null, chan));\n} else {\nthrow cljs.core.missing_protocol(\x22Channel.closed?\x22,chan);\n}\n}\n});\ncljs.core.async.impl.protocols.closed_QMARK_ \x3d (function cljs$core$async$impl$protocols$closed_QMARK_(chan){\nif((((!((chan \x3d\x3d null)))) \x26\x26 ((!((chan.cljs$core$async$impl$protocols$Channel$closed_QMARK_$arity$1 \x3d\x3d null)))))){\nreturn chan.cljs$core$async$impl$protocols$Channel$closed_QMARK_$arity$1(chan);\n} else {\nreturn cljs$core$async$impl$protocols$Channel$closed_QMARK_$dyn_19831(chan);\n}\n});\n\n\n/**\n * @interface\n */\ncljs.core.async.impl.protocols.Handler \x3d function(){};\n\nvar cljs$core$async$impl$protocols$Handler$active_QMARK_$dyn_19841 \x3d (function (h){\nvar x__5350__auto__ \x3d (((h \x3d\x3d null))?null:h);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.active_QMARK_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(h) : m__5351__auto__.call(null, h));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.active_QMARK_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(h) : m__5349__auto__.call(null, h));\n} else {\nthrow cljs.core.missing_protocol(\x22Handler.active?\x22,h);\n}\n}\n});\n/**\n * returns true if has callback. Must work w/o lock\n */\ncljs.core.async.impl.protocols.active_QMARK_ \x3d (function cljs$core$async$impl$protocols$active_QMARK_(h){\nif((((!((h \x3d\x3d null)))) \x26\x26 ((!((h.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1 \x3d\x3d null)))))){\nreturn h.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(h);\n} else {\nreturn cljs$core$async$impl$protocols$Handler$active_QMARK_$dyn_19841(h);\n}\n});\n\nvar cljs$core$async$impl$protocols$Handler$blockable_QMARK_$dyn_19849 \x3d (function (h){\nvar x__5350__auto__ \x3d (((h \x3d\x3d null))?null:h);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.blockable_QMARK_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(h) : m__5351__auto__.call(null, h));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.blockable_QMARK_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(h) : m__5349__auto__.call(null, h));\n} else {\nthrow cljs.core.missing_protocol(\x22Handler.blockable?\x22,h);\n}\n}\n});\n/**\n * returns true if this handler may be blocked, otherwise it must not block\n */\ncljs.core.async.impl.protocols.blockable_QMARK_ \x3d (function cljs$core$async$impl$protocols$blockable_QMARK_(h){\nif((((!((h \x3d\x3d null)))) \x26\x26 ((!((h.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1 \x3d\x3d null)))))){\nreturn h.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1(h);\n} else {\nreturn cljs$core$async$impl$protocols$Handler$blockable_QMARK_$dyn_19849(h);\n}\n});\n\nvar cljs$core$async$impl$protocols$Handler$commit$dyn_19856 \x3d (function (h){\nvar x__5350__auto__ \x3d (((h \x3d\x3d null))?null:h);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.commit[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(h) : m__5351__auto__.call(null, h));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.commit[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(h) : m__5349__auto__.call(null, h));\n} else {\nthrow cljs.core.missing_protocol(\x22Handler.commit\x22,h);\n}\n}\n});\n/**\n * commit to fulfilling its end of the transfer, returns cb. Must be called within lock\n */\ncljs.core.async.impl.protocols.commit \x3d (function cljs$core$async$impl$protocols$commit(h){\nif((((!((h \x3d\x3d null)))) \x26\x26 ((!((h.cljs$core$async$impl$protocols$Handler$commit$arity$1 \x3d\x3d null)))))){\nreturn h.cljs$core$async$impl$protocols$Handler$commit$arity$1(h);\n} else {\nreturn cljs$core$async$impl$protocols$Handler$commit$dyn_19856(h);\n}\n});\n\n\n/**\n * @interface\n */\ncljs.core.async.impl.protocols.Buffer \x3d function(){};\n\nvar cljs$core$async$impl$protocols$Buffer$full_QMARK_$dyn_19863 \x3d (function (b){\nvar x__5350__auto__ \x3d (((b \x3d\x3d null))?null:b);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.full_QMARK_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(b) : m__5351__auto__.call(null, b));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.full_QMARK_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(b) : m__5349__auto__.call(null, b));\n} else {\nthrow cljs.core.missing_protocol(\x22Buffer.full?\x22,b);\n}\n}\n});\n/**\n * returns true if buffer cannot accept put\n */\ncljs.core.async.impl.protocols.full_QMARK_ \x3d (function cljs$core$async$impl$protocols$full_QMARK_(b){\nif((((!((b \x3d\x3d null)))) \x26\x26 ((!((b.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1 \x3d\x3d null)))))){\nreturn b.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1(b);\n} else {\nreturn cljs$core$async$impl$protocols$Buffer$full_QMARK_$dyn_19863(b);\n}\n});\n\nvar cljs$core$async$impl$protocols$Buffer$remove_BANG_$dyn_19881 \x3d (function (b){\nvar x__5350__auto__ \x3d (((b \x3d\x3d null))?null:b);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.remove_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(b) : m__5351__auto__.call(null, b));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.remove_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(b) : m__5349__auto__.call(null, b));\n} else {\nthrow cljs.core.missing_protocol(\x22Buffer.remove!\x22,b);\n}\n}\n});\n/**\n * remove and return next item from buffer, called under chan mutex\n */\ncljs.core.async.impl.protocols.remove_BANG_ \x3d (function cljs$core$async$impl$protocols$remove_BANG_(b){\nif((((!((b \x3d\x3d null)))) \x26\x26 ((!((b.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1 \x3d\x3d null)))))){\nreturn b.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1(b);\n} else {\nreturn cljs$core$async$impl$protocols$Buffer$remove_BANG_$dyn_19881(b);\n}\n});\n\nvar cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$dyn_19900 \x3d (function (b,itm){\nvar x__5350__auto__ \x3d (((b \x3d\x3d null))?null:b);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.add_BANG__STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(b,itm) : m__5351__auto__.call(null, b,itm));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.add_BANG__STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(b,itm) : m__5349__auto__.call(null, b,itm));\n} else {\nthrow cljs.core.missing_protocol(\x22Buffer.add!*\x22,b);\n}\n}\n});\n/**\n * if room, add item to the buffer, returns b, called under chan mutex\n */\ncljs.core.async.impl.protocols.add_BANG__STAR_ \x3d (function cljs$core$async$impl$protocols$add_BANG__STAR_(b,itm){\nif((((!((b \x3d\x3d null)))) \x26\x26 ((!((b.cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$arity$2 \x3d\x3d null)))))){\nreturn b.cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$arity$2(b,itm);\n} else {\nreturn cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$dyn_19900(b,itm);\n}\n});\n\nvar cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$dyn_19912 \x3d (function (b){\nvar x__5350__auto__ \x3d (((b \x3d\x3d null))?null:b);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.protocols.close_buf_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(b) : m__5351__auto__.call(null, b));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.protocols.close_buf_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(b) : m__5349__auto__.call(null, b));\n} else {\nthrow cljs.core.missing_protocol(\x22Buffer.close-buf!\x22,b);\n}\n}\n});\n/**\n * called on chan closed under chan mutex, return ignored\n */\ncljs.core.async.impl.protocols.close_buf_BANG_ \x3d (function cljs$core$async$impl$protocols$close_buf_BANG_(b){\nif((((!((b \x3d\x3d null)))) \x26\x26 ((!((b.cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$arity$1 \x3d\x3d null)))))){\nreturn b.cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$arity$1(b);\n} else {\nreturn cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$dyn_19912(b);\n}\n});\n\ncljs.core.async.impl.protocols.add_BANG_ \x3d (function cljs$core$async$impl$protocols$add_BANG_(var_args){\nvar G__19803 \x3d arguments.length;\nswitch (G__19803) {\ncase 1:\nreturn cljs.core.async.impl.protocols.add_BANG_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.impl.protocols.add_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.impl.protocols.add_BANG_.cljs$core$IFn$_invoke$arity$1 \x3d (function (b){\nreturn b;\n}));\n\n(cljs.core.async.impl.protocols.add_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (b,itm){\nif((!((itm \x3d\x3d null)))){\n} else {\nthrow (new Error(\x22Assert failed: (not (nil? itm))\x22));\n}\n\nreturn cljs.core.async.impl.protocols.add_BANG__STAR_(b,itm);\n}));\n\n(cljs.core.async.impl.protocols.add_BANG_.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n * @interface\n */\ncljs.core.async.impl.protocols.UnblockingBuffer \x3d function(){};\n\n");
SHADOW_ENV.evalLoad("cljs.core.async.impl.buffers.js", true, "goog.provide(\x27cljs.core.async.impl.buffers\x27);\ncljs.core.async.impl.buffers.acopy \x3d (function cljs$core$async$impl$buffers$acopy(src,src_start,dest,dest_start,len){\nvar cnt \x3d (0);\nwhile(true){\nif((cnt \x3c len)){\n(dest[(dest_start + cnt)] \x3d (src[(src_start + cnt)]));\n\nvar G__20025 \x3d (cnt + (1));\ncnt \x3d G__20025;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n*/\ncljs.core.async.impl.buffers.RingBuffer \x3d (function (head,tail,length,arr){\nthis.head \x3d head;\nthis.tail \x3d tail;\nthis.length \x3d length;\nthis.arr \x3d arr;\n});\n(cljs.core.async.impl.buffers.RingBuffer.prototype.pop \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif((self__.length \x3d\x3d\x3d (0))){\nreturn null;\n} else {\nvar x \x3d (self__.arr[self__.tail]);\n(self__.arr[self__.tail] \x3d null);\n\n(self__.tail \x3d ((self__.tail + (1)) % self__.arr.length));\n\n(self__.length \x3d (self__.length - (1)));\n\nreturn x;\n}\n}));\n\n(cljs.core.async.impl.buffers.RingBuffer.prototype.unshift \x3d (function (x){\nvar self__ \x3d this;\nvar _ \x3d this;\n(self__.arr[self__.head] \x3d x);\n\n(self__.head \x3d ((self__.head + (1)) % self__.arr.length));\n\n(self__.length \x3d (self__.length + (1)));\n\nreturn null;\n}));\n\n(cljs.core.async.impl.buffers.RingBuffer.prototype.unbounded_unshift \x3d (function (x){\nvar self__ \x3d this;\nvar this$ \x3d this;\nif(((self__.length + (1)) \x3d\x3d\x3d self__.arr.length)){\nthis$.resize();\n} else {\n}\n\nreturn this$.unshift(x);\n}));\n\n(cljs.core.async.impl.buffers.RingBuffer.prototype.resize \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar new_arr_size \x3d (self__.arr.length * (2));\nvar new_arr \x3d (new Array(new_arr_size));\nif((self__.tail \x3c self__.head)){\ncljs.core.async.impl.buffers.acopy(self__.arr,self__.tail,new_arr,(0),self__.length);\n\n(self__.tail \x3d (0));\n\n(self__.head \x3d self__.length);\n\nreturn (self__.arr \x3d new_arr);\n} else {\nif((self__.tail \x3e self__.head)){\ncljs.core.async.impl.buffers.acopy(self__.arr,self__.tail,new_arr,(0),(self__.arr.length - self__.tail));\n\ncljs.core.async.impl.buffers.acopy(self__.arr,(0),new_arr,(self__.arr.length - self__.tail),self__.head);\n\n(self__.tail \x3d (0));\n\n(self__.head \x3d self__.length);\n\nreturn (self__.arr \x3d new_arr);\n} else {\nif((self__.tail \x3d\x3d\x3d self__.head)){\n(self__.tail \x3d (0));\n\n(self__.head \x3d (0));\n\nreturn (self__.arr \x3d new_arr);\n} else {\nreturn null;\n}\n}\n}\n}));\n\n(cljs.core.async.impl.buffers.RingBuffer.prototype.cleanup \x3d (function (keep_QMARK_){\nvar self__ \x3d this;\nvar this$ \x3d this;\nvar n__5593__auto__ \x3d self__.length;\nvar x \x3d (0);\nwhile(true){\nif((x \x3c n__5593__auto__)){\nvar v_20063 \x3d this$.pop();\nif((keep_QMARK_.cljs$core$IFn$_invoke$arity$1 ? keep_QMARK_.cljs$core$IFn$_invoke$arity$1(v_20063) : keep_QMARK_.call(null, v_20063))){\nthis$.unshift(v_20063);\n} else {\n}\n\nvar G__20073 \x3d (x + (1));\nx \x3d G__20073;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(cljs.core.async.impl.buffers.RingBuffer.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22head\x22,\x22head\x22,869147608,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22tail\x22,\x22tail\x22,494507963,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22length\x22,\x22length\x22,-2065447907,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22arr\x22,\x22arr\x22,2115492975,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.async.impl.buffers.RingBuffer.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.buffers.RingBuffer.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.buffers/RingBuffer\x22);\n\n(cljs.core.async.impl.buffers.RingBuffer.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.buffers/RingBuffer\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.buffers/RingBuffer.\n */\ncljs.core.async.impl.buffers.__GT_RingBuffer \x3d (function cljs$core$async$impl$buffers$__GT_RingBuffer(head,tail,length,arr){\nreturn (new cljs.core.async.impl.buffers.RingBuffer(head,tail,length,arr));\n});\n\ncljs.core.async.impl.buffers.ring_buffer \x3d (function cljs$core$async$impl$buffers$ring_buffer(n){\nif((n \x3e (0))){\n} else {\nthrow (new Error([\x22Assert failed: \x22,\x22Can\x27t create a ring buffer of size 0\x22,\x22\\n\x22,\x22(\x3e n 0)\x22].join(\x27\x27)));\n}\n\nreturn (new cljs.core.async.impl.buffers.RingBuffer((0),(0),(0),(new Array(n))));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.async.impl.protocols.Buffer}\n*/\ncljs.core.async.impl.buffers.FixedBuffer \x3d (function (buf,n){\nthis.buf \x3d buf;\nthis.n \x3d n;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.buffers.FixedBuffer.prototype.cljs$core$async$impl$protocols$Buffer$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.buffers.FixedBuffer.prototype.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (self__.buf.length \x3e\x3d self__.n);\n}));\n\n(cljs.core.async.impl.buffers.FixedBuffer.prototype.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.buf.pop();\n}));\n\n(cljs.core.async.impl.buffers.FixedBuffer.prototype.cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$arity$2 \x3d (function (this$,itm){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nself__.buf.unbounded_unshift(itm);\n\nreturn this$__$1;\n}));\n\n(cljs.core.async.impl.buffers.FixedBuffer.prototype.cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.async.impl.buffers.FixedBuffer.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.buf.length;\n}));\n\n(cljs.core.async.impl.buffers.FixedBuffer.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22buf\x22,\x22buf\x22,1426618187,null),new cljs.core.Symbol(null,\x22n\x22,\x22n\x22,-2092305744,null)], null);\n}));\n\n(cljs.core.async.impl.buffers.FixedBuffer.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.buffers.FixedBuffer.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.buffers/FixedBuffer\x22);\n\n(cljs.core.async.impl.buffers.FixedBuffer.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.buffers/FixedBuffer\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.buffers/FixedBuffer.\n */\ncljs.core.async.impl.buffers.__GT_FixedBuffer \x3d (function cljs$core$async$impl$buffers$__GT_FixedBuffer(buf,n){\nreturn (new cljs.core.async.impl.buffers.FixedBuffer(buf,n));\n});\n\ncljs.core.async.impl.buffers.fixed_buffer \x3d (function cljs$core$async$impl$buffers$fixed_buffer(n){\nreturn (new cljs.core.async.impl.buffers.FixedBuffer(cljs.core.async.impl.buffers.ring_buffer(n),n));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.async.impl.protocols.UnblockingBuffer}\n * @implements {cljs.core.async.impl.protocols.Buffer}\n*/\ncljs.core.async.impl.buffers.DroppingBuffer \x3d (function (buf,n){\nthis.buf \x3d buf;\nthis.n \x3d n;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.buffers.DroppingBuffer.prototype.cljs$core$async$impl$protocols$UnblockingBuffer$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.buffers.DroppingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.buffers.DroppingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn false;\n}));\n\n(cljs.core.async.impl.buffers.DroppingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.buf.pop();\n}));\n\n(cljs.core.async.impl.buffers.DroppingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$arity$2 \x3d (function (this$,itm){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((self__.buf.length \x3d\x3d\x3d self__.n)){\n} else {\nself__.buf.unshift(itm);\n}\n\nreturn this$__$1;\n}));\n\n(cljs.core.async.impl.buffers.DroppingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.async.impl.buffers.DroppingBuffer.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.buf.length;\n}));\n\n(cljs.core.async.impl.buffers.DroppingBuffer.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22buf\x22,\x22buf\x22,1426618187,null),new cljs.core.Symbol(null,\x22n\x22,\x22n\x22,-2092305744,null)], null);\n}));\n\n(cljs.core.async.impl.buffers.DroppingBuffer.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.buffers.DroppingBuffer.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.buffers/DroppingBuffer\x22);\n\n(cljs.core.async.impl.buffers.DroppingBuffer.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.buffers/DroppingBuffer\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.buffers/DroppingBuffer.\n */\ncljs.core.async.impl.buffers.__GT_DroppingBuffer \x3d (function cljs$core$async$impl$buffers$__GT_DroppingBuffer(buf,n){\nreturn (new cljs.core.async.impl.buffers.DroppingBuffer(buf,n));\n});\n\ncljs.core.async.impl.buffers.dropping_buffer \x3d (function cljs$core$async$impl$buffers$dropping_buffer(n){\nreturn (new cljs.core.async.impl.buffers.DroppingBuffer(cljs.core.async.impl.buffers.ring_buffer(n),n));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.async.impl.protocols.UnblockingBuffer}\n * @implements {cljs.core.async.impl.protocols.Buffer}\n*/\ncljs.core.async.impl.buffers.SlidingBuffer \x3d (function (buf,n){\nthis.buf \x3d buf;\nthis.n \x3d n;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.buffers.SlidingBuffer.prototype.cljs$core$async$impl$protocols$UnblockingBuffer$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.buffers.SlidingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.buffers.SlidingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn false;\n}));\n\n(cljs.core.async.impl.buffers.SlidingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.buf.pop();\n}));\n\n(cljs.core.async.impl.buffers.SlidingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$arity$2 \x3d (function (this$,itm){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((self__.buf.length \x3d\x3d\x3d self__.n)){\nthis$__$1.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1(null, );\n} else {\n}\n\nself__.buf.unshift(itm);\n\nreturn this$__$1;\n}));\n\n(cljs.core.async.impl.buffers.SlidingBuffer.prototype.cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn null;\n}));\n\n(cljs.core.async.impl.buffers.SlidingBuffer.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.buf.length;\n}));\n\n(cljs.core.async.impl.buffers.SlidingBuffer.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22buf\x22,\x22buf\x22,1426618187,null),new cljs.core.Symbol(null,\x22n\x22,\x22n\x22,-2092305744,null)], null);\n}));\n\n(cljs.core.async.impl.buffers.SlidingBuffer.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.buffers.SlidingBuffer.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.buffers/SlidingBuffer\x22);\n\n(cljs.core.async.impl.buffers.SlidingBuffer.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.buffers/SlidingBuffer\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.buffers/SlidingBuffer.\n */\ncljs.core.async.impl.buffers.__GT_SlidingBuffer \x3d (function cljs$core$async$impl$buffers$__GT_SlidingBuffer(buf,n){\nreturn (new cljs.core.async.impl.buffers.SlidingBuffer(buf,n));\n});\n\ncljs.core.async.impl.buffers.sliding_buffer \x3d (function cljs$core$async$impl$buffers$sliding_buffer(n){\nreturn (new cljs.core.async.impl.buffers.SlidingBuffer(cljs.core.async.impl.buffers.ring_buffer(n),n));\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.async !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.async.impl !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.async.impl.buffers !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.async.impl.buffers.NO_VAL !\x3d\x3d \x27undefined\x27)){\n} else {\ncljs.core.async.impl.buffers.NO_VAL \x3d (new Object());\n}\ncljs.core.async.impl.buffers.undelivered_QMARK_ \x3d (function cljs$core$async$impl$buffers$undelivered_QMARK_(val){\nreturn (cljs.core.async.impl.buffers.NO_VAL \x3d\x3d\x3d val);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.async.impl.protocols.UnblockingBuffer}\n * @implements {cljs.core.async.impl.protocols.Buffer}\n*/\ncljs.core.async.impl.buffers.PromiseBuffer \x3d (function (val){\nthis.val \x3d val;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.buffers.PromiseBuffer.prototype.cljs$core$async$impl$protocols$UnblockingBuffer$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.buffers.PromiseBuffer.prototype.cljs$core$async$impl$protocols$Buffer$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.buffers.PromiseBuffer.prototype.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn false;\n}));\n\n(cljs.core.async.impl.buffers.PromiseBuffer.prototype.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.async.impl.buffers.PromiseBuffer.prototype.cljs$core$async$impl$protocols$Buffer$add_BANG__STAR_$arity$2 \x3d (function (this$,itm){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif(cljs.core.async.impl.buffers.undelivered_QMARK_(self__.val)){\n(self__.val \x3d itm);\n} else {\n}\n\nreturn this$__$1;\n}));\n\n(cljs.core.async.impl.buffers.PromiseBuffer.prototype.cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.async.impl.buffers.undelivered_QMARK_(self__.val)){\nreturn (self__.val \x3d null);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.async.impl.buffers.PromiseBuffer.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.async.impl.buffers.undelivered_QMARK_(self__.val)){\nreturn (0);\n} else {\nreturn (1);\n}\n}));\n\n(cljs.core.async.impl.buffers.PromiseBuffer.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.async.impl.buffers.PromiseBuffer.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.buffers.PromiseBuffer.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.buffers/PromiseBuffer\x22);\n\n(cljs.core.async.impl.buffers.PromiseBuffer.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.buffers/PromiseBuffer\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.buffers/PromiseBuffer.\n */\ncljs.core.async.impl.buffers.__GT_PromiseBuffer \x3d (function cljs$core$async$impl$buffers$__GT_PromiseBuffer(val){\nreturn (new cljs.core.async.impl.buffers.PromiseBuffer(val));\n});\n\ncljs.core.async.impl.buffers.promise_buffer \x3d (function cljs$core$async$impl$buffers$promise_buffer(){\nreturn (new cljs.core.async.impl.buffers.PromiseBuffer(cljs.core.async.impl.buffers.NO_VAL));\n});\n");
SHADOW_ENV.evalLoad("goog.debug.entrypointregistry.js", true, "goog.provide(\x22goog.debug.EntryPointMonitor\x22);\ngoog.provide(\x22goog.debug.entryPointRegistry\x22);\ngoog.require(\x22goog.asserts\x22);\ngoog.debug.entryPointRegistry.EntryPointMonitor \x3d function() {\n};\ngoog.debug.entryPointRegistry.EntryPointMonitor.prototype.wrap;\ngoog.debug.entryPointRegistry.EntryPointMonitor.prototype.unwrap;\ngoog.debug.EntryPointMonitor \x3d goog.debug.entryPointRegistry.EntryPointMonitor;\ngoog.debug.entryPointRegistry.refList_ \x3d [];\ngoog.debug.entryPointRegistry.monitors_ \x3d [];\ngoog.debug.entryPointRegistry.monitorsMayExist_ \x3d false;\ngoog.debug.entryPointRegistry.register \x3d function(callback) {\n  goog.debug.entryPointRegistry.refList_[goog.debug.entryPointRegistry.refList_.length] \x3d callback;\n  if (goog.debug.entryPointRegistry.monitorsMayExist_) {\n    var monitors \x3d goog.debug.entryPointRegistry.monitors_;\n    var i \x3d 0;\n    for (; i \x3c monitors.length; i++) {\n      callback(goog.bind(monitors[i].wrap, monitors[i]));\n    }\n  }\n};\ngoog.debug.entryPointRegistry.monitorAll \x3d function(monitor) {\n  goog.debug.entryPointRegistry.monitorsMayExist_ \x3d true;\n  var transformer \x3d goog.bind(monitor.wrap, monitor);\n  var i \x3d 0;\n  for (; i \x3c goog.debug.entryPointRegistry.refList_.length; i++) {\n    goog.debug.entryPointRegistry.refList_[i](transformer);\n  }\n  goog.debug.entryPointRegistry.monitors_.push(monitor);\n};\ngoog.debug.entryPointRegistry.unmonitorAllIfPossible \x3d function(monitor) {\n  var monitors \x3d goog.debug.entryPointRegistry.monitors_;\n  goog.asserts.assert(monitor \x3d\x3d monitors[monitors.length - 1], \x22Only the most recent monitor can be unwrapped.\x22);\n  var transformer \x3d goog.bind(monitor.unwrap, monitor);\n  var i \x3d 0;\n  for (; i \x3c goog.debug.entryPointRegistry.refList_.length; i++) {\n    goog.debug.entryPointRegistry.refList_[i](transformer);\n  }\n  monitors.length--;\n};\n");
SHADOW_ENV.evalLoad("goog.async.nexttick.js", true, "goog.provide(\x22goog.async.nextTick\x22);\ngoog.require(\x22goog.debug.entryPointRegistry\x22);\ngoog.require(\x22goog.dom\x22);\ngoog.require(\x22goog.dom.TagName\x22);\ngoog.require(\x22goog.functions\x22);\ngoog.require(\x22goog.labs.userAgent.browser\x22);\ngoog.require(\x22goog.labs.userAgent.engine\x22);\ngoog.async.nextTick \x3d function(callback, opt_context, opt_useSetImmediate) {\n  var cb \x3d callback;\n  if (opt_context) {\n    cb \x3d goog.bind(callback, opt_context);\n  }\n  cb \x3d goog.async.nextTick.wrapCallback_(cb);\n  if (typeof goog.global.setImmediate \x3d\x3d\x3d \x22function\x22 \x26\x26 (opt_useSetImmediate || goog.async.nextTick.useSetImmediate_())) {\n    goog.global.setImmediate(cb);\n    return;\n  }\n  if (!goog.async.nextTick.nextTickImpl) {\n    goog.async.nextTick.nextTickImpl \x3d goog.async.nextTick.getNextTickImpl_();\n  }\n  goog.async.nextTick.nextTickImpl(cb);\n};\ngoog.async.nextTick.useSetImmediate_ \x3d function() {\n  if (!goog.global.Window || !goog.global.Window.prototype) {\n    return true;\n  }\n  if (goog.labs.userAgent.browser.isEdge() || goog.global.Window.prototype.setImmediate !\x3d goog.global.setImmediate) {\n    return true;\n  }\n  return false;\n};\ngoog.async.nextTick.nextTickImpl;\ngoog.async.nextTick.getNextTickImpl_ \x3d function() {\n  var Channel \x3d goog.global[\x22MessageChannel\x22];\n  if (typeof Channel \x3d\x3d\x3d \x22undefined\x22 \x26\x26 typeof window !\x3d\x3d \x22undefined\x22 \x26\x26 window.postMessage \x26\x26 window.addEventListener \x26\x26 !goog.labs.userAgent.engine.isPresto()) {\n    Channel \x3d function() {\n      var iframe \x3d goog.dom.createElement(goog.dom.TagName.IFRAME);\n      iframe.style.display \x3d \x22none\x22;\n      document.documentElement.appendChild(iframe);\n      var win \x3d iframe.contentWindow;\n      var doc \x3d win.document;\n      doc.open();\n      doc.close();\n      var message \x3d \x22callImmediate\x22 + Math.random();\n      var origin \x3d win.location.protocol \x3d\x3d \x22file:\x22 ? \x22*\x22 : win.location.protocol + \x22//\x22 + win.location.host;\n      var onmessage \x3d goog.bind(function(e) {\n        if (origin !\x3d \x22*\x22 \x26\x26 e.origin !\x3d origin || e.data !\x3d message) {\n          return;\n        }\n        this[\x22port1\x22].onmessage();\n      }, this);\n      win.addEventListener(\x22message\x22, onmessage, false);\n      this[\x22port1\x22] \x3d {};\n      this[\x22port2\x22] \x3d {postMessage:function() {\n        win.postMessage(message, origin);\n      }};\n    };\n  }\n  if (typeof Channel !\x3d\x3d \x22undefined\x22 \x26\x26 !goog.labs.userAgent.browser.isIE()) {\n    var channel \x3d new Channel();\n    var head \x3d {};\n    var tail \x3d head;\n    channel[\x22port1\x22].onmessage \x3d function() {\n      if (head.next !\x3d\x3d undefined) {\n        head \x3d head.next;\n        var cb \x3d head.cb;\n        head.cb \x3d null;\n        cb();\n      }\n    };\n    return function(cb) {\n      tail.next \x3d {cb:cb};\n      tail \x3d tail.next;\n      channel[\x22port2\x22].postMessage(0);\n    };\n  }\n  return function(cb) {\n    goog.global.setTimeout(cb, 0);\n  };\n};\ngoog.async.nextTick.wrapCallback_ \x3d goog.functions.identity;\ngoog.debug.entryPointRegistry.register(function(transformer) {\n  goog.async.nextTick.wrapCallback_ \x3d transformer;\n});\n");
SHADOW_ENV.evalLoad("cljs.core.async.impl.dispatch.js", true, "goog.provide(\x27cljs.core.async.impl.dispatch\x27);\ncljs.core.async.impl.dispatch.tasks \x3d cljs.core.async.impl.buffers.ring_buffer((32));\ncljs.core.async.impl.dispatch.running_QMARK_ \x3d false;\ncljs.core.async.impl.dispatch.queued_QMARK_ \x3d false;\ncljs.core.async.impl.dispatch.TASK_BATCH_SIZE \x3d (1024);\ncljs.core.async.impl.dispatch.process_messages \x3d (function cljs$core$async$impl$dispatch$process_messages(){\n(cljs.core.async.impl.dispatch.running_QMARK_ \x3d true);\n\n(cljs.core.async.impl.dispatch.queued_QMARK_ \x3d false);\n\nvar count_21605 \x3d (0);\nwhile(true){\nvar m_21606 \x3d cljs.core.async.impl.dispatch.tasks.pop();\nif((m_21606 \x3d\x3d null)){\n} else {\n(m_21606.cljs$core$IFn$_invoke$arity$0 ? m_21606.cljs$core$IFn$_invoke$arity$0() : m_21606.call(null, ));\n\nif((count_21605 \x3c cljs.core.async.impl.dispatch.TASK_BATCH_SIZE)){\nvar G__21609 \x3d (count_21605 + (1));\ncount_21605 \x3d G__21609;\ncontinue;\n} else {\n}\n}\nbreak;\n}\n\n(cljs.core.async.impl.dispatch.running_QMARK_ \x3d false);\n\nif((cljs.core.async.impl.dispatch.tasks.length \x3e (0))){\nreturn (cljs.core.async.impl.dispatch.queue_dispatcher.cljs$core$IFn$_invoke$arity$0 ? cljs.core.async.impl.dispatch.queue_dispatcher.cljs$core$IFn$_invoke$arity$0() : cljs.core.async.impl.dispatch.queue_dispatcher.call(null, ));\n} else {\nreturn null;\n}\n});\ncljs.core.async.impl.dispatch.queue_dispatcher \x3d (function cljs$core$async$impl$dispatch$queue_dispatcher(){\nif(((cljs.core.async.impl.dispatch.queued_QMARK_) \x26\x26 (cljs.core.async.impl.dispatch.running_QMARK_))){\nreturn null;\n} else {\n(cljs.core.async.impl.dispatch.queued_QMARK_ \x3d true);\n\nreturn goog.async.nextTick(cljs.core.async.impl.dispatch.process_messages);\n}\n});\ncljs.core.async.impl.dispatch.run \x3d (function cljs$core$async$impl$dispatch$run(f){\ncljs.core.async.impl.dispatch.tasks.unbounded_unshift(f);\n\nreturn cljs.core.async.impl.dispatch.queue_dispatcher();\n});\ncljs.core.async.impl.dispatch.queue_delay \x3d (function cljs$core$async$impl$dispatch$queue_delay(f,delay){\nreturn setTimeout(f,delay);\n});\n");
SHADOW_ENV.evalLoad("cljs.core.async.impl.channels.js", true, "goog.provide(\x27cljs.core.async.impl.channels\x27);\n\n/**\n* @constructor\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IDeref}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720 \x3d (function (val,meta21721){\nthis.val \x3d val;\nthis.meta21721 \x3d meta21721;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 425984;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_21722,meta21721__$1){\nvar self__ \x3d this;\nvar _21722__$1 \x3d this;\nreturn (new cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720(self__.val,meta21721__$1));\n}));\n\n(cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_21722){\nvar self__ \x3d this;\nvar _21722__$1 \x3d this;\nreturn self__.meta21721;\n}));\n\n(cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.val;\n}));\n\n(cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.Symbol(null,\x22meta21721\x22,\x22meta21721\x22,-661743079,null)], null);\n}));\n\n(cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.channels/t_cljs$core$async$impl$channels21720\x22);\n\n(cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.channels/t_cljs$core$async$impl$channels21720\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.channels/t_cljs$core$async$impl$channels21720.\n */\ncljs.core.async.impl.channels.__GT_t_cljs$core$async$impl$channels21720 \x3d (function cljs$core$async$impl$channels$__GT_t_cljs$core$async$impl$channels21720(val,meta21721){\nreturn (new cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720(val,meta21721));\n});\n\n\ncljs.core.async.impl.channels.box \x3d (function cljs$core$async$impl$channels$box(val){\nreturn (new cljs.core.async.impl.channels.t_cljs$core$async$impl$channels21720(val,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n*/\ncljs.core.async.impl.channels.PutBox \x3d (function (handler,val){\nthis.handler \x3d handler;\nthis.val \x3d val;\n});\n\n(cljs.core.async.impl.channels.PutBox.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22handler\x22,\x22handler\x22,1444934915,null),new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null)], null);\n}));\n\n(cljs.core.async.impl.channels.PutBox.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.channels.PutBox.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.channels/PutBox\x22);\n\n(cljs.core.async.impl.channels.PutBox.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.channels/PutBox\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.channels/PutBox.\n */\ncljs.core.async.impl.channels.__GT_PutBox \x3d (function cljs$core$async$impl$channels$__GT_PutBox(handler,val){\nreturn (new cljs.core.async.impl.channels.PutBox(handler,val));\n});\n\ncljs.core.async.impl.channels.put_active_QMARK_ \x3d (function cljs$core$async$impl$channels$put_active_QMARK_(box){\nreturn cljs.core.async.impl.protocols.active_QMARK_(box.handler);\n});\ncljs.core.async.impl.channels.MAX_DIRTY \x3d (64);\n\n/**\n * @interface\n */\ncljs.core.async.impl.channels.MMC \x3d function(){};\n\nvar cljs$core$async$impl$channels$MMC$abort$dyn_22140 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (cljs.core.async.impl.channels.abort[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.impl.channels.abort[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22MMC.abort\x22,this$);\n}\n}\n});\ncljs.core.async.impl.channels.abort \x3d (function cljs$core$async$impl$channels$abort(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.cljs$core$async$impl$channels$MMC$abort$arity$1 \x3d\x3d null)))))){\nreturn this$.cljs$core$async$impl$channels$MMC$abort$arity$1(this$);\n} else {\nreturn cljs$core$async$impl$channels$MMC$abort$dyn_22140(this$);\n}\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.channels.MMC}\n * @implements {cljs.core.async.impl.protocols.Channel}\n * @implements {cljs.core.async.impl.protocols.WritePort}\n * @implements {cljs.core.async.impl.protocols.ReadPort}\n*/\ncljs.core.async.impl.channels.ManyToManyChannel \x3d (function (takes,dirty_takes,puts,dirty_puts,buf,closed,add_BANG_){\nthis.takes \x3d takes;\nthis.dirty_takes \x3d dirty_takes;\nthis.puts \x3d puts;\nthis.dirty_puts \x3d dirty_puts;\nthis.buf \x3d buf;\nthis.closed \x3d closed;\nthis.add_BANG_ \x3d add_BANG_;\n});\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$channels$MMC$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$channels$MMC$abort$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nwhile(true){\nvar putter_22147 \x3d self__.puts.pop();\nif((putter_22147 \x3d\x3d null)){\n} else {\nvar put_handler_22149 \x3d putter_22147.handler;\nvar val_22150 \x3d putter_22147.val;\nif(put_handler_22149.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, )){\nvar put_cb_22155 \x3d put_handler_22149.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\ncljs.core.async.impl.dispatch.run(((function (put_cb_22155,put_handler_22149,val_22150,putter_22147,this$__$1){\nreturn (function (){\nreturn (put_cb_22155.cljs$core$IFn$_invoke$arity$1 ? put_cb_22155.cljs$core$IFn$_invoke$arity$1(true) : put_cb_22155.call(null, true));\n});})(put_cb_22155,put_handler_22149,val_22150,putter_22147,this$__$1))\n);\n} else {\ncontinue;\n}\n}\nbreak;\n}\n\nself__.puts.cleanup(cljs.core.constantly(false));\n\nreturn this$__$1.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1(null, );\n}));\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$protocols$WritePort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3 \x3d (function (this$,val,handler){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((!((val \x3d\x3d null)))){\n} else {\nthrow (new Error([\x22Assert failed: \x22,\x22Can\x27t put nil on a channel\x22,\x22\\n\x22,\x22(not (nil? val))\x22].join(\x27\x27)));\n}\n\nvar closed__$1 \x3d self__.closed;\nif((!(handler.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, )))){\nreturn cljs.core.async.impl.channels.box((!(closed__$1)));\n} else {\nif(closed__$1){\nhandler.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\n\nreturn cljs.core.async.impl.channels.box(false);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d self__.buf;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.not(self__.buf.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1(null, ));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nhandler.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\n\nvar done_QMARK_ \x3d cljs.core.reduced_QMARK_((self__.add_BANG_.cljs$core$IFn$_invoke$arity$2 ? self__.add_BANG_.cljs$core$IFn$_invoke$arity$2(self__.buf,val) : self__.add_BANG_.call(null, self__.buf,val)));\nvar take_cbs \x3d (function (){var takers \x3d cljs.core.PersistentVector.EMPTY;\nwhile(true){\nif((((self__.takes.length \x3e (0))) \x26\x26 ((cljs.core.count(self__.buf) \x3e (0))))){\nvar taker \x3d self__.takes.pop();\nif(taker.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, )){\nvar ret \x3d taker.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\nvar val__$1 \x3d self__.buf.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1(null, );\nvar G__22172 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(takers,((function (takers,ret,val__$1,taker,done_QMARK_,closed__$1,this$__$1){\nreturn (function (){\nreturn (ret.cljs$core$IFn$_invoke$arity$1 ? ret.cljs$core$IFn$_invoke$arity$1(val__$1) : ret.call(null, val__$1));\n});})(takers,ret,val__$1,taker,done_QMARK_,closed__$1,this$__$1))\n);\ntakers \x3d G__22172;\ncontinue;\n} else {\nvar G__22174 \x3d takers;\ntakers \x3d G__22174;\ncontinue;\n}\n} else {\nreturn takers;\n}\nbreak;\n}\n})();\nif(done_QMARK_){\nthis$__$1.cljs$core$async$impl$channels$MMC$abort$arity$1(null, );\n} else {\n}\n\nif(cljs.core.seq(take_cbs)){\nvar seq__21829_22178 \x3d cljs.core.seq(take_cbs);\nvar chunk__21830_22179 \x3d null;\nvar count__21831_22180 \x3d (0);\nvar i__21832_22181 \x3d (0);\nwhile(true){\nif((i__21832_22181 \x3c count__21831_22180)){\nvar f_22182 \x3d chunk__21830_22179.cljs$core$IIndexed$_nth$arity$2(null, i__21832_22181);\ncljs.core.async.impl.dispatch.run(f_22182);\n\n\nvar G__22183 \x3d seq__21829_22178;\nvar G__22184 \x3d chunk__21830_22179;\nvar G__22185 \x3d count__21831_22180;\nvar G__22186 \x3d (i__21832_22181 + (1));\nseq__21829_22178 \x3d G__22183;\nchunk__21830_22179 \x3d G__22184;\ncount__21831_22180 \x3d G__22185;\ni__21832_22181 \x3d G__22186;\ncontinue;\n} else {\nvar temp__5804__auto___22187 \x3d cljs.core.seq(seq__21829_22178);\nif(temp__5804__auto___22187){\nvar seq__21829_22188__$1 \x3d temp__5804__auto___22187;\nif(cljs.core.chunked_seq_QMARK_(seq__21829_22188__$1)){\nvar c__5525__auto___22190 \x3d cljs.core.chunk_first(seq__21829_22188__$1);\nvar G__22191 \x3d cljs.core.chunk_rest(seq__21829_22188__$1);\nvar G__22192 \x3d c__5525__auto___22190;\nvar G__22193 \x3d cljs.core.count(c__5525__auto___22190);\nvar G__22194 \x3d (0);\nseq__21829_22178 \x3d G__22191;\nchunk__21830_22179 \x3d G__22192;\ncount__21831_22180 \x3d G__22193;\ni__21832_22181 \x3d G__22194;\ncontinue;\n} else {\nvar f_22197 \x3d cljs.core.first(seq__21829_22188__$1);\ncljs.core.async.impl.dispatch.run(f_22197);\n\n\nvar G__22204 \x3d cljs.core.next(seq__21829_22188__$1);\nvar G__22205 \x3d null;\nvar G__22206 \x3d (0);\nvar G__22207 \x3d (0);\nseq__21829_22178 \x3d G__22204;\nchunk__21830_22179 \x3d G__22205;\ncount__21831_22180 \x3d G__22206;\ni__21832_22181 \x3d G__22207;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n} else {\n}\n\nreturn cljs.core.async.impl.channels.box(true);\n} else {\nvar taker \x3d (function (){while(true){\nvar taker \x3d self__.takes.pop();\nif(cljs.core.truth_(taker)){\nif(cljs.core.truth_(taker.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, ))){\nreturn taker;\n} else {\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n})();\nif(cljs.core.truth_(taker)){\nvar take_cb \x3d taker.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\nhandler.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\n\ncljs.core.async.impl.dispatch.run((function (){\nreturn (take_cb.cljs$core$IFn$_invoke$arity$1 ? take_cb.cljs$core$IFn$_invoke$arity$1(val) : take_cb.call(null, val));\n}));\n\nreturn cljs.core.async.impl.channels.box(true);\n} else {\nif((self__.dirty_puts \x3e (64))){\n(self__.dirty_puts \x3d (0));\n\nself__.puts.cleanup(cljs.core.async.impl.channels.put_active_QMARK_);\n} else {\n(self__.dirty_puts \x3d (self__.dirty_puts + (1)));\n}\n\nif(cljs.core.truth_(handler.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1(null, ))){\nif((self__.puts.length \x3c (1024))){\n} else {\nthrow (new Error([\x22Assert failed: \x22,[\x22No more than \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((1024)),\x22 pending puts are allowed on a single channel.\x22,\x22 Consider using a windowed buffer.\x22].join(\x27\x27),\x22\\n\x22,\x22(\x3c (.-length puts) impl/MAX-QUEUE-SIZE)\x22].join(\x27\x27)));\n}\n\nself__.puts.unbounded_unshift((new cljs.core.async.impl.channels.PutBox(handler,val)));\n} else {\n}\n\nreturn null;\n}\n}\n}\n}\n}));\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$protocols$ReadPort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2 \x3d (function (this$,handler){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((!(handler.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, )))){\nreturn null;\n} else {\nif((((!((self__.buf \x3d\x3d null)))) \x26\x26 ((cljs.core.count(self__.buf) \x3e (0))))){\nvar temp__5802__auto__ \x3d handler.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\nif(cljs.core.truth_(temp__5802__auto__)){\nvar take_cb \x3d temp__5802__auto__;\nvar val \x3d self__.buf.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1(null, );\nvar vec__21892 \x3d ((((cljs.core.not(self__.buf.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1(null, ))) \x26\x26 ((self__.puts.length \x3e (0)))))?(function (){var cbs \x3d cljs.core.PersistentVector.EMPTY;\nwhile(true){\nvar putter \x3d self__.puts.pop();\nvar put_handler \x3d putter.handler;\nvar val__$1 \x3d putter.val;\nvar cb \x3d (function (){var and__5000__auto__ \x3d put_handler.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, );\nif(and__5000__auto__){\nreturn put_handler.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\n} else {\nreturn and__5000__auto__;\n}\n})();\nvar cbs__$1 \x3d (cljs.core.truth_(cb)?cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cbs,cb):cbs);\nvar done_QMARK_ \x3d (cljs.core.truth_(cb)?cljs.core.reduced_QMARK_((self__.add_BANG_.cljs$core$IFn$_invoke$arity$2 ? self__.add_BANG_.cljs$core$IFn$_invoke$arity$2(self__.buf,val__$1) : self__.add_BANG_.call(null, self__.buf,val__$1))):null);\nif(((cljs.core.not(done_QMARK_)) \x26\x26 (((cljs.core.not(self__.buf.cljs$core$async$impl$protocols$Buffer$full_QMARK_$arity$1(null, ))) \x26\x26 ((self__.puts.length \x3e (0))))))){\nvar G__22238 \x3d cbs__$1;\ncbs \x3d G__22238;\ncontinue;\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [done_QMARK_,cbs__$1], null);\n}\nbreak;\n}\n})():null);\nvar done_QMARK_ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21892,(0),null);\nvar cbs \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21892,(1),null);\nif(cljs.core.truth_(done_QMARK_)){\nthis$__$1.cljs$core$async$impl$channels$MMC$abort$arity$1(null, );\n} else {\n}\n\nvar seq__21934_22240 \x3d cljs.core.seq(cbs);\nvar chunk__21935_22241 \x3d null;\nvar count__21936_22242 \x3d (0);\nvar i__21937_22243 \x3d (0);\nwhile(true){\nif((i__21937_22243 \x3c count__21936_22242)){\nvar cb_22244 \x3d chunk__21935_22241.cljs$core$IIndexed$_nth$arity$2(null, i__21937_22243);\ncljs.core.async.impl.dispatch.run(((function (seq__21934_22240,chunk__21935_22241,count__21936_22242,i__21937_22243,cb_22244,val,vec__21892,done_QMARK_,cbs,take_cb,temp__5802__auto__,this$__$1){\nreturn (function (){\nreturn (cb_22244.cljs$core$IFn$_invoke$arity$1 ? cb_22244.cljs$core$IFn$_invoke$arity$1(true) : cb_22244.call(null, true));\n});})(seq__21934_22240,chunk__21935_22241,count__21936_22242,i__21937_22243,cb_22244,val,vec__21892,done_QMARK_,cbs,take_cb,temp__5802__auto__,this$__$1))\n);\n\n\nvar G__22249 \x3d seq__21934_22240;\nvar G__22250 \x3d chunk__21935_22241;\nvar G__22251 \x3d count__21936_22242;\nvar G__22252 \x3d (i__21937_22243 + (1));\nseq__21934_22240 \x3d G__22249;\nchunk__21935_22241 \x3d G__22250;\ncount__21936_22242 \x3d G__22251;\ni__21937_22243 \x3d G__22252;\ncontinue;\n} else {\nvar temp__5804__auto___22254 \x3d cljs.core.seq(seq__21934_22240);\nif(temp__5804__auto___22254){\nvar seq__21934_22256__$1 \x3d temp__5804__auto___22254;\nif(cljs.core.chunked_seq_QMARK_(seq__21934_22256__$1)){\nvar c__5525__auto___22257 \x3d cljs.core.chunk_first(seq__21934_22256__$1);\nvar G__22258 \x3d cljs.core.chunk_rest(seq__21934_22256__$1);\nvar G__22259 \x3d c__5525__auto___22257;\nvar G__22260 \x3d cljs.core.count(c__5525__auto___22257);\nvar G__22261 \x3d (0);\nseq__21934_22240 \x3d G__22258;\nchunk__21935_22241 \x3d G__22259;\ncount__21936_22242 \x3d G__22260;\ni__21937_22243 \x3d G__22261;\ncontinue;\n} else {\nvar cb_22264 \x3d cljs.core.first(seq__21934_22256__$1);\ncljs.core.async.impl.dispatch.run(((function (seq__21934_22240,chunk__21935_22241,count__21936_22242,i__21937_22243,cb_22264,seq__21934_22256__$1,temp__5804__auto___22254,val,vec__21892,done_QMARK_,cbs,take_cb,temp__5802__auto__,this$__$1){\nreturn (function (){\nreturn (cb_22264.cljs$core$IFn$_invoke$arity$1 ? cb_22264.cljs$core$IFn$_invoke$arity$1(true) : cb_22264.call(null, true));\n});})(seq__21934_22240,chunk__21935_22241,count__21936_22242,i__21937_22243,cb_22264,seq__21934_22256__$1,temp__5804__auto___22254,val,vec__21892,done_QMARK_,cbs,take_cb,temp__5802__auto__,this$__$1))\n);\n\n\nvar G__22267 \x3d cljs.core.next(seq__21934_22256__$1);\nvar G__22268 \x3d null;\nvar G__22269 \x3d (0);\nvar G__22270 \x3d (0);\nseq__21934_22240 \x3d G__22267;\nchunk__21935_22241 \x3d G__22268;\ncount__21936_22242 \x3d G__22269;\ni__21937_22243 \x3d G__22270;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn cljs.core.async.impl.channels.box(val);\n} else {\nreturn null;\n}\n} else {\nvar putter \x3d (function (){while(true){\nvar putter \x3d self__.puts.pop();\nif(cljs.core.truth_(putter)){\nif(cljs.core.async.impl.protocols.active_QMARK_(putter.handler)){\nreturn putter;\n} else {\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n})();\nif(cljs.core.truth_(putter)){\nvar put_cb \x3d cljs.core.async.impl.protocols.commit(putter.handler);\nhandler.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\n\ncljs.core.async.impl.dispatch.run((function (){\nreturn (put_cb.cljs$core$IFn$_invoke$arity$1 ? put_cb.cljs$core$IFn$_invoke$arity$1(true) : put_cb.call(null, true));\n}));\n\nreturn cljs.core.async.impl.channels.box(putter.val);\n} else {\nif(cljs.core.truth_(self__.closed)){\nif(cljs.core.truth_(self__.buf)){\n(self__.add_BANG_.cljs$core$IFn$_invoke$arity$1 ? self__.add_BANG_.cljs$core$IFn$_invoke$arity$1(self__.buf) : self__.add_BANG_.call(null, self__.buf));\n} else {\n}\n\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d handler.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, );\nif(cljs.core.truth_(and__5000__auto__)){\nreturn handler.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\n} else {\nreturn and__5000__auto__;\n}\n})())){\nvar has_val \x3d (function (){var and__5000__auto__ \x3d self__.buf;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (cljs.core.count(self__.buf) \x3e (0));\n} else {\nreturn and__5000__auto__;\n}\n})();\nvar val \x3d (cljs.core.truth_(has_val)?self__.buf.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1(null, ):null);\nreturn cljs.core.async.impl.channels.box(val);\n} else {\nreturn null;\n}\n} else {\nif((self__.dirty_takes \x3e (64))){\n(self__.dirty_takes \x3d (0));\n\nself__.takes.cleanup(cljs.core.async.impl.protocols.active_QMARK_);\n} else {\n(self__.dirty_takes \x3d (self__.dirty_takes + (1)));\n}\n\nif(cljs.core.truth_(handler.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1(null, ))){\nif((self__.takes.length \x3c (1024))){\n} else {\nthrow (new Error([\x22Assert failed: \x22,[\x22No more than \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((1024)),\x22 pending takes are allowed on a single channel.\x22].join(\x27\x27),\x22\\n\x22,\x22(\x3c (.-length takes) impl/MAX-QUEUE-SIZE)\x22].join(\x27\x27)));\n}\n\nself__.takes.unbounded_unshift(handler);\n} else {\n}\n\nreturn null;\n}\n}\n}\n}\n}));\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$protocols$Channel$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$protocols$Channel$closed_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.closed;\n}));\n\n(cljs.core.async.impl.channels.ManyToManyChannel.prototype.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif(self__.closed){\nreturn null;\n} else {\n(self__.closed \x3d true);\n\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d self__.buf;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (self__.puts.length \x3d\x3d\x3d (0));\n} else {\nreturn and__5000__auto__;\n}\n})())){\n(self__.add_BANG_.cljs$core$IFn$_invoke$arity$1 ? self__.add_BANG_.cljs$core$IFn$_invoke$arity$1(self__.buf) : self__.add_BANG_.call(null, self__.buf));\n} else {\n}\n\nwhile(true){\nvar taker_22306 \x3d self__.takes.pop();\nif((taker_22306 \x3d\x3d null)){\n} else {\nif(taker_22306.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, )){\nvar take_cb_22308 \x3d taker_22306.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\nvar val_22309 \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d self__.buf;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (cljs.core.count(self__.buf) \x3e (0));\n} else {\nreturn and__5000__auto__;\n}\n})())?self__.buf.cljs$core$async$impl$protocols$Buffer$remove_BANG_$arity$1(null, ):null);\ncljs.core.async.impl.dispatch.run(((function (take_cb_22308,val_22309,taker_22306,this$__$1){\nreturn (function (){\nreturn (take_cb_22308.cljs$core$IFn$_invoke$arity$1 ? take_cb_22308.cljs$core$IFn$_invoke$arity$1(val_22309) : take_cb_22308.call(null, val_22309));\n});})(take_cb_22308,val_22309,taker_22306,this$__$1))\n);\n} else {\n}\n\ncontinue;\n}\nbreak;\n}\n\nif(cljs.core.truth_(self__.buf)){\nself__.buf.cljs$core$async$impl$protocols$Buffer$close_buf_BANG_$arity$1(null, );\n} else {\n}\n\nreturn null;\n}\n}));\n\n(cljs.core.async.impl.channels.ManyToManyChannel.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 7, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22takes\x22,\x22takes\x22,298247964,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22dirty-takes\x22,\x22dirty-takes\x22,575642138,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22puts\x22,\x22puts\x22,-1883877054,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22dirty-puts\x22,\x22dirty-puts\x22,57041148,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22buf\x22,\x22buf\x22,1426618187,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22not-native\x22,\x22not-native\x22,-236392494,null)], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22closed\x22,\x22closed\x22,720856168,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22add!\x22,\x22add!\x22,2046056845,null)], null);\n}));\n\n(cljs.core.async.impl.channels.ManyToManyChannel.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.channels.ManyToManyChannel.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.channels/ManyToManyChannel\x22);\n\n(cljs.core.async.impl.channels.ManyToManyChannel.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.channels/ManyToManyChannel\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.channels/ManyToManyChannel.\n */\ncljs.core.async.impl.channels.__GT_ManyToManyChannel \x3d (function cljs$core$async$impl$channels$__GT_ManyToManyChannel(takes,dirty_takes,puts,dirty_puts,buf,closed,add_BANG_){\nreturn (new cljs.core.async.impl.channels.ManyToManyChannel(takes,dirty_takes,puts,dirty_puts,buf,closed,add_BANG_));\n});\n\ncljs.core.async.impl.channels.ex_handler \x3d (function cljs$core$async$impl$channels$ex_handler(ex){\nconsole.log(ex);\n\nreturn null;\n});\ncljs.core.async.impl.channels.handle \x3d (function cljs$core$async$impl$channels$handle(buf,exh,t){\nvar else$ \x3d (function (){var fexpr__22034 \x3d (function (){var or__5002__auto__ \x3d exh;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.async.impl.channels.ex_handler;\n}\n})();\nreturn (fexpr__22034.cljs$core$IFn$_invoke$arity$1 ? fexpr__22034.cljs$core$IFn$_invoke$arity$1(t) : fexpr__22034.call(null, t));\n})();\nif((else$ \x3d\x3d null)){\nreturn buf;\n} else {\nreturn cljs.core.async.impl.protocols.add_BANG_.cljs$core$IFn$_invoke$arity$2(buf,else$);\n}\n});\ncljs.core.async.impl.channels.chan \x3d (function cljs$core$async$impl$channels$chan(var_args){\nvar G__22063 \x3d arguments.length;\nswitch (G__22063) {\ncase 1:\nreturn cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$1 \x3d (function (buf){\nreturn cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$2(buf,null);\n}));\n\n(cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$2 \x3d (function (buf,xform){\nreturn cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$3(buf,xform,null);\n}));\n\n(cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$3 \x3d (function (buf,xform,exh){\nreturn (new cljs.core.async.impl.channels.ManyToManyChannel(cljs.core.async.impl.buffers.ring_buffer((32)),(0),cljs.core.async.impl.buffers.ring_buffer((32)),(0),buf,false,(function (){var add_BANG_ \x3d (cljs.core.truth_(xform)?(xform.cljs$core$IFn$_invoke$arity$1 ? xform.cljs$core$IFn$_invoke$arity$1(cljs.core.async.impl.protocols.add_BANG_) : xform.call(null, cljs.core.async.impl.protocols.add_BANG_)):cljs.core.async.impl.protocols.add_BANG_);\nreturn (function() {\nvar G__22339 \x3d null;\nvar G__22339__1 \x3d (function (buf__$1){\ntry{return (add_BANG_.cljs$core$IFn$_invoke$arity$1 ? add_BANG_.cljs$core$IFn$_invoke$arity$1(buf__$1) : add_BANG_.call(null, buf__$1));\n}catch (e22099){var t \x3d e22099;\nreturn cljs.core.async.impl.channels.handle(buf__$1,exh,t);\n}});\nvar G__22339__2 \x3d (function (buf__$1,val){\ntry{return (add_BANG_.cljs$core$IFn$_invoke$arity$2 ? add_BANG_.cljs$core$IFn$_invoke$arity$2(buf__$1,val) : add_BANG_.call(null, buf__$1,val));\n}catch (e22107){var t \x3d e22107;\nreturn cljs.core.async.impl.channels.handle(buf__$1,exh,t);\n}});\nG__22339 \x3d function(buf__$1,val){\nswitch(arguments.length){\ncase 1:\nreturn G__22339__1.call(this,buf__$1);\ncase 2:\nreturn G__22339__2.call(this,buf__$1,val);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__22339.cljs$core$IFn$_invoke$arity$1 \x3d G__22339__1;\nG__22339.cljs$core$IFn$_invoke$arity$2 \x3d G__22339__2;\nreturn G__22339;\n})()\n})()));\n}));\n\n(cljs.core.async.impl.channels.chan.cljs$lang$maxFixedArity \x3d 3);\n\n");
SHADOW_ENV.evalLoad("cljs.core.async.impl.timers.js", true, "goog.provide(\x27cljs.core.async.impl.timers\x27);\ncljs.core.async.impl.timers.MAX_LEVEL \x3d (15);\ncljs.core.async.impl.timers.P \x3d ((1) / (2));\ncljs.core.async.impl.timers.random_level \x3d (function cljs$core$async$impl$timers$random_level(var_args){\nvar G__22208 \x3d arguments.length;\nswitch (G__22208) {\ncase 0:\nreturn cljs.core.async.impl.timers.random_level.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.async.impl.timers.random_level.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.impl.timers.random_level.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.async.impl.timers.random_level.cljs$core$IFn$_invoke$arity$1((0));\n}));\n\n(cljs.core.async.impl.timers.random_level.cljs$core$IFn$_invoke$arity$1 \x3d (function (level){\nwhile(true){\nif((((Math.random() \x3c cljs.core.async.impl.timers.P)) \x26\x26 ((level \x3c cljs.core.async.impl.timers.MAX_LEVEL)))){\nvar G__22429 \x3d (level + (1));\nlevel \x3d G__22429;\ncontinue;\n} else {\nreturn level;\n}\nbreak;\n}\n}));\n\n(cljs.core.async.impl.timers.random_level.cljs$lang$maxFixedArity \x3d 1);\n\n\n/**\n* @constructor\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IPrintWithWriter}\n*/\ncljs.core.async.impl.timers.SkipListNode \x3d (function (key,val,forward){\nthis.key \x3d key;\nthis.val \x3d val;\nthis.forward \x3d forward;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2155872256;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.timers.SkipListNode.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn (new cljs.core.List(null,self__.key,(new cljs.core.List(null,self__.val,null,(1),null)),(2),null));\n}));\n\n(cljs.core.async.impl.timers.SkipListNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22[\x22,\x22 \x22,\x22]\x22,opts,coll__$1);\n}));\n\n(cljs.core.async.impl.timers.SkipListNode.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22key\x22,\x22key\x22,124488940,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22val\x22,\x22val\x22,1769233139,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22forward\x22,\x22forward\x22,1083186224,null)], null);\n}));\n\n(cljs.core.async.impl.timers.SkipListNode.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.timers.SkipListNode.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.timers/SkipListNode\x22);\n\n(cljs.core.async.impl.timers.SkipListNode.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.timers/SkipListNode\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.timers/SkipListNode.\n */\ncljs.core.async.impl.timers.__GT_SkipListNode \x3d (function cljs$core$async$impl$timers$__GT_SkipListNode(key,val,forward){\nreturn (new cljs.core.async.impl.timers.SkipListNode(key,val,forward));\n});\n\ncljs.core.async.impl.timers.skip_list_node \x3d (function cljs$core$async$impl$timers$skip_list_node(var_args){\nvar G__22280 \x3d arguments.length;\nswitch (G__22280) {\ncase 1:\nreturn cljs.core.async.impl.timers.skip_list_node.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.impl.timers.skip_list_node.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.impl.timers.skip_list_node.cljs$core$IFn$_invoke$arity$1 \x3d (function (level){\nreturn cljs.core.async.impl.timers.skip_list_node.cljs$core$IFn$_invoke$arity$3(null,null,level);\n}));\n\n(cljs.core.async.impl.timers.skip_list_node.cljs$core$IFn$_invoke$arity$3 \x3d (function (k,v,level){\nvar arr \x3d (new Array((level + (1))));\nvar i_22438 \x3d (0);\nwhile(true){\nif((i_22438 \x3c arr.length)){\n(arr[i_22438] \x3d null);\n\nvar G__22443 \x3d (i_22438 + (1));\ni_22438 \x3d G__22443;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn (new cljs.core.async.impl.timers.SkipListNode(k,v,arr));\n}));\n\n(cljs.core.async.impl.timers.skip_list_node.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.async.impl.timers.least_greater_node \x3d (function cljs$core$async$impl$timers$least_greater_node(var_args){\nvar G__22307 \x3d arguments.length;\nswitch (G__22307) {\ncase 3:\nreturn cljs.core.async.impl.timers.least_greater_node.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.async.impl.timers.least_greater_node.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.impl.timers.least_greater_node.cljs$core$IFn$_invoke$arity$3 \x3d (function (x,k,level){\nreturn cljs.core.async.impl.timers.least_greater_node.cljs$core$IFn$_invoke$arity$4(x,k,level,null);\n}));\n\n(cljs.core.async.impl.timers.least_greater_node.cljs$core$IFn$_invoke$arity$4 \x3d (function (x,k,level,update){\nwhile(true){\nif((!((level \x3c (0))))){\nvar x__$1 \x3d (function (){var x__$1 \x3d x;\nwhile(true){\nvar temp__5802__auto__ \x3d (((level \x3c x__$1.forward.length))?(x__$1.forward[level]):null);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar x_SINGLEQUOTE_ \x3d temp__5802__auto__;\nif((x_SINGLEQUOTE_.key \x3c k)){\nvar G__22465 \x3d x_SINGLEQUOTE_;\nx__$1 \x3d G__22465;\ncontinue;\n} else {\nreturn x__$1;\n}\n} else {\nreturn x__$1;\n}\nbreak;\n}\n})();\nif((update \x3d\x3d null)){\n} else {\n(update[level] \x3d x__$1);\n}\n\nvar G__22466 \x3d x__$1;\nvar G__22467 \x3d k;\nvar G__22468 \x3d (level - (1));\nvar G__22469 \x3d update;\nx \x3d G__22466;\nk \x3d G__22467;\nlevel \x3d G__22468;\nupdate \x3d G__22469;\ncontinue;\n} else {\nreturn x;\n}\nbreak;\n}\n}));\n\n(cljs.core.async.impl.timers.least_greater_node.cljs$lang$maxFixedArity \x3d 4);\n\n\n/**\n* @constructor\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IPrintWithWriter}\n*/\ncljs.core.async.impl.timers.SkipList \x3d (function (header,level){\nthis.header \x3d header;\nthis.level \x3d level;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2155872256;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.timers.SkipList.prototype.put \x3d (function (k,v){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar update \x3d (new Array(cljs.core.async.impl.timers.MAX_LEVEL));\nvar x \x3d cljs.core.async.impl.timers.least_greater_node.cljs$core$IFn$_invoke$arity$4(self__.header,k,self__.level,update);\nvar x__$1 \x3d (x.forward[(0)]);\nif((((!((x__$1 \x3d\x3d null)))) \x26\x26 ((x__$1.key \x3d\x3d\x3d k)))){\nreturn (x__$1.val \x3d v);\n} else {\nvar new_level \x3d cljs.core.async.impl.timers.random_level.cljs$core$IFn$_invoke$arity$0();\nif((new_level \x3e self__.level)){\nvar i_22470 \x3d (self__.level + (1));\nwhile(true){\nif((i_22470 \x3c\x3d (new_level + (1)))){\n(update[i_22470] \x3d self__.header);\n\nvar G__22471 \x3d (i_22470 + (1));\ni_22470 \x3d G__22471;\ncontinue;\n} else {\n}\nbreak;\n}\n\n(self__.level \x3d new_level);\n} else {\n}\n\nvar x__$2 \x3d cljs.core.async.impl.timers.skip_list_node.cljs$core$IFn$_invoke$arity$3(k,v,(new Array(new_level)));\nvar i \x3d (0);\nwhile(true){\nif((i \x3c\x3d self__.level)){\nvar links_22476 \x3d (update[i]).forward;\nif((i \x3c x__$2.forward.length)){\n(x__$2.forward[i] \x3d (links_22476[i]));\n} else {\nx__$2.forward.push((((i \x3c links_22476.length))?(links_22476[i]):null));\n}\n\nif((i \x3c links_22476.length)){\n(links_22476[i] \x3d x__$2);\n} else {\nlinks_22476.push(x__$2);\n}\n\nvar G__22478 \x3d (i + (1));\ni \x3d G__22478;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}\n}));\n\n(cljs.core.async.impl.timers.SkipList.prototype.remove \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar update \x3d (new Array(cljs.core.async.impl.timers.MAX_LEVEL));\nvar x \x3d cljs.core.async.impl.timers.least_greater_node.cljs$core$IFn$_invoke$arity$4(self__.header,k,self__.level,update);\nvar x__$1 \x3d (((x.forward.length \x3d\x3d\x3d (0)))?null:(x.forward[(0)]));\nif((((!((x__$1 \x3d\x3d null)))) \x26\x26 ((x__$1.key \x3d\x3d\x3d k)))){\nvar i_22482 \x3d (0);\nwhile(true){\nif((i_22482 \x3c\x3d self__.level)){\nvar links_22483 \x3d (update[i_22482]).forward;\nif((x__$1 \x3d\x3d\x3d (((i_22482 \x3c links_22483.length))?(links_22483[i_22482]):null))){\n(links_22483[i_22482] \x3d (x__$1.forward[i_22482]));\n\nvar G__22486 \x3d (i_22482 + (1));\ni_22482 \x3d G__22486;\ncontinue;\n} else {\nvar G__22487 \x3d (i_22482 + (1));\ni_22482 \x3d G__22487;\ncontinue;\n}\n} else {\n}\nbreak;\n}\n\nwhile(true){\nif(((((((0) \x3c self__.level)) \x26\x26 ((self__.level \x3c self__.header.forward.length)))) \x26\x26 (((self__.header.forward[self__.level]) \x3d\x3d null)))){\n(self__.level \x3d (self__.level - (1)));\n\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.async.impl.timers.SkipList.prototype.ceilingEntry \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar x \x3d self__.header;\nvar level__$1 \x3d self__.level;\nwhile(true){\nif((!((level__$1 \x3c (0))))){\nvar nx \x3d (function (){var x__$1 \x3d x;\nwhile(true){\nvar x_SINGLEQUOTE_ \x3d (((level__$1 \x3c x__$1.forward.length))?(x__$1.forward[level__$1]):null);\nif((!((x_SINGLEQUOTE_ \x3d\x3d null)))){\nif((x_SINGLEQUOTE_.key \x3e k)){\nreturn x__$1;\n} else {\nvar G__22498 \x3d x_SINGLEQUOTE_;\nx__$1 \x3d G__22498;\ncontinue;\n}\n} else {\nif((level__$1 \x3d\x3d\x3d (0))){\nreturn x__$1;\n} else {\nreturn null;\n}\n}\nbreak;\n}\n})();\nif(cljs.core.truth_(nx)){\nvar G__22502 \x3d nx;\nvar G__22503 \x3d (level__$1 - (1));\nx \x3d G__22502;\nlevel__$1 \x3d G__22503;\ncontinue;\n} else {\nvar G__22504 \x3d x;\nvar G__22505 \x3d (level__$1 - (1));\nx \x3d G__22504;\nlevel__$1 \x3d G__22505;\ncontinue;\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x.key,k)){\nreturn x;\n} else {\nreturn (x.forward[(0)]);\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.async.impl.timers.SkipList.prototype.floorEntry \x3d (function (k){\nvar self__ \x3d this;\nvar coll \x3d this;\nvar x \x3d self__.header;\nvar level__$1 \x3d self__.level;\nwhile(true){\nif((!((level__$1 \x3c (0))))){\nvar nx \x3d (function (){var x__$1 \x3d x;\nwhile(true){\nvar x_SINGLEQUOTE_ \x3d (((level__$1 \x3c x__$1.forward.length))?(x__$1.forward[level__$1]):null);\nif((!((x_SINGLEQUOTE_ \x3d\x3d null)))){\nif((x_SINGLEQUOTE_.key \x3e k)){\nreturn x__$1;\n} else {\nvar G__22513 \x3d x_SINGLEQUOTE_;\nx__$1 \x3d G__22513;\ncontinue;\n}\n} else {\nif((level__$1 \x3d\x3d\x3d (0))){\nreturn x__$1;\n} else {\nreturn null;\n}\n}\nbreak;\n}\n})();\nif(cljs.core.truth_(nx)){\nvar G__22515 \x3d nx;\nvar G__22516 \x3d (level__$1 - (1));\nx \x3d G__22515;\nlevel__$1 \x3d G__22516;\ncontinue;\n} else {\nvar G__22521 \x3d x;\nvar G__22522 \x3d (level__$1 - (1));\nx \x3d G__22521;\nlevel__$1 \x3d G__22522;\ncontinue;\n}\n} else {\nif((x \x3d\x3d\x3d self__.header)){\nreturn null;\n} else {\nreturn x;\n}\n}\nbreak;\n}\n}));\n\n(cljs.core.async.impl.timers.SkipList.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (coll){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar iter \x3d (function cljs$core$async$impl$timers$iter(node){\nreturn (new cljs.core.LazySeq(null,(function (){\nif((node \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [node.key,node.val], null),cljs$core$async$impl$timers$iter((node.forward[(0)])));\n}\n}),null,null));\n});\nreturn iter((self__.header.forward[(0)]));\n}));\n\n(cljs.core.async.impl.timers.SkipList.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (coll,writer,opts){\nvar self__ \x3d this;\nvar coll__$1 \x3d this;\nvar pr_pair \x3d (function (keyval){\nreturn cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts,keyval);\n});\nreturn cljs.core.pr_sequential_writer(writer,pr_pair,\x22{\x22,\x22, \x22,\x22}\x22,opts,coll__$1);\n}));\n\n(cljs.core.async.impl.timers.SkipList.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22header\x22,\x22header\x22,1759972661,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22level\x22,\x22level\x22,-1363938217,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.core.async.impl.timers.SkipList.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.timers.SkipList.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.timers/SkipList\x22);\n\n(cljs.core.async.impl.timers.SkipList.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.timers/SkipList\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.timers/SkipList.\n */\ncljs.core.async.impl.timers.__GT_SkipList \x3d (function cljs$core$async$impl$timers$__GT_SkipList(header,level){\nreturn (new cljs.core.async.impl.timers.SkipList(header,level));\n});\n\ncljs.core.async.impl.timers.skip_list \x3d (function cljs$core$async$impl$timers$skip_list(){\nreturn (new cljs.core.async.impl.timers.SkipList(cljs.core.async.impl.timers.skip_list_node.cljs$core$IFn$_invoke$arity$1((0)),(0)));\n});\ncljs.core.async.impl.timers.timeouts_map \x3d cljs.core.async.impl.timers.skip_list();\ncljs.core.async.impl.timers.TIMEOUT_RESOLUTION_MS \x3d (10);\n/**\n * returns a channel that will close after msecs\n */\ncljs.core.async.impl.timers.timeout \x3d (function cljs$core$async$impl$timers$timeout(msecs){\nvar timeout \x3d ((new Date()).valueOf() + msecs);\nvar me \x3d cljs.core.async.impl.timers.timeouts_map.ceilingEntry(timeout);\nvar or__5002__auto__ \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d me;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (me.key \x3c (timeout + cljs.core.async.impl.timers.TIMEOUT_RESOLUTION_MS));\n} else {\nreturn and__5000__auto__;\n}\n})())?me.val:null);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar timeout_channel \x3d cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$1(null);\ncljs.core.async.impl.timers.timeouts_map.put(timeout,timeout_channel);\n\ncljs.core.async.impl.dispatch.queue_delay((function (){\ncljs.core.async.impl.timers.timeouts_map.remove(timeout);\n\nreturn cljs.core.async.impl.protocols.close_BANG_(timeout_channel);\n}),msecs);\n\nreturn timeout_channel;\n}\n});\n");
SHADOW_ENV.evalLoad("cljs.core.async.impl.ioc_helpers.js", true, "goog.provide(\x27cljs.core.async.impl.ioc_helpers\x27);\ncljs.core.async.impl.ioc_helpers.FN_IDX \x3d (0);\ncljs.core.async.impl.ioc_helpers.STATE_IDX \x3d (1);\ncljs.core.async.impl.ioc_helpers.VALUE_IDX \x3d (2);\ncljs.core.async.impl.ioc_helpers.BINDINGS_IDX \x3d (3);\ncljs.core.async.impl.ioc_helpers.EXCEPTION_FRAMES \x3d (4);\ncljs.core.async.impl.ioc_helpers.CURRENT_EXCEPTION \x3d (5);\ncljs.core.async.impl.ioc_helpers.USER_START_IDX \x3d (6);\ncljs.core.async.impl.ioc_helpers.aset_object \x3d (function cljs$core$async$impl$ioc_helpers$aset_object(arr,idx,o){\nreturn (arr[idx][o]);\n});\ncljs.core.async.impl.ioc_helpers.aget_object \x3d (function cljs$core$async$impl$ioc_helpers$aget_object(arr,idx){\nreturn (arr[idx]);\n});\n/**\n * Returns true if the machine is in a finished state\n */\ncljs.core.async.impl.ioc_helpers.finished_QMARK_ \x3d (function cljs$core$async$impl$ioc_helpers$finished_QMARK_(state_array){\nreturn cljs.core.keyword_identical_QMARK_((state_array[(1)]),new cljs.core.Keyword(null,\x22finished\x22,\x22finished\x22,-1018867731));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Handler}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592 \x3d (function (f,meta21593){\nthis.f \x3d f;\nthis.meta21593 \x3d meta21593;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_21594,meta21593__$1){\nvar self__ \x3d this;\nvar _21594__$1 \x3d this;\nreturn (new cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592(self__.f,meta21593__$1));\n}));\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_21594){\nvar self__ \x3d this;\nvar _21594__$1 \x3d this;\nreturn self__.meta21593;\n}));\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.prototype.cljs$core$async$impl$protocols$Handler$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.prototype.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn true;\n}));\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.prototype.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn true;\n}));\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.prototype.cljs$core$async$impl$protocols$Handler$commit$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.f;\n}));\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),new cljs.core.Symbol(null,\x22meta21593\x22,\x22meta21593\x22,-507229830,null)], null);\n}));\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.cljs$lang$type \x3d true);\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.cljs$lang$ctorStr \x3d \x22cljs.core.async.impl.ioc-helpers/t_cljs$core$async$impl$ioc_helpers21592\x22);\n\n(cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async.impl.ioc-helpers/t_cljs$core$async$impl$ioc_helpers21592\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async.impl.ioc-helpers/t_cljs$core$async$impl$ioc_helpers21592.\n */\ncljs.core.async.impl.ioc_helpers.__GT_t_cljs$core$async$impl$ioc_helpers21592 \x3d (function cljs$core$async$impl$ioc_helpers$__GT_t_cljs$core$async$impl$ioc_helpers21592(f,meta21593){\nreturn (new cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592(f,meta21593));\n});\n\n\ncljs.core.async.impl.ioc_helpers.fn_handler \x3d (function cljs$core$async$impl$ioc_helpers$fn_handler(f){\nreturn (new cljs.core.async.impl.ioc_helpers.t_cljs$core$async$impl$ioc_helpers21592(f,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.core.async.impl.ioc_helpers.run_state_machine \x3d (function cljs$core$async$impl$ioc_helpers$run_state_machine(state){\nvar fexpr__21625 \x3d cljs.core.async.impl.ioc_helpers.aget_object(state,(0));\nreturn (fexpr__21625.cljs$core$IFn$_invoke$arity$1 ? fexpr__21625.cljs$core$IFn$_invoke$arity$1(state) : fexpr__21625.call(null, state));\n});\ncljs.core.async.impl.ioc_helpers.run_state_machine_wrapped \x3d (function cljs$core$async$impl$ioc_helpers$run_state_machine_wrapped(state){\ntry{return cljs.core.async.impl.ioc_helpers.run_state_machine(state);\n}catch (e21634){if((e21634 instanceof Object)){\nvar ex \x3d e21634;\ncljs.core.async.impl.ioc_helpers.aget_object(state,(6)).cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1(null, );\n\nthrow ex;\n} else {\nthrow e21634;\n\n}\n}});\ncljs.core.async.impl.ioc_helpers.take_BANG_ \x3d (function cljs$core$async$impl$ioc_helpers$take_BANG_(state,blk,c){\nvar temp__5802__auto__ \x3d c.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2(null, cljs.core.async.impl.ioc_helpers.fn_handler((function (x){\nvar statearr_21645_21697 \x3d state;\n(statearr_21645_21697[(2)] \x3d x);\n\n(statearr_21645_21697[(1)] \x3d blk);\n\n\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state);\n})));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar cb \x3d temp__5802__auto__;\nvar statearr_21648_21700 \x3d state;\n(statearr_21648_21700[(2)] \x3d cljs.core.deref(cb));\n\n(statearr_21648_21700[(1)] \x3d blk);\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n});\ncljs.core.async.impl.ioc_helpers.put_BANG_ \x3d (function cljs$core$async$impl$ioc_helpers$put_BANG_(state,blk,c,val){\nvar temp__5802__auto__ \x3d c.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3(null, val,cljs.core.async.impl.ioc_helpers.fn_handler((function (ret_val){\nvar statearr_21657_21703 \x3d state;\n(statearr_21657_21703[(2)] \x3d ret_val);\n\n(statearr_21657_21703[(1)] \x3d blk);\n\n\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state);\n})));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar cb \x3d temp__5802__auto__;\nvar statearr_21662_21704 \x3d state;\n(statearr_21662_21704[(2)] \x3d cljs.core.deref(cb));\n\n(statearr_21662_21704[(1)] \x3d blk);\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n});\ncljs.core.async.impl.ioc_helpers.return_chan \x3d (function cljs$core$async$impl$ioc_helpers$return_chan(state,value){\nvar c \x3d (state[(6)]);\nif((value \x3d\x3d null)){\n} else {\nc.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3(null, value,cljs.core.async.impl.ioc_helpers.fn_handler((function (_){\nreturn null;\n})));\n}\n\nc.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1(null, );\n\nreturn c;\n});\n");
SHADOW_ENV.evalLoad("cljs.core.async.js", true, "goog.provide(\x27cljs.core.async\x27);\ngoog.scope(function(){\n  cljs.core.async.goog$module$goog$array \x3d goog.module.get(\x27goog.array\x27);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Handler}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async22742 \x3d (function (f,blockable,meta22743){\nthis.f \x3d f;\nthis.blockable \x3d blockable;\nthis.meta22743 \x3d meta22743;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async22742.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_22744,meta22743__$1){\nvar self__ \x3d this;\nvar _22744__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async22742(self__.f,self__.blockable,meta22743__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async22742.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_22744){\nvar self__ \x3d this;\nvar _22744__$1 \x3d this;\nreturn self__.meta22743;\n}));\n\n(cljs.core.async.t_cljs$core$async22742.prototype.cljs$core$async$impl$protocols$Handler$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async22742.prototype.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn true;\n}));\n\n(cljs.core.async.t_cljs$core$async22742.prototype.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.blockable;\n}));\n\n(cljs.core.async.t_cljs$core$async22742.prototype.cljs$core$async$impl$protocols$Handler$commit$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.f;\n}));\n\n(cljs.core.async.t_cljs$core$async22742.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),new cljs.core.Symbol(null,\x22blockable\x22,\x22blockable\x22,-28395259,null),new cljs.core.Symbol(null,\x22meta22743\x22,\x22meta22743\x22,-204130493,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async22742.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async22742.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async22742\x22);\n\n(cljs.core.async.t_cljs$core$async22742.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async22742\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async22742.\n */\ncljs.core.async.__GT_t_cljs$core$async22742 \x3d (function cljs$core$async$__GT_t_cljs$core$async22742(f,blockable,meta22743){\nreturn (new cljs.core.async.t_cljs$core$async22742(f,blockable,meta22743));\n});\n\n\ncljs.core.async.fn_handler \x3d (function cljs$core$async$fn_handler(var_args){\nvar G__22740 \x3d arguments.length;\nswitch (G__22740) {\ncase 1:\nreturn cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$1 \x3d (function (f){\nreturn cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$2(f,true);\n}));\n\n(cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,blockable){\nreturn (new cljs.core.async.t_cljs$core$async22742(f,blockable,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(cljs.core.async.fn_handler.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a fixed buffer of size n. When full, puts will block/park.\n */\ncljs.core.async.buffer \x3d (function cljs$core$async$buffer(n){\nreturn cljs.core.async.impl.buffers.fixed_buffer(n);\n});\n/**\n * Returns a buffer of size n. When full, puts will complete but\n *   val will be dropped (no transfer).\n */\ncljs.core.async.dropping_buffer \x3d (function cljs$core$async$dropping_buffer(n){\nreturn cljs.core.async.impl.buffers.dropping_buffer(n);\n});\n/**\n * Returns a buffer of size n. When full, puts will complete, and be\n *   buffered, but oldest elements in buffer will be dropped (not\n *   transferred).\n */\ncljs.core.async.sliding_buffer \x3d (function cljs$core$async$sliding_buffer(n){\nreturn cljs.core.async.impl.buffers.sliding_buffer(n);\n});\n/**\n * Returns true if a channel created with buff will never block. That is to say,\n * puts into this buffer will never cause the buffer to be full. \n */\ncljs.core.async.unblocking_buffer_QMARK_ \x3d (function cljs$core$async$unblocking_buffer_QMARK_(buff){\nif((!((buff \x3d\x3d null)))){\nif(((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d buff.cljs$core$async$impl$protocols$UnblockingBuffer$)))){\nreturn true;\n} else {\nif((!buff.cljs$lang$protocol_mask$partition$)){\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.async.impl.protocols.UnblockingBuffer,buff);\n} else {\nreturn false;\n}\n}\n} else {\nreturn cljs.core.native_satisfies_QMARK_(cljs.core.async.impl.protocols.UnblockingBuffer,buff);\n}\n});\n/**\n * Creates a channel with an optional buffer, an optional transducer (like (map f),\n *   (filter p) etc or a composition thereof), and an optional exception handler.\n *   If buf-or-n is a number, will create and use a fixed buffer of that size. If a\n *   transducer is supplied a buffer must be specified. ex-handler must be a\n *   fn of one argument - if an exception occurs during transformation it will be called\n *   with the thrown value as an argument, and any non-nil return value will be placed\n *   in the channel.\n */\ncljs.core.async.chan \x3d (function cljs$core$async$chan(var_args){\nvar G__22764 \x3d arguments.length;\nswitch (G__22764) {\ncase 0:\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.chan.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(null);\n}));\n\n(cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1 \x3d (function (buf_or_n){\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$3(buf_or_n,null,null);\n}));\n\n(cljs.core.async.chan.cljs$core$IFn$_invoke$arity$2 \x3d (function (buf_or_n,xform){\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$3(buf_or_n,xform,null);\n}));\n\n(cljs.core.async.chan.cljs$core$IFn$_invoke$arity$3 \x3d (function (buf_or_n,xform,ex_handler){\nvar buf_or_n__$1 \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(buf_or_n,(0)))?null:buf_or_n);\nif(cljs.core.truth_(xform)){\nif(cljs.core.truth_(buf_or_n__$1)){\n} else {\nthrow (new Error([\x22Assert failed: \x22,\x22buffer must be supplied when transducer is\x22,\x22\\n\x22,\x22buf-or-n\x22].join(\x27\x27)));\n}\n} else {\n}\n\nreturn cljs.core.async.impl.channels.chan.cljs$core$IFn$_invoke$arity$3(((typeof buf_or_n__$1 \x3d\x3d\x3d \x27number\x27)?cljs.core.async.buffer(buf_or_n__$1):buf_or_n__$1),xform,ex_handler);\n}));\n\n(cljs.core.async.chan.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Creates a promise channel with an optional transducer, and an optional\n *   exception-handler. A promise channel can take exactly one value that consumers\n *   will receive. Once full, puts complete but val is dropped (no transfer).\n *   Consumers will block until either a value is placed in the channel or the\n *   channel is closed. See chan for the semantics of xform and ex-handler.\n */\ncljs.core.async.promise_chan \x3d (function cljs$core$async$promise_chan(var_args){\nvar G__22772 \x3d arguments.length;\nswitch (G__22772) {\ncase 0:\nreturn cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$1(null);\n}));\n\n(cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$1 \x3d (function (xform){\nreturn cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$2(xform,null);\n}));\n\n(cljs.core.async.promise_chan.cljs$core$IFn$_invoke$arity$2 \x3d (function (xform,ex_handler){\nreturn cljs.core.async.chan.cljs$core$IFn$_invoke$arity$3(cljs.core.async.impl.buffers.promise_buffer(),xform,ex_handler);\n}));\n\n(cljs.core.async.promise_chan.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a channel that will close after msecs\n */\ncljs.core.async.timeout \x3d (function cljs$core$async$timeout(msecs){\nreturn cljs.core.async.impl.timers.timeout(msecs);\n});\n/**\n * takes a val from port. Must be called inside a (go ...) block. Will\n *   return nil if closed. Will park if nothing is available.\n *   Returns true unless port is already closed\n */\ncljs.core.async._LT__BANG_ \x3d (function cljs$core$async$_LT__BANG_(port){\nthrow (new Error(\x22\x3c! used not in (go ...) block\x22));\n});\n/**\n * Asynchronously takes a val from port, passing to fn1. Will pass nil\n * if closed. If on-caller? (default true) is true, and value is\n * immediately available, will call fn1 on calling thread.\n * Returns nil.\n */\ncljs.core.async.take_BANG_ \x3d (function cljs$core$async$take_BANG_(var_args){\nvar G__22787 \x3d arguments.length;\nswitch (G__22787) {\ncase 2:\nreturn cljs.core.async.take_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.take_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.take_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (port,fn1){\nreturn cljs.core.async.take_BANG_.cljs$core$IFn$_invoke$arity$3(port,fn1,true);\n}));\n\n(cljs.core.async.take_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (port,fn1,on_caller_QMARK_){\nvar ret \x3d cljs.core.async.impl.protocols.take_BANG_(port,cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$1(fn1));\nif(cljs.core.truth_(ret)){\nvar val_26883 \x3d cljs.core.deref(ret);\nif(cljs.core.truth_(on_caller_QMARK_)){\n(fn1.cljs$core$IFn$_invoke$arity$1 ? fn1.cljs$core$IFn$_invoke$arity$1(val_26883) : fn1.call(null, val_26883));\n} else {\ncljs.core.async.impl.dispatch.run((function (){\nreturn (fn1.cljs$core$IFn$_invoke$arity$1 ? fn1.cljs$core$IFn$_invoke$arity$1(val_26883) : fn1.call(null, val_26883));\n}));\n}\n} else {\n}\n\nreturn null;\n}));\n\n(cljs.core.async.take_BANG_.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.async.nop \x3d (function cljs$core$async$nop(_){\nreturn null;\n});\ncljs.core.async.fhnop \x3d cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$1(cljs.core.async.nop);\n/**\n * puts a val into port. nil values are not allowed. Must be called\n *   inside a (go ...) block. Will park if no buffer space is available.\n *   Returns true unless port is already closed.\n */\ncljs.core.async._GT__BANG_ \x3d (function cljs$core$async$_GT__BANG_(port,val){\nthrow (new Error(\x22\x3e! used not in (go ...) block\x22));\n});\n/**\n * Asynchronously puts a val into port, calling fn1 (if supplied) when\n * complete. nil values are not allowed. Will throw if closed. If\n * on-caller? (default true) is true, and the put is immediately\n * accepted, will call fn1 on calling thread.  Returns nil.\n */\ncljs.core.async.put_BANG_ \x3d (function cljs$core$async$put_BANG_(var_args){\nvar G__22811 \x3d arguments.length;\nswitch (G__22811) {\ncase 2:\nreturn cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (port,val){\nvar temp__5802__auto__ \x3d cljs.core.async.impl.protocols.put_BANG_(port,val,cljs.core.async.fhnop);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar ret \x3d temp__5802__auto__;\nreturn cljs.core.deref(ret);\n} else {\nreturn true;\n}\n}));\n\n(cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (port,val,fn1){\nreturn cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$4(port,val,fn1,true);\n}));\n\n(cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$4 \x3d (function (port,val,fn1,on_caller_QMARK_){\nvar temp__5802__auto__ \x3d cljs.core.async.impl.protocols.put_BANG_(port,val,cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$1(fn1));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar retb \x3d temp__5802__auto__;\nvar ret \x3d cljs.core.deref(retb);\nif(cljs.core.truth_(on_caller_QMARK_)){\n(fn1.cljs$core$IFn$_invoke$arity$1 ? fn1.cljs$core$IFn$_invoke$arity$1(ret) : fn1.call(null, ret));\n} else {\ncljs.core.async.impl.dispatch.run((function (){\nreturn (fn1.cljs$core$IFn$_invoke$arity$1 ? fn1.cljs$core$IFn$_invoke$arity$1(ret) : fn1.call(null, ret));\n}));\n}\n\nreturn ret;\n} else {\nreturn true;\n}\n}));\n\n(cljs.core.async.put_BANG_.cljs$lang$maxFixedArity \x3d 4);\n\ncljs.core.async.close_BANG_ \x3d (function cljs$core$async$close_BANG_(port){\nreturn cljs.core.async.impl.protocols.close_BANG_(port);\n});\ncljs.core.async.random_array \x3d (function cljs$core$async$random_array(n){\nvar a \x3d (new Array(n));\nvar n__5593__auto___26906 \x3d n;\nvar x_26907 \x3d (0);\nwhile(true){\nif((x_26907 \x3c n__5593__auto___26906)){\n(a[x_26907] \x3d x_26907);\n\nvar G__26908 \x3d (x_26907 + (1));\nx_26907 \x3d G__26908;\ncontinue;\n} else {\n}\nbreak;\n}\n\ncljs.core.async.goog$module$goog$array.shuffle(a);\n\nreturn a;\n});\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Handler}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async22843 \x3d (function (flag,meta22844){\nthis.flag \x3d flag;\nthis.meta22844 \x3d meta22844;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async22843.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_22845,meta22844__$1){\nvar self__ \x3d this;\nvar _22845__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async22843(self__.flag,meta22844__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async22843.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_22845){\nvar self__ \x3d this;\nvar _22845__$1 \x3d this;\nreturn self__.meta22844;\n}));\n\n(cljs.core.async.t_cljs$core$async22843.prototype.cljs$core$async$impl$protocols$Handler$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async22843.prototype.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.deref(self__.flag);\n}));\n\n(cljs.core.async.t_cljs$core$async22843.prototype.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn true;\n}));\n\n(cljs.core.async.t_cljs$core$async22843.prototype.cljs$core$async$impl$protocols$Handler$commit$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.reset_BANG_(self__.flag,null);\n\nreturn true;\n}));\n\n(cljs.core.async.t_cljs$core$async22843.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22flag\x22,\x22flag\x22,-1565787888,null),new cljs.core.Symbol(null,\x22meta22844\x22,\x22meta22844\x22,1623195629,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async22843.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async22843.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async22843\x22);\n\n(cljs.core.async.t_cljs$core$async22843.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async22843\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async22843.\n */\ncljs.core.async.__GT_t_cljs$core$async22843 \x3d (function cljs$core$async$__GT_t_cljs$core$async22843(flag,meta22844){\nreturn (new cljs.core.async.t_cljs$core$async22843(flag,meta22844));\n});\n\n\ncljs.core.async.alt_flag \x3d (function cljs$core$async$alt_flag(){\nvar flag \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(true);\nreturn (new cljs.core.async.t_cljs$core$async22843(flag,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Handler}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async22857 \x3d (function (flag,cb,meta22858){\nthis.flag \x3d flag;\nthis.cb \x3d cb;\nthis.meta22858 \x3d meta22858;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async22857.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_22859,meta22858__$1){\nvar self__ \x3d this;\nvar _22859__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async22857(self__.flag,self__.cb,meta22858__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async22857.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_22859){\nvar self__ \x3d this;\nvar _22859__$1 \x3d this;\nreturn self__.meta22858;\n}));\n\n(cljs.core.async.t_cljs$core$async22857.prototype.cljs$core$async$impl$protocols$Handler$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async22857.prototype.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.active_QMARK_(self__.flag);\n}));\n\n(cljs.core.async.t_cljs$core$async22857.prototype.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn true;\n}));\n\n(cljs.core.async.t_cljs$core$async22857.prototype.cljs$core$async$impl$protocols$Handler$commit$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.async.impl.protocols.commit(self__.flag);\n\nreturn self__.cb;\n}));\n\n(cljs.core.async.t_cljs$core$async22857.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22flag\x22,\x22flag\x22,-1565787888,null),new cljs.core.Symbol(null,\x22cb\x22,\x22cb\x22,-2064487928,null),new cljs.core.Symbol(null,\x22meta22858\x22,\x22meta22858\x22,464649069,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async22857.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async22857.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async22857\x22);\n\n(cljs.core.async.t_cljs$core$async22857.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async22857\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async22857.\n */\ncljs.core.async.__GT_t_cljs$core$async22857 \x3d (function cljs$core$async$__GT_t_cljs$core$async22857(flag,cb,meta22858){\nreturn (new cljs.core.async.t_cljs$core$async22857(flag,cb,meta22858));\n});\n\n\ncljs.core.async.alt_handler \x3d (function cljs$core$async$alt_handler(flag,cb){\nreturn (new cljs.core.async.t_cljs$core$async22857(flag,cb,cljs.core.PersistentArrayMap.EMPTY));\n});\n/**\n * returns derefable [val port] if immediate, nil if enqueued\n */\ncljs.core.async.do_alts \x3d (function cljs$core$async$do_alts(fret,ports,opts){\nif((cljs.core.count(ports) \x3e (0))){\n} else {\nthrow (new Error([\x22Assert failed: \x22,\x22alts must have at least one channel operation\x22,\x22\\n\x22,\x22(pos? (count ports))\x22].join(\x27\x27)));\n}\n\nvar flag \x3d cljs.core.async.alt_flag();\nvar n \x3d cljs.core.count(ports);\nvar idxs \x3d cljs.core.async.random_array(n);\nvar priority \x3d new cljs.core.Keyword(null,\x22priority\x22,\x22priority\x22,1431093715).cljs$core$IFn$_invoke$arity$1(opts);\nvar ret \x3d (function (){var i \x3d (0);\nwhile(true){\nif((i \x3c n)){\nvar idx \x3d (cljs.core.truth_(priority)?i:(idxs[i]));\nvar port \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(ports,idx);\nvar wport \x3d ((cljs.core.vector_QMARK_(port))?(port.cljs$core$IFn$_invoke$arity$1 ? port.cljs$core$IFn$_invoke$arity$1((0)) : port.call(null, (0))):null);\nvar vbox \x3d (cljs.core.truth_(wport)?(function (){var val \x3d (port.cljs$core$IFn$_invoke$arity$1 ? port.cljs$core$IFn$_invoke$arity$1((1)) : port.call(null, (1)));\nreturn cljs.core.async.impl.protocols.put_BANG_(wport,val,cljs.core.async.alt_handler(flag,((function (i,val,idx,port,wport,flag,n,idxs,priority){\nreturn (function (p1__22885_SHARP_){\nvar G__22903 \x3d new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [p1__22885_SHARP_,wport], null);\nreturn (fret.cljs$core$IFn$_invoke$arity$1 ? fret.cljs$core$IFn$_invoke$arity$1(G__22903) : fret.call(null, G__22903));\n});})(i,val,idx,port,wport,flag,n,idxs,priority))\n));\n})():cljs.core.async.impl.protocols.take_BANG_(port,cljs.core.async.alt_handler(flag,((function (i,idx,port,wport,flag,n,idxs,priority){\nreturn (function (p1__22886_SHARP_){\nvar G__22906 \x3d new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [p1__22886_SHARP_,port], null);\nreturn (fret.cljs$core$IFn$_invoke$arity$1 ? fret.cljs$core$IFn$_invoke$arity$1(G__22906) : fret.call(null, G__22906));\n});})(i,idx,port,wport,flag,n,idxs,priority))\n)));\nif(cljs.core.truth_(vbox)){\nreturn cljs.core.async.impl.channels.box(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.deref(vbox),(function (){var or__5002__auto__ \x3d wport;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn port;\n}\n})()], null));\n} else {\nvar G__26918 \x3d (i + (1));\ni \x3d G__26918;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n})();\nvar or__5002__auto__ \x3d ret;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nif(cljs.core.contains_QMARK_(opts,new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328))){\nvar temp__5804__auto__ \x3d (function (){var and__5000__auto__ \x3d flag.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1(null, );\nif(cljs.core.truth_(and__5000__auto__)){\nreturn flag.cljs$core$async$impl$protocols$Handler$commit$arity$1(null, );\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.truth_(temp__5804__auto__)){\nvar got \x3d temp__5804__auto__;\nreturn cljs.core.async.impl.channels.box(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328).cljs$core$IFn$_invoke$arity$1(opts),new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328)], null));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}\n});\n/**\n * Completes at most one of several channel operations. Must be called\n * inside a (go ...) block. ports is a vector of channel endpoints,\n * which can be either a channel to take from or a vector of\n *   [channel-to-put-to val-to-put], in any combination. Takes will be\n *   made as if by \x3c!, and puts will be made as if by \x3e!. Unless\n *   the :priority option is true, if more than one port operation is\n *   ready a non-deterministic choice will be made. If no operation is\n *   ready and a :default value is supplied, [default-val :default] will\n *   be returned, otherwise alts! will park until the first operation to\n *   become ready completes. Returns [val port] of the completed\n *   operation, where val is the value taken for takes, and a\n *   boolean (true unless already closed, as per put!) for puts.\n * \n *   opts are passed as :key val ... Supported options:\n * \n *   :default val - the value to use if none of the operations are immediately ready\n *   :priority true - (default nil) when true, the operations will be tried in order.\n * \n *   Note: there is no guarantee that the port exps or val exprs will be\n *   used, nor in what order should they be, so they should not be\n *   depended upon for side effects.\n */\ncljs.core.async.alts_BANG_ \x3d (function cljs$core$async$alts_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___26919 \x3d arguments.length;\nvar i__5727__auto___26920 \x3d (0);\nwhile(true){\nif((i__5727__auto___26920 \x3c len__5726__auto___26919)){\nargs__5732__auto__.push((arguments[i__5727__auto___26920]));\n\nvar G__26921 \x3d (i__5727__auto___26920 + (1));\ni__5727__auto___26920 \x3d G__26921;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.core.async.alts_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.core.async.alts_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (ports,p__22933){\nvar map__22934 \x3d p__22933;\nvar map__22934__$1 \x3d cljs.core.__destructure_map(map__22934);\nvar opts \x3d map__22934__$1;\nthrow (new Error(\x22alts! used not in (go ...) block\x22));\n}));\n\n(cljs.core.async.alts_BANG_.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.core.async.alts_BANG_.cljs$lang$applyTo \x3d (function (seq22923){\nvar G__22924 \x3d cljs.core.first(seq22923);\nvar seq22923__$1 \x3d cljs.core.next(seq22923);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__22924,seq22923__$1);\n}));\n\n/**\n * Puts a val into port if it\x27s possible to do so immediately.\n *   nil values are not allowed. Never blocks. Returns true if offer succeeds.\n */\ncljs.core.async.offer_BANG_ \x3d (function cljs$core$async$offer_BANG_(port,val){\nvar ret \x3d cljs.core.async.impl.protocols.put_BANG_(port,val,cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$2(cljs.core.async.nop,false));\nif(cljs.core.truth_(ret)){\nreturn cljs.core.deref(ret);\n} else {\nreturn null;\n}\n});\n/**\n * Takes a val from port if it\x27s possible to do so immediately.\n *   Never blocks. Returns value if successful, nil otherwise.\n */\ncljs.core.async.poll_BANG_ \x3d (function cljs$core$async$poll_BANG_(port){\nvar ret \x3d cljs.core.async.impl.protocols.take_BANG_(port,cljs.core.async.fn_handler.cljs$core$IFn$_invoke$arity$2(cljs.core.async.nop,false));\nif(cljs.core.truth_(ret)){\nreturn cljs.core.deref(ret);\n} else {\nreturn null;\n}\n});\n/**\n * Takes elements from the from channel and supplies them to the to\n * channel. By default, the to channel will be closed when the from\n * channel closes, but can be determined by the close?  parameter. Will\n * stop consuming the from channel if the to channel closes\n */\ncljs.core.async.pipe \x3d (function cljs$core$async$pipe(var_args){\nvar G__22949 \x3d arguments.length;\nswitch (G__22949) {\ncase 2:\nreturn cljs.core.async.pipe.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.pipe.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.pipe.cljs$core$IFn$_invoke$arity$2 \x3d (function (from,to){\nreturn cljs.core.async.pipe.cljs$core$IFn$_invoke$arity$3(from,to,true);\n}));\n\n(cljs.core.async.pipe.cljs$core$IFn$_invoke$arity$3 \x3d (function (from,to,close_QMARK_){\nvar c__22634__auto___26930 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_23007){\nvar state_val_23009 \x3d (state_23007[(1)]);\nif((state_val_23009 \x3d\x3d\x3d (7))){\nvar inst_23000 \x3d (state_23007[(2)]);\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23022_26932 \x3d state_23007__$1;\n(statearr_23022_26932[(2)] \x3d inst_23000);\n\n(statearr_23022_26932[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (1))){\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23023_26934 \x3d state_23007__$1;\n(statearr_23023_26934[(2)] \x3d null);\n\n(statearr_23023_26934[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (4))){\nvar inst_22978 \x3d (state_23007[(7)]);\nvar inst_22978__$1 \x3d (state_23007[(2)]);\nvar inst_22982 \x3d (inst_22978__$1 \x3d\x3d null);\nvar state_23007__$1 \x3d (function (){var statearr_23027 \x3d state_23007;\n(statearr_23027[(7)] \x3d inst_22978__$1);\n\nreturn statearr_23027;\n})();\nif(cljs.core.truth_(inst_22982)){\nvar statearr_23029_26940 \x3d state_23007__$1;\n(statearr_23029_26940[(1)] \x3d (5));\n\n} else {\nvar statearr_23030_26941 \x3d state_23007__$1;\n(statearr_23030_26941[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (13))){\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23034_26942 \x3d state_23007__$1;\n(statearr_23034_26942[(2)] \x3d null);\n\n(statearr_23034_26942[(1)] \x3d (14));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (6))){\nvar inst_22978 \x3d (state_23007[(7)]);\nvar state_23007__$1 \x3d state_23007;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_23007__$1,(11),to,inst_22978);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (3))){\nvar inst_23005 \x3d (state_23007[(2)]);\nvar state_23007__$1 \x3d state_23007;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23007__$1,inst_23005);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (12))){\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23039_26944 \x3d state_23007__$1;\n(statearr_23039_26944[(2)] \x3d null);\n\n(statearr_23039_26944[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (2))){\nvar state_23007__$1 \x3d state_23007;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23007__$1,(4),from);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (11))){\nvar inst_22993 \x3d (state_23007[(2)]);\nvar state_23007__$1 \x3d state_23007;\nif(cljs.core.truth_(inst_22993)){\nvar statearr_23041_26953 \x3d state_23007__$1;\n(statearr_23041_26953[(1)] \x3d (12));\n\n} else {\nvar statearr_23042_26954 \x3d state_23007__$1;\n(statearr_23042_26954[(1)] \x3d (13));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (9))){\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23046_26955 \x3d state_23007__$1;\n(statearr_23046_26955[(2)] \x3d null);\n\n(statearr_23046_26955[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (5))){\nvar state_23007__$1 \x3d state_23007;\nif(cljs.core.truth_(close_QMARK_)){\nvar statearr_23048_26957 \x3d state_23007__$1;\n(statearr_23048_26957[(1)] \x3d (8));\n\n} else {\nvar statearr_23049_26958 \x3d state_23007__$1;\n(statearr_23049_26958[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (14))){\nvar inst_22998 \x3d (state_23007[(2)]);\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23051_26959 \x3d state_23007__$1;\n(statearr_23051_26959[(2)] \x3d inst_22998);\n\n(statearr_23051_26959[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (10))){\nvar inst_22989 \x3d (state_23007[(2)]);\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23054_26960 \x3d state_23007__$1;\n(statearr_23054_26960[(2)] \x3d inst_22989);\n\n(statearr_23054_26960[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23009 \x3d\x3d\x3d (8))){\nvar inst_22985 \x3d cljs.core.async.close_BANG_(to);\nvar state_23007__$1 \x3d state_23007;\nvar statearr_23056_26964 \x3d state_23007__$1;\n(statearr_23056_26964[(2)] \x3d inst_22985);\n\n(statearr_23056_26964[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23061 \x3d [null,null,null,null,null,null,null,null];\n(statearr_23061[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_23061[(1)] \x3d (1));\n\nreturn statearr_23061;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_23007){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23007);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23065){var ex__21558__auto__ \x3d e23065;\nvar statearr_23066_26966 \x3d state_23007;\n(statearr_23066_26966[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23007[(4)]))){\nvar statearr_23067_26967 \x3d state_23007;\n(statearr_23067_26967[(1)] \x3d cljs.core.first((state_23007[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__26968 \x3d state_23007;\nstate_23007 \x3d G__26968;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_23007){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_23007);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23077 \x3d f__22635__auto__();\n(statearr_23077[(6)] \x3d c__22634__auto___26930);\n\nreturn statearr_23077;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn to;\n}));\n\n(cljs.core.async.pipe.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.async.pipeline_STAR_ \x3d (function cljs$core$async$pipeline_STAR_(n,to,xf,from,close_QMARK_,ex_handler,type){\nif((n \x3e (0))){\n} else {\nthrow (new Error(\x22Assert failed: (pos? n)\x22));\n}\n\nvar jobs \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(n);\nvar results \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(n);\nvar process__$1 \x3d (function (p__23094){\nvar vec__23096 \x3d p__23094;\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23096,(0),null);\nvar p \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23096,(1),null);\nvar job \x3d vec__23096;\nif((job \x3d\x3d null)){\ncljs.core.async.close_BANG_(results);\n\nreturn null;\n} else {\nvar res \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$3((1),xf,ex_handler);\nvar c__22634__auto___26975 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_23112){\nvar state_val_23113 \x3d (state_23112[(1)]);\nif((state_val_23113 \x3d\x3d\x3d (1))){\nvar state_23112__$1 \x3d state_23112;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_23112__$1,(2),res,v);\n} else {\nif((state_val_23113 \x3d\x3d\x3d (2))){\nvar inst_23106 \x3d (state_23112[(2)]);\nvar inst_23107 \x3d cljs.core.async.close_BANG_(res);\nvar state_23112__$1 \x3d (function (){var statearr_23125 \x3d state_23112;\n(statearr_23125[(7)] \x3d inst_23106);\n\nreturn statearr_23125;\n})();\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23112__$1,inst_23107);\n} else {\nreturn null;\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23128 \x3d [null,null,null,null,null,null,null,null];\n(statearr_23128[(0)] \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__);\n\n(statearr_23128[(1)] \x3d (1));\n\nreturn statearr_23128;\n});\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1 \x3d (function (state_23112){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23112);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23135){var ex__21558__auto__ \x3d e23135;\nvar statearr_23136_26984 \x3d state_23112;\n(statearr_23136_26984[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23112[(4)]))){\nvar statearr_23137_26985 \x3d state_23112;\n(statearr_23137_26985[(1)] \x3d cljs.core.first((state_23112[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__26987 \x3d state_23112;\nstate_23112 \x3d G__26987;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d function(state_23112){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1.call(this,state_23112);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0;\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1;\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23140 \x3d f__22635__auto__();\n(statearr_23140[(6)] \x3d c__22634__auto___26975);\n\nreturn statearr_23140;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\ncljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(p,res);\n\nreturn true;\n}\n});\nvar async \x3d (function (p__23145){\nvar vec__23147 \x3d p__23145;\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23147,(0),null);\nvar p \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23147,(1),null);\nvar job \x3d vec__23147;\nif((job \x3d\x3d null)){\ncljs.core.async.close_BANG_(results);\n\nreturn null;\n} else {\nvar res \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\n(xf.cljs$core$IFn$_invoke$arity$2 ? xf.cljs$core$IFn$_invoke$arity$2(v,res) : xf.call(null, v,res));\n\ncljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(p,res);\n\nreturn true;\n}\n});\nvar n__5593__auto___26994 \x3d n;\nvar __26995 \x3d (0);\nwhile(true){\nif((__26995 \x3c n__5593__auto___26994)){\nvar G__23153_26996 \x3d type;\nvar G__23153_26997__$1 \x3d (((G__23153_26996 instanceof cljs.core.Keyword))?G__23153_26996.fqn:null);\nswitch (G__23153_26997__$1) {\ncase \x22compute\x22:\nvar c__22634__auto___26999 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run(((function (__26995,c__22634__auto___26999,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async){\nreturn (function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d ((function (__26995,c__22634__auto___26999,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async){\nreturn (function (state_23178){\nvar state_val_23179 \x3d (state_23178[(1)]);\nif((state_val_23179 \x3d\x3d\x3d (1))){\nvar state_23178__$1 \x3d state_23178;\nvar statearr_23184_27002 \x3d state_23178__$1;\n(statearr_23184_27002[(2)] \x3d null);\n\n(statearr_23184_27002[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23179 \x3d\x3d\x3d (2))){\nvar state_23178__$1 \x3d state_23178;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23178__$1,(4),jobs);\n} else {\nif((state_val_23179 \x3d\x3d\x3d (3))){\nvar inst_23176 \x3d (state_23178[(2)]);\nvar state_23178__$1 \x3d state_23178;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23178__$1,inst_23176);\n} else {\nif((state_val_23179 \x3d\x3d\x3d (4))){\nvar inst_23160 \x3d (state_23178[(2)]);\nvar inst_23167 \x3d process__$1(inst_23160);\nvar state_23178__$1 \x3d state_23178;\nif(cljs.core.truth_(inst_23167)){\nvar statearr_23196_27005 \x3d state_23178__$1;\n(statearr_23196_27005[(1)] \x3d (5));\n\n} else {\nvar statearr_23197_27006 \x3d state_23178__$1;\n(statearr_23197_27006[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23179 \x3d\x3d\x3d (5))){\nvar state_23178__$1 \x3d state_23178;\nvar statearr_23199_27007 \x3d state_23178__$1;\n(statearr_23199_27007[(2)] \x3d null);\n\n(statearr_23199_27007[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23179 \x3d\x3d\x3d (6))){\nvar state_23178__$1 \x3d state_23178;\nvar statearr_23201_27008 \x3d state_23178__$1;\n(statearr_23201_27008[(2)] \x3d null);\n\n(statearr_23201_27008[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23179 \x3d\x3d\x3d (7))){\nvar inst_23173 \x3d (state_23178[(2)]);\nvar state_23178__$1 \x3d state_23178;\nvar statearr_23204_27009 \x3d state_23178__$1;\n(statearr_23204_27009[(2)] \x3d inst_23173);\n\n(statearr_23204_27009[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n});})(__26995,c__22634__auto___26999,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async))\n;\nreturn ((function (__26995,switch__21554__auto__,c__22634__auto___26999,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async){\nreturn (function() {\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23206 \x3d [null,null,null,null,null,null,null];\n(statearr_23206[(0)] \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__);\n\n(statearr_23206[(1)] \x3d (1));\n\nreturn statearr_23206;\n});\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1 \x3d (function (state_23178){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23178);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23208){var ex__21558__auto__ \x3d e23208;\nvar statearr_23209_27012 \x3d state_23178;\n(statearr_23209_27012[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23178[(4)]))){\nvar statearr_23210_27015 \x3d state_23178;\n(statearr_23210_27015[(1)] \x3d cljs.core.first((state_23178[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27017 \x3d state_23178;\nstate_23178 \x3d G__27017;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d function(state_23178){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1.call(this,state_23178);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0;\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1;\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__;\n})()\n;})(__26995,switch__21554__auto__,c__22634__auto___26999,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async))\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23217 \x3d f__22635__auto__();\n(statearr_23217[(6)] \x3d c__22634__auto___26999);\n\nreturn statearr_23217;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n});})(__26995,c__22634__auto___26999,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async))\n);\n\n\nbreak;\ncase \x22async\x22:\nvar c__22634__auto___27018 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run(((function (__26995,c__22634__auto___27018,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async){\nreturn (function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d ((function (__26995,c__22634__auto___27018,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async){\nreturn (function (state_23234){\nvar state_val_23235 \x3d (state_23234[(1)]);\nif((state_val_23235 \x3d\x3d\x3d (1))){\nvar state_23234__$1 \x3d state_23234;\nvar statearr_23251_27019 \x3d state_23234__$1;\n(statearr_23251_27019[(2)] \x3d null);\n\n(statearr_23251_27019[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23235 \x3d\x3d\x3d (2))){\nvar state_23234__$1 \x3d state_23234;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23234__$1,(4),jobs);\n} else {\nif((state_val_23235 \x3d\x3d\x3d (3))){\nvar inst_23232 \x3d (state_23234[(2)]);\nvar state_23234__$1 \x3d state_23234;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23234__$1,inst_23232);\n} else {\nif((state_val_23235 \x3d\x3d\x3d (4))){\nvar inst_23222 \x3d (state_23234[(2)]);\nvar inst_23223 \x3d async(inst_23222);\nvar state_23234__$1 \x3d state_23234;\nif(cljs.core.truth_(inst_23223)){\nvar statearr_23255_27024 \x3d state_23234__$1;\n(statearr_23255_27024[(1)] \x3d (5));\n\n} else {\nvar statearr_23257_27025 \x3d state_23234__$1;\n(statearr_23257_27025[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23235 \x3d\x3d\x3d (5))){\nvar state_23234__$1 \x3d state_23234;\nvar statearr_23258_27028 \x3d state_23234__$1;\n(statearr_23258_27028[(2)] \x3d null);\n\n(statearr_23258_27028[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23235 \x3d\x3d\x3d (6))){\nvar state_23234__$1 \x3d state_23234;\nvar statearr_23263_27033 \x3d state_23234__$1;\n(statearr_23263_27033[(2)] \x3d null);\n\n(statearr_23263_27033[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23235 \x3d\x3d\x3d (7))){\nvar inst_23229 \x3d (state_23234[(2)]);\nvar state_23234__$1 \x3d state_23234;\nvar statearr_23265_27034 \x3d state_23234__$1;\n(statearr_23265_27034[(2)] \x3d inst_23229);\n\n(statearr_23265_27034[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n});})(__26995,c__22634__auto___27018,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async))\n;\nreturn ((function (__26995,switch__21554__auto__,c__22634__auto___27018,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async){\nreturn (function() {\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23267 \x3d [null,null,null,null,null,null,null];\n(statearr_23267[(0)] \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__);\n\n(statearr_23267[(1)] \x3d (1));\n\nreturn statearr_23267;\n});\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1 \x3d (function (state_23234){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23234);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23269){var ex__21558__auto__ \x3d e23269;\nvar statearr_23271_27041 \x3d state_23234;\n(statearr_23271_27041[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23234[(4)]))){\nvar statearr_23273_27042 \x3d state_23234;\n(statearr_23273_27042[(1)] \x3d cljs.core.first((state_23234[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27044 \x3d state_23234;\nstate_23234 \x3d G__27044;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d function(state_23234){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1.call(this,state_23234);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0;\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1;\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__;\n})()\n;})(__26995,switch__21554__auto__,c__22634__auto___27018,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async))\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23275 \x3d f__22635__auto__();\n(statearr_23275[(6)] \x3d c__22634__auto___27018);\n\nreturn statearr_23275;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n});})(__26995,c__22634__auto___27018,G__23153_26996,G__23153_26997__$1,n__5593__auto___26994,jobs,results,process__$1,async))\n);\n\n\nbreak;\ndefault:\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__23153_26997__$1)].join(\x27\x27)));\n\n}\n\nvar G__27047 \x3d (__26995 + (1));\n__26995 \x3d G__27047;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar c__22634__auto___27048 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_23312){\nvar state_val_23313 \x3d (state_23312[(1)]);\nif((state_val_23313 \x3d\x3d\x3d (7))){\nvar inst_23308 \x3d (state_23312[(2)]);\nvar state_23312__$1 \x3d state_23312;\nvar statearr_23321_27051 \x3d state_23312__$1;\n(statearr_23321_27051[(2)] \x3d inst_23308);\n\n(statearr_23321_27051[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (1))){\nvar state_23312__$1 \x3d state_23312;\nvar statearr_23324_27053 \x3d state_23312__$1;\n(statearr_23324_27053[(2)] \x3d null);\n\n(statearr_23324_27053[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (4))){\nvar inst_23288 \x3d (state_23312[(7)]);\nvar inst_23288__$1 \x3d (state_23312[(2)]);\nvar inst_23289 \x3d (inst_23288__$1 \x3d\x3d null);\nvar state_23312__$1 \x3d (function (){var statearr_23326 \x3d state_23312;\n(statearr_23326[(7)] \x3d inst_23288__$1);\n\nreturn statearr_23326;\n})();\nif(cljs.core.truth_(inst_23289)){\nvar statearr_23327_27054 \x3d state_23312__$1;\n(statearr_23327_27054[(1)] \x3d (5));\n\n} else {\nvar statearr_23331_27055 \x3d state_23312__$1;\n(statearr_23331_27055[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (6))){\nvar inst_23288 \x3d (state_23312[(7)]);\nvar inst_23293 \x3d (state_23312[(8)]);\nvar inst_23293__$1 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\nvar inst_23298 \x3d cljs.core.PersistentVector.EMPTY_NODE;\nvar inst_23299 \x3d [inst_23288,inst_23293__$1];\nvar inst_23300 \x3d (new cljs.core.PersistentVector(null,2,(5),inst_23298,inst_23299,null));\nvar state_23312__$1 \x3d (function (){var statearr_23339 \x3d state_23312;\n(statearr_23339[(8)] \x3d inst_23293__$1);\n\nreturn statearr_23339;\n})();\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_23312__$1,(8),jobs,inst_23300);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (3))){\nvar inst_23310 \x3d (state_23312[(2)]);\nvar state_23312__$1 \x3d state_23312;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23312__$1,inst_23310);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (2))){\nvar state_23312__$1 \x3d state_23312;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23312__$1,(4),from);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (9))){\nvar inst_23305 \x3d (state_23312[(2)]);\nvar state_23312__$1 \x3d (function (){var statearr_23343 \x3d state_23312;\n(statearr_23343[(9)] \x3d inst_23305);\n\nreturn statearr_23343;\n})();\nvar statearr_23344_27062 \x3d state_23312__$1;\n(statearr_23344_27062[(2)] \x3d null);\n\n(statearr_23344_27062[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (5))){\nvar inst_23291 \x3d cljs.core.async.close_BANG_(jobs);\nvar state_23312__$1 \x3d state_23312;\nvar statearr_23346_27064 \x3d state_23312__$1;\n(statearr_23346_27064[(2)] \x3d inst_23291);\n\n(statearr_23346_27064[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23313 \x3d\x3d\x3d (8))){\nvar inst_23293 \x3d (state_23312[(8)]);\nvar inst_23302 \x3d (state_23312[(2)]);\nvar state_23312__$1 \x3d (function (){var statearr_23348 \x3d state_23312;\n(statearr_23348[(10)] \x3d inst_23302);\n\nreturn statearr_23348;\n})();\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_23312__$1,(9),results,inst_23293);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23349 \x3d [null,null,null,null,null,null,null,null,null,null,null];\n(statearr_23349[(0)] \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__);\n\n(statearr_23349[(1)] \x3d (1));\n\nreturn statearr_23349;\n});\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1 \x3d (function (state_23312){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23312);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23351){var ex__21558__auto__ \x3d e23351;\nvar statearr_23352_27078 \x3d state_23312;\n(statearr_23352_27078[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23312[(4)]))){\nvar statearr_23354_27084 \x3d state_23312;\n(statearr_23354_27084[(1)] \x3d cljs.core.first((state_23312[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27088 \x3d state_23312;\nstate_23312 \x3d G__27088;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d function(state_23312){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1.call(this,state_23312);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0;\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1;\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23357 \x3d f__22635__auto__();\n(statearr_23357[(6)] \x3d c__22634__auto___27048);\n\nreturn statearr_23357;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nvar c__22634__auto__ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_23399){\nvar state_val_23400 \x3d (state_23399[(1)]);\nif((state_val_23400 \x3d\x3d\x3d (7))){\nvar inst_23395 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23401_27107 \x3d state_23399__$1;\n(statearr_23401_27107[(2)] \x3d inst_23395);\n\n(statearr_23401_27107[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (20))){\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23404_27115 \x3d state_23399__$1;\n(statearr_23404_27115[(2)] \x3d null);\n\n(statearr_23404_27115[(1)] \x3d (21));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (1))){\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23405_27120 \x3d state_23399__$1;\n(statearr_23405_27120[(2)] \x3d null);\n\n(statearr_23405_27120[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (4))){\nvar inst_23360 \x3d (state_23399[(7)]);\nvar inst_23360__$1 \x3d (state_23399[(2)]);\nvar inst_23361 \x3d (inst_23360__$1 \x3d\x3d null);\nvar state_23399__$1 \x3d (function (){var statearr_23407 \x3d state_23399;\n(statearr_23407[(7)] \x3d inst_23360__$1);\n\nreturn statearr_23407;\n})();\nif(cljs.core.truth_(inst_23361)){\nvar statearr_23408_27122 \x3d state_23399__$1;\n(statearr_23408_27122[(1)] \x3d (5));\n\n} else {\nvar statearr_23409_27123 \x3d state_23399__$1;\n(statearr_23409_27123[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (15))){\nvar inst_23377 \x3d (state_23399[(8)]);\nvar state_23399__$1 \x3d state_23399;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_23399__$1,(18),to,inst_23377);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (21))){\nvar inst_23390 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23417_27124 \x3d state_23399__$1;\n(statearr_23417_27124[(2)] \x3d inst_23390);\n\n(statearr_23417_27124[(1)] \x3d (13));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (13))){\nvar inst_23392 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d (function (){var statearr_23419 \x3d state_23399;\n(statearr_23419[(9)] \x3d inst_23392);\n\nreturn statearr_23419;\n})();\nvar statearr_23420_27130 \x3d state_23399__$1;\n(statearr_23420_27130[(2)] \x3d null);\n\n(statearr_23420_27130[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (6))){\nvar inst_23360 \x3d (state_23399[(7)]);\nvar state_23399__$1 \x3d state_23399;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23399__$1,(11),inst_23360);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (17))){\nvar inst_23385 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d state_23399;\nif(cljs.core.truth_(inst_23385)){\nvar statearr_23421_27134 \x3d state_23399__$1;\n(statearr_23421_27134[(1)] \x3d (19));\n\n} else {\nvar statearr_23422_27135 \x3d state_23399__$1;\n(statearr_23422_27135[(1)] \x3d (20));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (3))){\nvar inst_23397 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d state_23399;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23399__$1,inst_23397);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (12))){\nvar inst_23374 \x3d (state_23399[(10)]);\nvar state_23399__$1 \x3d state_23399;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23399__$1,(14),inst_23374);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (2))){\nvar state_23399__$1 \x3d state_23399;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23399__$1,(4),results);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (19))){\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23429_27136 \x3d state_23399__$1;\n(statearr_23429_27136[(2)] \x3d null);\n\n(statearr_23429_27136[(1)] \x3d (12));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (11))){\nvar inst_23374 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d (function (){var statearr_23430 \x3d state_23399;\n(statearr_23430[(10)] \x3d inst_23374);\n\nreturn statearr_23430;\n})();\nvar statearr_23431_27143 \x3d state_23399__$1;\n(statearr_23431_27143[(2)] \x3d null);\n\n(statearr_23431_27143[(1)] \x3d (12));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (9))){\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23433_27144 \x3d state_23399__$1;\n(statearr_23433_27144[(2)] \x3d null);\n\n(statearr_23433_27144[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (5))){\nvar state_23399__$1 \x3d state_23399;\nif(cljs.core.truth_(close_QMARK_)){\nvar statearr_23439_27145 \x3d state_23399__$1;\n(statearr_23439_27145[(1)] \x3d (8));\n\n} else {\nvar statearr_23440_27146 \x3d state_23399__$1;\n(statearr_23440_27146[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (14))){\nvar inst_23379 \x3d (state_23399[(11)]);\nvar inst_23377 \x3d (state_23399[(8)]);\nvar inst_23377__$1 \x3d (state_23399[(2)]);\nvar inst_23378 \x3d (inst_23377__$1 \x3d\x3d null);\nvar inst_23379__$1 \x3d cljs.core.not(inst_23378);\nvar state_23399__$1 \x3d (function (){var statearr_23449 \x3d state_23399;\n(statearr_23449[(11)] \x3d inst_23379__$1);\n\n(statearr_23449[(8)] \x3d inst_23377__$1);\n\nreturn statearr_23449;\n})();\nif(inst_23379__$1){\nvar statearr_23451_27151 \x3d state_23399__$1;\n(statearr_23451_27151[(1)] \x3d (15));\n\n} else {\nvar statearr_23452_27152 \x3d state_23399__$1;\n(statearr_23452_27152[(1)] \x3d (16));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (16))){\nvar inst_23379 \x3d (state_23399[(11)]);\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23453_27153 \x3d state_23399__$1;\n(statearr_23453_27153[(2)] \x3d inst_23379);\n\n(statearr_23453_27153[(1)] \x3d (17));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (10))){\nvar inst_23370 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23456_27154 \x3d state_23399__$1;\n(statearr_23456_27154[(2)] \x3d inst_23370);\n\n(statearr_23456_27154[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (18))){\nvar inst_23382 \x3d (state_23399[(2)]);\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23463_27156 \x3d state_23399__$1;\n(statearr_23463_27156[(2)] \x3d inst_23382);\n\n(statearr_23463_27156[(1)] \x3d (17));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23400 \x3d\x3d\x3d (8))){\nvar inst_23367 \x3d cljs.core.async.close_BANG_(to);\nvar state_23399__$1 \x3d state_23399;\nvar statearr_23468_27159 \x3d state_23399__$1;\n(statearr_23468_27159[(2)] \x3d inst_23367);\n\n(statearr_23468_27159[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23474 \x3d [null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_23474[(0)] \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__);\n\n(statearr_23474[(1)] \x3d (1));\n\nreturn statearr_23474;\n});\nvar cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1 \x3d (function (state_23399){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23399);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23480){var ex__21558__auto__ \x3d e23480;\nvar statearr_23481_27164 \x3d state_23399;\n(statearr_23481_27164[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23399[(4)]))){\nvar statearr_23482_27166 \x3d state_23399;\n(statearr_23482_27166[(1)] \x3d cljs.core.first((state_23399[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27170 \x3d state_23399;\nstate_23399 \x3d G__27170;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__ \x3d function(state_23399){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1.call(this,state_23399);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____0;\ncljs$core$async$pipeline_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$pipeline_STAR__$_state_machine__21555__auto____1;\nreturn cljs$core$async$pipeline_STAR__$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23489 \x3d f__22635__auto__();\n(statearr_23489[(6)] \x3d c__22634__auto__);\n\nreturn statearr_23489;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\nreturn c__22634__auto__;\n});\n/**\n * Takes elements from the from channel and supplies them to the to\n *   channel, subject to the async function af, with parallelism n. af\n *   must be a function of two arguments, the first an input value and\n *   the second a channel on which to place the result(s). The\n *   presumption is that af will return immediately, having launched some\n *   asynchronous operation whose completion/callback will put results on\n *   the channel, then close! it. Outputs will be returned in order\n *   relative to the inputs. By default, the to channel will be closed\n *   when the from channel closes, but can be determined by the close?\n *   parameter. Will stop consuming the from channel if the to channel\n *   closes. See also pipeline, pipeline-blocking.\n */\ncljs.core.async.pipeline_async \x3d (function cljs$core$async$pipeline_async(var_args){\nvar G__23499 \x3d arguments.length;\nswitch (G__23499) {\ncase 4:\nreturn cljs.core.async.pipeline_async.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.async.pipeline_async.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.pipeline_async.cljs$core$IFn$_invoke$arity$4 \x3d (function (n,to,af,from){\nreturn cljs.core.async.pipeline_async.cljs$core$IFn$_invoke$arity$5(n,to,af,from,true);\n}));\n\n(cljs.core.async.pipeline_async.cljs$core$IFn$_invoke$arity$5 \x3d (function (n,to,af,from,close_QMARK_){\nreturn cljs.core.async.pipeline_STAR_(n,to,af,from,close_QMARK_,null,new cljs.core.Keyword(null,\x22async\x22,\x22async\x22,1050769601));\n}));\n\n(cljs.core.async.pipeline_async.cljs$lang$maxFixedArity \x3d 5);\n\n/**\n * Takes elements from the from channel and supplies them to the to\n *   channel, subject to the transducer xf, with parallelism n. Because\n *   it is parallel, the transducer will be applied independently to each\n *   element, not across elements, and may produce zero or more outputs\n *   per input.  Outputs will be returned in order relative to the\n *   inputs. By default, the to channel will be closed when the from\n *   channel closes, but can be determined by the close?  parameter. Will\n *   stop consuming the from channel if the to channel closes.\n * \n *   Note this is supplied for API compatibility with the Clojure version.\n *   Values of N \x3e 1 will not result in actual concurrency in a\n *   single-threaded runtime.\n */\ncljs.core.async.pipeline \x3d (function cljs$core$async$pipeline(var_args){\nvar G__23524 \x3d arguments.length;\nswitch (G__23524) {\ncase 4:\nreturn cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$4 \x3d (function (n,to,xf,from){\nreturn cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$5(n,to,xf,from,true);\n}));\n\n(cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$5 \x3d (function (n,to,xf,from,close_QMARK_){\nreturn cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$6(n,to,xf,from,close_QMARK_,null);\n}));\n\n(cljs.core.async.pipeline.cljs$core$IFn$_invoke$arity$6 \x3d (function (n,to,xf,from,close_QMARK_,ex_handler){\nreturn cljs.core.async.pipeline_STAR_(n,to,xf,from,close_QMARK_,ex_handler,new cljs.core.Keyword(null,\x22compute\x22,\x22compute\x22,1555393130));\n}));\n\n(cljs.core.async.pipeline.cljs$lang$maxFixedArity \x3d 6);\n\n/**\n * Takes a predicate and a source channel and returns a vector of two\n *   channels, the first of which will contain the values for which the\n *   predicate returned true, the second those for which it returned\n *   false.\n * \n *   The out channels will be unbuffered by default, or two buf-or-ns can\n *   be supplied. The channels will close after the source channel has\n *   closed.\n */\ncljs.core.async.split \x3d (function cljs$core$async$split(var_args){\nvar G__23552 \x3d arguments.length;\nswitch (G__23552) {\ncase 2:\nreturn cljs.core.async.split.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 4:\nreturn cljs.core.async.split.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.split.cljs$core$IFn$_invoke$arity$2 \x3d (function (p,ch){\nreturn cljs.core.async.split.cljs$core$IFn$_invoke$arity$4(p,ch,null,null);\n}));\n\n(cljs.core.async.split.cljs$core$IFn$_invoke$arity$4 \x3d (function (p,ch,t_buf_or_n,f_buf_or_n){\nvar tc \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(t_buf_or_n);\nvar fc \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(f_buf_or_n);\nvar c__22634__auto___27190 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_23614){\nvar state_val_23615 \x3d (state_23614[(1)]);\nif((state_val_23615 \x3d\x3d\x3d (7))){\nvar inst_23607 \x3d (state_23614[(2)]);\nvar state_23614__$1 \x3d state_23614;\nvar statearr_23624_27191 \x3d state_23614__$1;\n(statearr_23624_27191[(2)] \x3d inst_23607);\n\n(statearr_23624_27191[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (1))){\nvar state_23614__$1 \x3d state_23614;\nvar statearr_23631_27192 \x3d state_23614__$1;\n(statearr_23631_27192[(2)] \x3d null);\n\n(statearr_23631_27192[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (4))){\nvar inst_23572 \x3d (state_23614[(7)]);\nvar inst_23572__$1 \x3d (state_23614[(2)]);\nvar inst_23573 \x3d (inst_23572__$1 \x3d\x3d null);\nvar state_23614__$1 \x3d (function (){var statearr_23640 \x3d state_23614;\n(statearr_23640[(7)] \x3d inst_23572__$1);\n\nreturn statearr_23640;\n})();\nif(cljs.core.truth_(inst_23573)){\nvar statearr_23646_27198 \x3d state_23614__$1;\n(statearr_23646_27198[(1)] \x3d (5));\n\n} else {\nvar statearr_23647_27199 \x3d state_23614__$1;\n(statearr_23647_27199[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (13))){\nvar state_23614__$1 \x3d state_23614;\nvar statearr_23650_27200 \x3d state_23614__$1;\n(statearr_23650_27200[(2)] \x3d null);\n\n(statearr_23650_27200[(1)] \x3d (14));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (6))){\nvar inst_23572 \x3d (state_23614[(7)]);\nvar inst_23587 \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(inst_23572) : p.call(null, inst_23572));\nvar state_23614__$1 \x3d state_23614;\nif(cljs.core.truth_(inst_23587)){\nvar statearr_23662_27202 \x3d state_23614__$1;\n(statearr_23662_27202[(1)] \x3d (9));\n\n} else {\nvar statearr_23667_27203 \x3d state_23614__$1;\n(statearr_23667_27203[(1)] \x3d (10));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (3))){\nvar inst_23610 \x3d (state_23614[(2)]);\nvar state_23614__$1 \x3d state_23614;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23614__$1,inst_23610);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (12))){\nvar state_23614__$1 \x3d state_23614;\nvar statearr_23678_27205 \x3d state_23614__$1;\n(statearr_23678_27205[(2)] \x3d null);\n\n(statearr_23678_27205[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (2))){\nvar state_23614__$1 \x3d state_23614;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23614__$1,(4),ch);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (11))){\nvar inst_23572 \x3d (state_23614[(7)]);\nvar inst_23596 \x3d (state_23614[(2)]);\nvar state_23614__$1 \x3d state_23614;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_23614__$1,(8),inst_23596,inst_23572);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (9))){\nvar state_23614__$1 \x3d state_23614;\nvar statearr_23683_27207 \x3d state_23614__$1;\n(statearr_23683_27207[(2)] \x3d tc);\n\n(statearr_23683_27207[(1)] \x3d (11));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (5))){\nvar inst_23584 \x3d cljs.core.async.close_BANG_(tc);\nvar inst_23585 \x3d cljs.core.async.close_BANG_(fc);\nvar state_23614__$1 \x3d (function (){var statearr_23690 \x3d state_23614;\n(statearr_23690[(8)] \x3d inst_23584);\n\nreturn statearr_23690;\n})();\nvar statearr_23692_27208 \x3d state_23614__$1;\n(statearr_23692_27208[(2)] \x3d inst_23585);\n\n(statearr_23692_27208[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (14))){\nvar inst_23605 \x3d (state_23614[(2)]);\nvar state_23614__$1 \x3d state_23614;\nvar statearr_23700_27210 \x3d state_23614__$1;\n(statearr_23700_27210[(2)] \x3d inst_23605);\n\n(statearr_23700_27210[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (10))){\nvar state_23614__$1 \x3d state_23614;\nvar statearr_23701_27211 \x3d state_23614__$1;\n(statearr_23701_27211[(2)] \x3d fc);\n\n(statearr_23701_27211[(1)] \x3d (11));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23615 \x3d\x3d\x3d (8))){\nvar inst_23599 \x3d (state_23614[(2)]);\nvar state_23614__$1 \x3d state_23614;\nif(cljs.core.truth_(inst_23599)){\nvar statearr_23706_27222 \x3d state_23614__$1;\n(statearr_23706_27222[(1)] \x3d (12));\n\n} else {\nvar statearr_23707_27225 \x3d state_23614__$1;\n(statearr_23707_27225[(1)] \x3d (13));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23714 \x3d [null,null,null,null,null,null,null,null,null];\n(statearr_23714[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_23714[(1)] \x3d (1));\n\nreturn statearr_23714;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_23614){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23614);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23716){var ex__21558__auto__ \x3d e23716;\nvar statearr_23717_27226 \x3d state_23614;\n(statearr_23717_27226[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23614[(4)]))){\nvar statearr_23718_27227 \x3d state_23614;\n(statearr_23718_27227[(1)] \x3d cljs.core.first((state_23614[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27228 \x3d state_23614;\nstate_23614 \x3d G__27228;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_23614){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_23614);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23730 \x3d f__22635__auto__();\n(statearr_23730[(6)] \x3d c__22634__auto___27190);\n\nreturn statearr_23730;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [tc,fc], null);\n}));\n\n(cljs.core.async.split.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * f should be a function of 2 arguments. Returns a channel containing\n *   the single result of applying f to init and the first item from the\n *   channel, then applying f to that result and the 2nd item, etc. If\n *   the channel closes without yielding items, returns init and f is not\n *   called. ch must close before reduce produces a result.\n */\ncljs.core.async.reduce \x3d (function cljs$core$async$reduce(f,init,ch){\nvar c__22634__auto__ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_23771){\nvar state_val_23776 \x3d (state_23771[(1)]);\nif((state_val_23776 \x3d\x3d\x3d (7))){\nvar inst_23765 \x3d (state_23771[(2)]);\nvar state_23771__$1 \x3d state_23771;\nvar statearr_23807_27233 \x3d state_23771__$1;\n(statearr_23807_27233[(2)] \x3d inst_23765);\n\n(statearr_23807_27233[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (1))){\nvar inst_23736 \x3d init;\nvar inst_23737 \x3d inst_23736;\nvar state_23771__$1 \x3d (function (){var statearr_23818 \x3d state_23771;\n(statearr_23818[(7)] \x3d inst_23737);\n\nreturn statearr_23818;\n})();\nvar statearr_23820_27234 \x3d state_23771__$1;\n(statearr_23820_27234[(2)] \x3d null);\n\n(statearr_23820_27234[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (4))){\nvar inst_23743 \x3d (state_23771[(8)]);\nvar inst_23743__$1 \x3d (state_23771[(2)]);\nvar inst_23744 \x3d (inst_23743__$1 \x3d\x3d null);\nvar state_23771__$1 \x3d (function (){var statearr_23835 \x3d state_23771;\n(statearr_23835[(8)] \x3d inst_23743__$1);\n\nreturn statearr_23835;\n})();\nif(cljs.core.truth_(inst_23744)){\nvar statearr_23836_27236 \x3d state_23771__$1;\n(statearr_23836_27236[(1)] \x3d (5));\n\n} else {\nvar statearr_23838_27237 \x3d state_23771__$1;\n(statearr_23838_27237[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (6))){\nvar inst_23748 \x3d (state_23771[(9)]);\nvar inst_23737 \x3d (state_23771[(7)]);\nvar inst_23743 \x3d (state_23771[(8)]);\nvar inst_23748__$1 \x3d (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(inst_23737,inst_23743) : f.call(null, inst_23737,inst_23743));\nvar inst_23751 \x3d cljs.core.reduced_QMARK_(inst_23748__$1);\nvar state_23771__$1 \x3d (function (){var statearr_23855 \x3d state_23771;\n(statearr_23855[(9)] \x3d inst_23748__$1);\n\nreturn statearr_23855;\n})();\nif(inst_23751){\nvar statearr_23858_27238 \x3d state_23771__$1;\n(statearr_23858_27238[(1)] \x3d (8));\n\n} else {\nvar statearr_23865_27239 \x3d state_23771__$1;\n(statearr_23865_27239[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (3))){\nvar inst_23767 \x3d (state_23771[(2)]);\nvar state_23771__$1 \x3d state_23771;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23771__$1,inst_23767);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (2))){\nvar state_23771__$1 \x3d state_23771;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23771__$1,(4),ch);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (9))){\nvar inst_23748 \x3d (state_23771[(9)]);\nvar inst_23737 \x3d inst_23748;\nvar state_23771__$1 \x3d (function (){var statearr_23876 \x3d state_23771;\n(statearr_23876[(7)] \x3d inst_23737);\n\nreturn statearr_23876;\n})();\nvar statearr_23877_27243 \x3d state_23771__$1;\n(statearr_23877_27243[(2)] \x3d null);\n\n(statearr_23877_27243[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (5))){\nvar inst_23737 \x3d (state_23771[(7)]);\nvar state_23771__$1 \x3d state_23771;\nvar statearr_23878_27244 \x3d state_23771__$1;\n(statearr_23878_27244[(2)] \x3d inst_23737);\n\n(statearr_23878_27244[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (10))){\nvar inst_23763 \x3d (state_23771[(2)]);\nvar state_23771__$1 \x3d state_23771;\nvar statearr_23879_27245 \x3d state_23771__$1;\n(statearr_23879_27245[(2)] \x3d inst_23763);\n\n(statearr_23879_27245[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_23776 \x3d\x3d\x3d (8))){\nvar inst_23748 \x3d (state_23771[(9)]);\nvar inst_23759 \x3d cljs.core.deref(inst_23748);\nvar state_23771__$1 \x3d state_23771;\nvar statearr_23888_27246 \x3d state_23771__$1;\n(statearr_23888_27246[(2)] \x3d inst_23759);\n\n(statearr_23888_27246[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$reduce_$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$reduce_$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23897 \x3d [null,null,null,null,null,null,null,null,null,null];\n(statearr_23897[(0)] \x3d cljs$core$async$reduce_$_state_machine__21555__auto__);\n\n(statearr_23897[(1)] \x3d (1));\n\nreturn statearr_23897;\n});\nvar cljs$core$async$reduce_$_state_machine__21555__auto____1 \x3d (function (state_23771){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23771);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23899){var ex__21558__auto__ \x3d e23899;\nvar statearr_23900_27248 \x3d state_23771;\n(statearr_23900_27248[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23771[(4)]))){\nvar statearr_23902_27249 \x3d state_23771;\n(statearr_23902_27249[(1)] \x3d cljs.core.first((state_23771[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27250 \x3d state_23771;\nstate_23771 \x3d G__27250;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$reduce_$_state_machine__21555__auto__ \x3d function(state_23771){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$reduce_$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$reduce_$_state_machine__21555__auto____1.call(this,state_23771);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$reduce_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$reduce_$_state_machine__21555__auto____0;\ncljs$core$async$reduce_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$reduce_$_state_machine__21555__auto____1;\nreturn cljs$core$async$reduce_$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23903 \x3d f__22635__auto__();\n(statearr_23903[(6)] \x3d c__22634__auto__);\n\nreturn statearr_23903;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\nreturn c__22634__auto__;\n});\n/**\n * async/reduces a channel with a transformation (xform f).\n *   Returns a channel containing the result.  ch must close before\n *   transduce produces a result.\n */\ncljs.core.async.transduce \x3d (function cljs$core$async$transduce(xform,f,init,ch){\nvar f__$1 \x3d (xform.cljs$core$IFn$_invoke$arity$1 ? xform.cljs$core$IFn$_invoke$arity$1(f) : xform.call(null, f));\nvar c__22634__auto__ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_23917){\nvar state_val_23918 \x3d (state_23917[(1)]);\nif((state_val_23918 \x3d\x3d\x3d (1))){\nvar inst_23910 \x3d cljs.core.async.reduce(f__$1,init,ch);\nvar state_23917__$1 \x3d state_23917;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_23917__$1,(2),inst_23910);\n} else {\nif((state_val_23918 \x3d\x3d\x3d (2))){\nvar inst_23912 \x3d (state_23917[(2)]);\nvar inst_23913 \x3d (f__$1.cljs$core$IFn$_invoke$arity$1 ? f__$1.cljs$core$IFn$_invoke$arity$1(inst_23912) : f__$1.call(null, inst_23912));\nvar state_23917__$1 \x3d state_23917;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_23917__$1,inst_23913);\n} else {\nreturn null;\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$transduce_$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$transduce_$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_23933 \x3d [null,null,null,null,null,null,null];\n(statearr_23933[(0)] \x3d cljs$core$async$transduce_$_state_machine__21555__auto__);\n\n(statearr_23933[(1)] \x3d (1));\n\nreturn statearr_23933;\n});\nvar cljs$core$async$transduce_$_state_machine__21555__auto____1 \x3d (function (state_23917){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_23917);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e23941){var ex__21558__auto__ \x3d e23941;\nvar statearr_23943_27252 \x3d state_23917;\n(statearr_23943_27252[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_23917[(4)]))){\nvar statearr_23948_27253 \x3d state_23917;\n(statearr_23948_27253[(1)] \x3d cljs.core.first((state_23917[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27254 \x3d state_23917;\nstate_23917 \x3d G__27254;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$transduce_$_state_machine__21555__auto__ \x3d function(state_23917){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$transduce_$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$transduce_$_state_machine__21555__auto____1.call(this,state_23917);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$transduce_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$transduce_$_state_machine__21555__auto____0;\ncljs$core$async$transduce_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$transduce_$_state_machine__21555__auto____1;\nreturn cljs$core$async$transduce_$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_23957 \x3d f__22635__auto__();\n(statearr_23957[(6)] \x3d c__22634__auto__);\n\nreturn statearr_23957;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\nreturn c__22634__auto__;\n});\n/**\n * Puts the contents of coll into the supplied channel.\n * \n *   By default the channel will be closed after the items are copied,\n *   but can be determined by the close? parameter.\n * \n *   Returns a channel which will close after the items are copied.\n */\ncljs.core.async.onto_chan_BANG_ \x3d (function cljs$core$async$onto_chan_BANG_(var_args){\nvar G__23977 \x3d arguments.length;\nswitch (G__23977) {\ncase 2:\nreturn cljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (ch,coll){\nreturn cljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$3(ch,coll,true);\n}));\n\n(cljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (ch,coll,close_QMARK_){\nvar c__22634__auto__ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_24007){\nvar state_val_24008 \x3d (state_24007[(1)]);\nif((state_val_24008 \x3d\x3d\x3d (7))){\nvar inst_23987 \x3d (state_24007[(2)]);\nvar state_24007__$1 \x3d state_24007;\nvar statearr_24026_27257 \x3d state_24007__$1;\n(statearr_24026_27257[(2)] \x3d inst_23987);\n\n(statearr_24026_27257[(1)] \x3d (6));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (1))){\nvar inst_23981 \x3d cljs.core.seq(coll);\nvar inst_23982 \x3d inst_23981;\nvar state_24007__$1 \x3d (function (){var statearr_24030 \x3d state_24007;\n(statearr_24030[(7)] \x3d inst_23982);\n\nreturn statearr_24030;\n})();\nvar statearr_24032_27259 \x3d state_24007__$1;\n(statearr_24032_27259[(2)] \x3d null);\n\n(statearr_24032_27259[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (4))){\nvar inst_23982 \x3d (state_24007[(7)]);\nvar inst_23985 \x3d cljs.core.first(inst_23982);\nvar state_24007__$1 \x3d state_24007;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_24007__$1,(7),ch,inst_23985);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (13))){\nvar inst_23999 \x3d (state_24007[(2)]);\nvar state_24007__$1 \x3d state_24007;\nvar statearr_24035_27260 \x3d state_24007__$1;\n(statearr_24035_27260[(2)] \x3d inst_23999);\n\n(statearr_24035_27260[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (6))){\nvar inst_23990 \x3d (state_24007[(2)]);\nvar state_24007__$1 \x3d state_24007;\nif(cljs.core.truth_(inst_23990)){\nvar statearr_24039_27261 \x3d state_24007__$1;\n(statearr_24039_27261[(1)] \x3d (8));\n\n} else {\nvar statearr_24040_27263 \x3d state_24007__$1;\n(statearr_24040_27263[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (3))){\nvar inst_24004 \x3d (state_24007[(2)]);\nvar state_24007__$1 \x3d state_24007;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_24007__$1,inst_24004);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (12))){\nvar state_24007__$1 \x3d state_24007;\nvar statearr_24045_27264 \x3d state_24007__$1;\n(statearr_24045_27264[(2)] \x3d null);\n\n(statearr_24045_27264[(1)] \x3d (13));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (2))){\nvar inst_23982 \x3d (state_24007[(7)]);\nvar state_24007__$1 \x3d state_24007;\nif(cljs.core.truth_(inst_23982)){\nvar statearr_24050_27265 \x3d state_24007__$1;\n(statearr_24050_27265[(1)] \x3d (4));\n\n} else {\nvar statearr_24051_27266 \x3d state_24007__$1;\n(statearr_24051_27266[(1)] \x3d (5));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (11))){\nvar inst_23996 \x3d cljs.core.async.close_BANG_(ch);\nvar state_24007__$1 \x3d state_24007;\nvar statearr_24053_27268 \x3d state_24007__$1;\n(statearr_24053_27268[(2)] \x3d inst_23996);\n\n(statearr_24053_27268[(1)] \x3d (13));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (9))){\nvar state_24007__$1 \x3d state_24007;\nif(cljs.core.truth_(close_QMARK_)){\nvar statearr_24055_27271 \x3d state_24007__$1;\n(statearr_24055_27271[(1)] \x3d (11));\n\n} else {\nvar statearr_24056_27272 \x3d state_24007__$1;\n(statearr_24056_27272[(1)] \x3d (12));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (5))){\nvar inst_23982 \x3d (state_24007[(7)]);\nvar state_24007__$1 \x3d state_24007;\nvar statearr_24058_27273 \x3d state_24007__$1;\n(statearr_24058_27273[(2)] \x3d inst_23982);\n\n(statearr_24058_27273[(1)] \x3d (6));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (10))){\nvar inst_24001 \x3d (state_24007[(2)]);\nvar state_24007__$1 \x3d state_24007;\nvar statearr_24062_27276 \x3d state_24007__$1;\n(statearr_24062_27276[(2)] \x3d inst_24001);\n\n(statearr_24062_27276[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24008 \x3d\x3d\x3d (8))){\nvar inst_23982 \x3d (state_24007[(7)]);\nvar inst_23992 \x3d cljs.core.next(inst_23982);\nvar inst_23982__$1 \x3d inst_23992;\nvar state_24007__$1 \x3d (function (){var statearr_24069 \x3d state_24007;\n(statearr_24069[(7)] \x3d inst_23982__$1);\n\nreturn statearr_24069;\n})();\nvar statearr_24070_27278 \x3d state_24007__$1;\n(statearr_24070_27278[(2)] \x3d null);\n\n(statearr_24070_27278[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_24072 \x3d [null,null,null,null,null,null,null,null];\n(statearr_24072[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_24072[(1)] \x3d (1));\n\nreturn statearr_24072;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_24007){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_24007);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e24074){var ex__21558__auto__ \x3d e24074;\nvar statearr_24075_27283 \x3d state_24007;\n(statearr_24075_27283[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_24007[(4)]))){\nvar statearr_24078_27285 \x3d state_24007;\n(statearr_24078_27285[(1)] \x3d cljs.core.first((state_24007[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27287 \x3d state_24007;\nstate_24007 \x3d G__27287;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_24007){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_24007);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_24085 \x3d f__22635__auto__();\n(statearr_24085[(6)] \x3d c__22634__auto__);\n\nreturn statearr_24085;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\nreturn c__22634__auto__;\n}));\n\n(cljs.core.async.onto_chan_BANG_.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Creates and returns a channel which contains the contents of coll,\n *   closing when exhausted.\n */\ncljs.core.async.to_chan_BANG_ \x3d (function cljs$core$async$to_chan_BANG_(coll){\nvar ch \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(cljs.core.bounded_count((100),coll));\ncljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$2(ch,coll);\n\nreturn ch;\n});\n/**\n * Deprecated - use onto-chan!\n */\ncljs.core.async.onto_chan \x3d (function cljs$core$async$onto_chan(var_args){\nvar G__24096 \x3d arguments.length;\nswitch (G__24096) {\ncase 2:\nreturn cljs.core.async.onto_chan.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.onto_chan.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.onto_chan.cljs$core$IFn$_invoke$arity$2 \x3d (function (ch,coll){\nreturn cljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$3(ch,coll,true);\n}));\n\n(cljs.core.async.onto_chan.cljs$core$IFn$_invoke$arity$3 \x3d (function (ch,coll,close_QMARK_){\nreturn cljs.core.async.onto_chan_BANG_.cljs$core$IFn$_invoke$arity$3(ch,coll,close_QMARK_);\n}));\n\n(cljs.core.async.onto_chan.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Deprecated - use to-chan!\n */\ncljs.core.async.to_chan \x3d (function cljs$core$async$to_chan(coll){\nreturn cljs.core.async.to_chan_BANG_(coll);\n});\n\n/**\n * @interface\n */\ncljs.core.async.Mux \x3d function(){};\n\nvar cljs$core$async$Mux$muxch_STAR_$dyn_27291 \x3d (function (_){\nvar x__5350__auto__ \x3d (((_ \x3d\x3d null))?null:_);\nvar m__5351__auto__ \x3d (cljs.core.async.muxch_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(_) : m__5351__auto__.call(null, _));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.muxch_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(_) : m__5349__auto__.call(null, _));\n} else {\nthrow cljs.core.missing_protocol(\x22Mux.muxch*\x22,_);\n}\n}\n});\ncljs.core.async.muxch_STAR_ \x3d (function cljs$core$async$muxch_STAR_(_){\nif((((!((_ \x3d\x3d null)))) \x26\x26 ((!((_.cljs$core$async$Mux$muxch_STAR_$arity$1 \x3d\x3d null)))))){\nreturn _.cljs$core$async$Mux$muxch_STAR_$arity$1(_);\n} else {\nreturn cljs$core$async$Mux$muxch_STAR_$dyn_27291(_);\n}\n});\n\n\n/**\n * @interface\n */\ncljs.core.async.Mult \x3d function(){};\n\nvar cljs$core$async$Mult$tap_STAR_$dyn_27302 \x3d (function (m,ch,close_QMARK_){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.tap_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(m,ch,close_QMARK_) : m__5351__auto__.call(null, m,ch,close_QMARK_));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.tap_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(m,ch,close_QMARK_) : m__5349__auto__.call(null, m,ch,close_QMARK_));\n} else {\nthrow cljs.core.missing_protocol(\x22Mult.tap*\x22,m);\n}\n}\n});\ncljs.core.async.tap_STAR_ \x3d (function cljs$core$async$tap_STAR_(m,ch,close_QMARK_){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mult$tap_STAR_$arity$3 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mult$tap_STAR_$arity$3(m,ch,close_QMARK_);\n} else {\nreturn cljs$core$async$Mult$tap_STAR_$dyn_27302(m,ch,close_QMARK_);\n}\n});\n\nvar cljs$core$async$Mult$untap_STAR_$dyn_27303 \x3d (function (m,ch){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.untap_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(m,ch) : m__5351__auto__.call(null, m,ch));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.untap_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(m,ch) : m__5349__auto__.call(null, m,ch));\n} else {\nthrow cljs.core.missing_protocol(\x22Mult.untap*\x22,m);\n}\n}\n});\ncljs.core.async.untap_STAR_ \x3d (function cljs$core$async$untap_STAR_(m,ch){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mult$untap_STAR_$arity$2 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mult$untap_STAR_$arity$2(m,ch);\n} else {\nreturn cljs$core$async$Mult$untap_STAR_$dyn_27303(m,ch);\n}\n});\n\nvar cljs$core$async$Mult$untap_all_STAR_$dyn_27316 \x3d (function (m){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.untap_all_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(m) : m__5351__auto__.call(null, m));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.untap_all_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(m) : m__5349__auto__.call(null, m));\n} else {\nthrow cljs.core.missing_protocol(\x22Mult.untap-all*\x22,m);\n}\n}\n});\ncljs.core.async.untap_all_STAR_ \x3d (function cljs$core$async$untap_all_STAR_(m){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mult$untap_all_STAR_$arity$1 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mult$untap_all_STAR_$arity$1(m);\n} else {\nreturn cljs$core$async$Mult$untap_all_STAR_$dyn_27316(m);\n}\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.async.Mult}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.async.Mux}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async24186 \x3d (function (ch,cs,meta24187){\nthis.ch \x3d ch;\nthis.cs \x3d cs;\nthis.meta24187 \x3d meta24187;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24188,meta24187__$1){\nvar self__ \x3d this;\nvar _24188__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async24186(self__.ch,self__.cs,meta24187__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24188){\nvar self__ \x3d this;\nvar _24188__$1 \x3d this;\nreturn self__.meta24187;\n}));\n\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$async$Mux$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$async$Mux$muxch_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.ch;\n}));\n\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$async$Mult$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$async$Mult$tap_STAR_$arity$3 \x3d (function (_,ch__$1,close_QMARK_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.cs,cljs.core.assoc,ch__$1,close_QMARK_);\n\nreturn null;\n}));\n\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$async$Mult$untap_STAR_$arity$2 \x3d (function (_,ch__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(self__.cs,cljs.core.dissoc,ch__$1);\n\nreturn null;\n}));\n\n(cljs.core.async.t_cljs$core$async24186.prototype.cljs$core$async$Mult$untap_all_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.reset_BANG_(self__.cs,cljs.core.PersistentArrayMap.EMPTY);\n\nreturn null;\n}));\n\n(cljs.core.async.t_cljs$core$async24186.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22ch\x22,\x22ch\x22,1085813622,null),new cljs.core.Symbol(null,\x22cs\x22,\x22cs\x22,-117024463,null),new cljs.core.Symbol(null,\x22meta24187\x22,\x22meta24187\x22,-88470828,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async24186.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async24186.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async24186\x22);\n\n(cljs.core.async.t_cljs$core$async24186.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async24186\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async24186.\n */\ncljs.core.async.__GT_t_cljs$core$async24186 \x3d (function cljs$core$async$__GT_t_cljs$core$async24186(ch,cs,meta24187){\nreturn (new cljs.core.async.t_cljs$core$async24186(ch,cs,meta24187));\n});\n\n\n/**\n * Creates and returns a mult(iple) of the supplied channel. Channels\n *   containing copies of the channel can be created with \x27tap\x27, and\n *   detached with \x27untap\x27.\n * \n *   Each item is distributed to all taps in parallel and synchronously,\n *   i.e. each tap must accept before the next item is distributed. Use\n *   buffering/windowing to prevent slow taps from holding up the mult.\n * \n *   Items received when there are no taps get dropped.\n * \n *   If a tap puts to a closed channel, it will be removed from the mult.\n */\ncljs.core.async.mult \x3d (function cljs$core$async$mult(ch){\nvar cs \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar m \x3d (new cljs.core.async.t_cljs$core$async24186(ch,cs,cljs.core.PersistentArrayMap.EMPTY));\nvar dchan \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\nvar dctr \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(null);\nvar done \x3d (function (_){\nif((cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(dctr,cljs.core.dec) \x3d\x3d\x3d (0))){\nreturn cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(dchan,true);\n} else {\nreturn null;\n}\n});\nvar c__22634__auto___27320 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_24501){\nvar state_val_24505 \x3d (state_24501[(1)]);\nif((state_val_24505 \x3d\x3d\x3d (7))){\nvar inst_24495 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24514_27321 \x3d state_24501__$1;\n(statearr_24514_27321[(2)] \x3d inst_24495);\n\n(statearr_24514_27321[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (20))){\nvar inst_24341 \x3d (state_24501[(7)]);\nvar inst_24371 \x3d cljs.core.first(inst_24341);\nvar inst_24389 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_24371,(0),null);\nvar inst_24397 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_24371,(1),null);\nvar state_24501__$1 \x3d (function (){var statearr_24519 \x3d state_24501;\n(statearr_24519[(8)] \x3d inst_24389);\n\nreturn statearr_24519;\n})();\nif(cljs.core.truth_(inst_24397)){\nvar statearr_24520_27322 \x3d state_24501__$1;\n(statearr_24520_27322[(1)] \x3d (22));\n\n} else {\nvar statearr_24521_27323 \x3d state_24501__$1;\n(statearr_24521_27323[(1)] \x3d (23));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (27))){\nvar inst_24268 \x3d (state_24501[(9)]);\nvar inst_24437 \x3d (state_24501[(10)]);\nvar inst_24435 \x3d (state_24501[(11)]);\nvar inst_24442 \x3d (state_24501[(12)]);\nvar inst_24442__$1 \x3d cljs.core._nth(inst_24435,inst_24437);\nvar inst_24444 \x3d cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$3(inst_24442__$1,inst_24268,done);\nvar state_24501__$1 \x3d (function (){var statearr_24524 \x3d state_24501;\n(statearr_24524[(12)] \x3d inst_24442__$1);\n\nreturn statearr_24524;\n})();\nif(cljs.core.truth_(inst_24444)){\nvar statearr_24526_27324 \x3d state_24501__$1;\n(statearr_24526_27324[(1)] \x3d (30));\n\n} else {\nvar statearr_24527_27325 \x3d state_24501__$1;\n(statearr_24527_27325[(1)] \x3d (31));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (1))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24530_27326 \x3d state_24501__$1;\n(statearr_24530_27326[(2)] \x3d null);\n\n(statearr_24530_27326[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (24))){\nvar inst_24341 \x3d (state_24501[(7)]);\nvar inst_24412 \x3d (state_24501[(2)]);\nvar inst_24413 \x3d cljs.core.next(inst_24341);\nvar inst_24287 \x3d inst_24413;\nvar inst_24288 \x3d null;\nvar inst_24289 \x3d (0);\nvar inst_24290 \x3d (0);\nvar state_24501__$1 \x3d (function (){var statearr_24536 \x3d state_24501;\n(statearr_24536[(13)] \x3d inst_24289);\n\n(statearr_24536[(14)] \x3d inst_24290);\n\n(statearr_24536[(15)] \x3d inst_24288);\n\n(statearr_24536[(16)] \x3d inst_24287);\n\n(statearr_24536[(17)] \x3d inst_24412);\n\nreturn statearr_24536;\n})();\nvar statearr_24537_27331 \x3d state_24501__$1;\n(statearr_24537_27331[(2)] \x3d null);\n\n(statearr_24537_27331[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (39))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24546_27332 \x3d state_24501__$1;\n(statearr_24546_27332[(2)] \x3d null);\n\n(statearr_24546_27332[(1)] \x3d (41));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (4))){\nvar inst_24268 \x3d (state_24501[(9)]);\nvar inst_24268__$1 \x3d (state_24501[(2)]);\nvar inst_24273 \x3d (inst_24268__$1 \x3d\x3d null);\nvar state_24501__$1 \x3d (function (){var statearr_24549 \x3d state_24501;\n(statearr_24549[(9)] \x3d inst_24268__$1);\n\nreturn statearr_24549;\n})();\nif(cljs.core.truth_(inst_24273)){\nvar statearr_24550_27337 \x3d state_24501__$1;\n(statearr_24550_27337[(1)] \x3d (5));\n\n} else {\nvar statearr_24551_27338 \x3d state_24501__$1;\n(statearr_24551_27338[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (15))){\nvar inst_24289 \x3d (state_24501[(13)]);\nvar inst_24290 \x3d (state_24501[(14)]);\nvar inst_24288 \x3d (state_24501[(15)]);\nvar inst_24287 \x3d (state_24501[(16)]);\nvar inst_24326 \x3d (state_24501[(2)]);\nvar inst_24330 \x3d (inst_24290 + (1));\nvar tmp24541 \x3d inst_24289;\nvar tmp24542 \x3d inst_24288;\nvar tmp24543 \x3d inst_24287;\nvar inst_24287__$1 \x3d tmp24543;\nvar inst_24288__$1 \x3d tmp24542;\nvar inst_24289__$1 \x3d tmp24541;\nvar inst_24290__$1 \x3d inst_24330;\nvar state_24501__$1 \x3d (function (){var statearr_24552 \x3d state_24501;\n(statearr_24552[(13)] \x3d inst_24289__$1);\n\n(statearr_24552[(14)] \x3d inst_24290__$1);\n\n(statearr_24552[(15)] \x3d inst_24288__$1);\n\n(statearr_24552[(18)] \x3d inst_24326);\n\n(statearr_24552[(16)] \x3d inst_24287__$1);\n\nreturn statearr_24552;\n})();\nvar statearr_24553_27344 \x3d state_24501__$1;\n(statearr_24553_27344[(2)] \x3d null);\n\n(statearr_24553_27344[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (21))){\nvar inst_24416 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24557_27349 \x3d state_24501__$1;\n(statearr_24557_27349[(2)] \x3d inst_24416);\n\n(statearr_24557_27349[(1)] \x3d (18));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (31))){\nvar inst_24442 \x3d (state_24501[(12)]);\nvar inst_24448 \x3d m.cljs$core$async$Mult$untap_STAR_$arity$2(null, inst_24442);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24561_27350 \x3d state_24501__$1;\n(statearr_24561_27350[(2)] \x3d inst_24448);\n\n(statearr_24561_27350[(1)] \x3d (32));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (32))){\nvar inst_24437 \x3d (state_24501[(10)]);\nvar inst_24435 \x3d (state_24501[(11)]);\nvar inst_24436 \x3d (state_24501[(19)]);\nvar inst_24434 \x3d (state_24501[(20)]);\nvar inst_24451 \x3d (state_24501[(2)]);\nvar inst_24452 \x3d (inst_24437 + (1));\nvar tmp24554 \x3d inst_24435;\nvar tmp24555 \x3d inst_24436;\nvar tmp24556 \x3d inst_24434;\nvar inst_24434__$1 \x3d tmp24556;\nvar inst_24435__$1 \x3d tmp24554;\nvar inst_24436__$1 \x3d tmp24555;\nvar inst_24437__$1 \x3d inst_24452;\nvar state_24501__$1 \x3d (function (){var statearr_24563 \x3d state_24501;\n(statearr_24563[(10)] \x3d inst_24437__$1);\n\n(statearr_24563[(11)] \x3d inst_24435__$1);\n\n(statearr_24563[(19)] \x3d inst_24436__$1);\n\n(statearr_24563[(21)] \x3d inst_24451);\n\n(statearr_24563[(20)] \x3d inst_24434__$1);\n\nreturn statearr_24563;\n})();\nvar statearr_24564_27353 \x3d state_24501__$1;\n(statearr_24564_27353[(2)] \x3d null);\n\n(statearr_24564_27353[(1)] \x3d (25));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (40))){\nvar inst_24466 \x3d (state_24501[(22)]);\nvar inst_24470 \x3d m.cljs$core$async$Mult$untap_STAR_$arity$2(null, inst_24466);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24566_27354 \x3d state_24501__$1;\n(statearr_24566_27354[(2)] \x3d inst_24470);\n\n(statearr_24566_27354[(1)] \x3d (41));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (33))){\nvar inst_24455 \x3d (state_24501[(23)]);\nvar inst_24457 \x3d cljs.core.chunked_seq_QMARK_(inst_24455);\nvar state_24501__$1 \x3d state_24501;\nif(inst_24457){\nvar statearr_24575_27355 \x3d state_24501__$1;\n(statearr_24575_27355[(1)] \x3d (36));\n\n} else {\nvar statearr_24576_27356 \x3d state_24501__$1;\n(statearr_24576_27356[(1)] \x3d (37));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (13))){\nvar inst_24315 \x3d (state_24501[(24)]);\nvar inst_24323 \x3d cljs.core.async.close_BANG_(inst_24315);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24577_27360 \x3d state_24501__$1;\n(statearr_24577_27360[(2)] \x3d inst_24323);\n\n(statearr_24577_27360[(1)] \x3d (15));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (22))){\nvar inst_24389 \x3d (state_24501[(8)]);\nvar inst_24409 \x3d cljs.core.async.close_BANG_(inst_24389);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24578_27361 \x3d state_24501__$1;\n(statearr_24578_27361[(2)] \x3d inst_24409);\n\n(statearr_24578_27361[(1)] \x3d (24));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (36))){\nvar inst_24455 \x3d (state_24501[(23)]);\nvar inst_24460 \x3d cljs.core.chunk_first(inst_24455);\nvar inst_24461 \x3d cljs.core.chunk_rest(inst_24455);\nvar inst_24462 \x3d cljs.core.count(inst_24460);\nvar inst_24434 \x3d inst_24461;\nvar inst_24435 \x3d inst_24460;\nvar inst_24436 \x3d inst_24462;\nvar inst_24437 \x3d (0);\nvar state_24501__$1 \x3d (function (){var statearr_24587 \x3d state_24501;\n(statearr_24587[(10)] \x3d inst_24437);\n\n(statearr_24587[(11)] \x3d inst_24435);\n\n(statearr_24587[(19)] \x3d inst_24436);\n\n(statearr_24587[(20)] \x3d inst_24434);\n\nreturn statearr_24587;\n})();\nvar statearr_24588_27362 \x3d state_24501__$1;\n(statearr_24588_27362[(2)] \x3d null);\n\n(statearr_24588_27362[(1)] \x3d (25));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (41))){\nvar inst_24455 \x3d (state_24501[(23)]);\nvar inst_24472 \x3d (state_24501[(2)]);\nvar inst_24473 \x3d cljs.core.next(inst_24455);\nvar inst_24434 \x3d inst_24473;\nvar inst_24435 \x3d null;\nvar inst_24436 \x3d (0);\nvar inst_24437 \x3d (0);\nvar state_24501__$1 \x3d (function (){var statearr_24591 \x3d state_24501;\n(statearr_24591[(25)] \x3d inst_24472);\n\n(statearr_24591[(10)] \x3d inst_24437);\n\n(statearr_24591[(11)] \x3d inst_24435);\n\n(statearr_24591[(19)] \x3d inst_24436);\n\n(statearr_24591[(20)] \x3d inst_24434);\n\nreturn statearr_24591;\n})();\nvar statearr_24592_27363 \x3d state_24501__$1;\n(statearr_24592_27363[(2)] \x3d null);\n\n(statearr_24592_27363[(1)] \x3d (25));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (43))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24594_27364 \x3d state_24501__$1;\n(statearr_24594_27364[(2)] \x3d null);\n\n(statearr_24594_27364[(1)] \x3d (44));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (29))){\nvar inst_24481 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24597_27369 \x3d state_24501__$1;\n(statearr_24597_27369[(2)] \x3d inst_24481);\n\n(statearr_24597_27369[(1)] \x3d (26));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (44))){\nvar inst_24492 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d (function (){var statearr_24603 \x3d state_24501;\n(statearr_24603[(26)] \x3d inst_24492);\n\nreturn statearr_24603;\n})();\nvar statearr_24604_27370 \x3d state_24501__$1;\n(statearr_24604_27370[(2)] \x3d null);\n\n(statearr_24604_27370[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (6))){\nvar inst_24426 \x3d (state_24501[(27)]);\nvar inst_24425 \x3d cljs.core.deref(cs);\nvar inst_24426__$1 \x3d cljs.core.keys(inst_24425);\nvar inst_24427 \x3d cljs.core.count(inst_24426__$1);\nvar inst_24428 \x3d cljs.core.reset_BANG_(dctr,inst_24427);\nvar inst_24433 \x3d cljs.core.seq(inst_24426__$1);\nvar inst_24434 \x3d inst_24433;\nvar inst_24435 \x3d null;\nvar inst_24436 \x3d (0);\nvar inst_24437 \x3d (0);\nvar state_24501__$1 \x3d (function (){var statearr_24606 \x3d state_24501;\n(statearr_24606[(28)] \x3d inst_24428);\n\n(statearr_24606[(10)] \x3d inst_24437);\n\n(statearr_24606[(11)] \x3d inst_24435);\n\n(statearr_24606[(19)] \x3d inst_24436);\n\n(statearr_24606[(27)] \x3d inst_24426__$1);\n\n(statearr_24606[(20)] \x3d inst_24434);\n\nreturn statearr_24606;\n})();\nvar statearr_24608_27371 \x3d state_24501__$1;\n(statearr_24608_27371[(2)] \x3d null);\n\n(statearr_24608_27371[(1)] \x3d (25));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (28))){\nvar inst_24455 \x3d (state_24501[(23)]);\nvar inst_24434 \x3d (state_24501[(20)]);\nvar inst_24455__$1 \x3d cljs.core.seq(inst_24434);\nvar state_24501__$1 \x3d (function (){var statearr_24609 \x3d state_24501;\n(statearr_24609[(23)] \x3d inst_24455__$1);\n\nreturn statearr_24609;\n})();\nif(inst_24455__$1){\nvar statearr_24610_27372 \x3d state_24501__$1;\n(statearr_24610_27372[(1)] \x3d (33));\n\n} else {\nvar statearr_24612_27374 \x3d state_24501__$1;\n(statearr_24612_27374[(1)] \x3d (34));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (25))){\nvar inst_24437 \x3d (state_24501[(10)]);\nvar inst_24436 \x3d (state_24501[(19)]);\nvar inst_24439 \x3d (inst_24437 \x3c inst_24436);\nvar inst_24440 \x3d inst_24439;\nvar state_24501__$1 \x3d state_24501;\nif(cljs.core.truth_(inst_24440)){\nvar statearr_24615_27378 \x3d state_24501__$1;\n(statearr_24615_27378[(1)] \x3d (27));\n\n} else {\nvar statearr_24618_27379 \x3d state_24501__$1;\n(statearr_24618_27379[(1)] \x3d (28));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (34))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24620_27380 \x3d state_24501__$1;\n(statearr_24620_27380[(2)] \x3d null);\n\n(statearr_24620_27380[(1)] \x3d (35));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (17))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24623_27381 \x3d state_24501__$1;\n(statearr_24623_27381[(2)] \x3d null);\n\n(statearr_24623_27381[(1)] \x3d (18));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (3))){\nvar inst_24497 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_24501__$1,inst_24497);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (12))){\nvar inst_24421 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24628_27382 \x3d state_24501__$1;\n(statearr_24628_27382[(2)] \x3d inst_24421);\n\n(statearr_24628_27382[(1)] \x3d (9));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (2))){\nvar state_24501__$1 \x3d state_24501;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_24501__$1,(4),ch);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (23))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24630_27383 \x3d state_24501__$1;\n(statearr_24630_27383[(2)] \x3d null);\n\n(statearr_24630_27383[(1)] \x3d (24));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (35))){\nvar inst_24479 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24631_27384 \x3d state_24501__$1;\n(statearr_24631_27384[(2)] \x3d inst_24479);\n\n(statearr_24631_27384[(1)] \x3d (29));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (19))){\nvar inst_24341 \x3d (state_24501[(7)]);\nvar inst_24352 \x3d cljs.core.chunk_first(inst_24341);\nvar inst_24353 \x3d cljs.core.chunk_rest(inst_24341);\nvar inst_24355 \x3d cljs.core.count(inst_24352);\nvar inst_24287 \x3d inst_24353;\nvar inst_24288 \x3d inst_24352;\nvar inst_24289 \x3d inst_24355;\nvar inst_24290 \x3d (0);\nvar state_24501__$1 \x3d (function (){var statearr_24635 \x3d state_24501;\n(statearr_24635[(13)] \x3d inst_24289);\n\n(statearr_24635[(14)] \x3d inst_24290);\n\n(statearr_24635[(15)] \x3d inst_24288);\n\n(statearr_24635[(16)] \x3d inst_24287);\n\nreturn statearr_24635;\n})();\nvar statearr_24637_27385 \x3d state_24501__$1;\n(statearr_24637_27385[(2)] \x3d null);\n\n(statearr_24637_27385[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (11))){\nvar inst_24341 \x3d (state_24501[(7)]);\nvar inst_24287 \x3d (state_24501[(16)]);\nvar inst_24341__$1 \x3d cljs.core.seq(inst_24287);\nvar state_24501__$1 \x3d (function (){var statearr_24640 \x3d state_24501;\n(statearr_24640[(7)] \x3d inst_24341__$1);\n\nreturn statearr_24640;\n})();\nif(inst_24341__$1){\nvar statearr_24641_27386 \x3d state_24501__$1;\n(statearr_24641_27386[(1)] \x3d (16));\n\n} else {\nvar statearr_24645_27387 \x3d state_24501__$1;\n(statearr_24645_27387[(1)] \x3d (17));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (9))){\nvar inst_24423 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24646_27388 \x3d state_24501__$1;\n(statearr_24646_27388[(2)] \x3d inst_24423);\n\n(statearr_24646_27388[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (5))){\nvar inst_24284 \x3d cljs.core.deref(cs);\nvar inst_24285 \x3d cljs.core.seq(inst_24284);\nvar inst_24287 \x3d inst_24285;\nvar inst_24288 \x3d null;\nvar inst_24289 \x3d (0);\nvar inst_24290 \x3d (0);\nvar state_24501__$1 \x3d (function (){var statearr_24648 \x3d state_24501;\n(statearr_24648[(13)] \x3d inst_24289);\n\n(statearr_24648[(14)] \x3d inst_24290);\n\n(statearr_24648[(15)] \x3d inst_24288);\n\n(statearr_24648[(16)] \x3d inst_24287);\n\nreturn statearr_24648;\n})();\nvar statearr_24652_27393 \x3d state_24501__$1;\n(statearr_24652_27393[(2)] \x3d null);\n\n(statearr_24652_27393[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (14))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24653_27394 \x3d state_24501__$1;\n(statearr_24653_27394[(2)] \x3d null);\n\n(statearr_24653_27394[(1)] \x3d (15));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (45))){\nvar inst_24488 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24654_27395 \x3d state_24501__$1;\n(statearr_24654_27395[(2)] \x3d inst_24488);\n\n(statearr_24654_27395[(1)] \x3d (44));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (26))){\nvar inst_24426 \x3d (state_24501[(27)]);\nvar inst_24483 \x3d (state_24501[(2)]);\nvar inst_24484 \x3d cljs.core.seq(inst_24426);\nvar state_24501__$1 \x3d (function (){var statearr_24655 \x3d state_24501;\n(statearr_24655[(29)] \x3d inst_24483);\n\nreturn statearr_24655;\n})();\nif(inst_24484){\nvar statearr_24656_27396 \x3d state_24501__$1;\n(statearr_24656_27396[(1)] \x3d (42));\n\n} else {\nvar statearr_24657_27397 \x3d state_24501__$1;\n(statearr_24657_27397[(1)] \x3d (43));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (16))){\nvar inst_24341 \x3d (state_24501[(7)]);\nvar inst_24345 \x3d cljs.core.chunked_seq_QMARK_(inst_24341);\nvar state_24501__$1 \x3d state_24501;\nif(inst_24345){\nvar statearr_24658_27400 \x3d state_24501__$1;\n(statearr_24658_27400[(1)] \x3d (19));\n\n} else {\nvar statearr_24659_27404 \x3d state_24501__$1;\n(statearr_24659_27404[(1)] \x3d (20));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (38))){\nvar inst_24476 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24661_27405 \x3d state_24501__$1;\n(statearr_24661_27405[(2)] \x3d inst_24476);\n\n(statearr_24661_27405[(1)] \x3d (35));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (30))){\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24662_27406 \x3d state_24501__$1;\n(statearr_24662_27406[(2)] \x3d null);\n\n(statearr_24662_27406[(1)] \x3d (32));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (10))){\nvar inst_24290 \x3d (state_24501[(14)]);\nvar inst_24288 \x3d (state_24501[(15)]);\nvar inst_24311 \x3d cljs.core._nth(inst_24288,inst_24290);\nvar inst_24315 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_24311,(0),null);\nvar inst_24316 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_24311,(1),null);\nvar state_24501__$1 \x3d (function (){var statearr_24667 \x3d state_24501;\n(statearr_24667[(24)] \x3d inst_24315);\n\nreturn statearr_24667;\n})();\nif(cljs.core.truth_(inst_24316)){\nvar statearr_24669_27407 \x3d state_24501__$1;\n(statearr_24669_27407[(1)] \x3d (13));\n\n} else {\nvar statearr_24672_27408 \x3d state_24501__$1;\n(statearr_24672_27408[(1)] \x3d (14));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (18))){\nvar inst_24419 \x3d (state_24501[(2)]);\nvar state_24501__$1 \x3d state_24501;\nvar statearr_24673_27410 \x3d state_24501__$1;\n(statearr_24673_27410[(2)] \x3d inst_24419);\n\n(statearr_24673_27410[(1)] \x3d (12));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (42))){\nvar state_24501__$1 \x3d state_24501;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_24501__$1,(45),dchan);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (37))){\nvar inst_24466 \x3d (state_24501[(22)]);\nvar inst_24268 \x3d (state_24501[(9)]);\nvar inst_24455 \x3d (state_24501[(23)]);\nvar inst_24466__$1 \x3d cljs.core.first(inst_24455);\nvar inst_24467 \x3d cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$3(inst_24466__$1,inst_24268,done);\nvar state_24501__$1 \x3d (function (){var statearr_24674 \x3d state_24501;\n(statearr_24674[(22)] \x3d inst_24466__$1);\n\nreturn statearr_24674;\n})();\nif(cljs.core.truth_(inst_24467)){\nvar statearr_24675_27413 \x3d state_24501__$1;\n(statearr_24675_27413[(1)] \x3d (39));\n\n} else {\nvar statearr_24676_27414 \x3d state_24501__$1;\n(statearr_24676_27414[(1)] \x3d (40));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24505 \x3d\x3d\x3d (8))){\nvar inst_24289 \x3d (state_24501[(13)]);\nvar inst_24290 \x3d (state_24501[(14)]);\nvar inst_24300 \x3d (inst_24290 \x3c inst_24289);\nvar inst_24301 \x3d inst_24300;\nvar state_24501__$1 \x3d state_24501;\nif(cljs.core.truth_(inst_24301)){\nvar statearr_24677_27415 \x3d state_24501__$1;\n(statearr_24677_27415[(1)] \x3d (10));\n\n} else {\nvar statearr_24678_27416 \x3d state_24501__$1;\n(statearr_24678_27416[(1)] \x3d (11));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$mult_$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$mult_$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_24679 \x3d [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];\n(statearr_24679[(0)] \x3d cljs$core$async$mult_$_state_machine__21555__auto__);\n\n(statearr_24679[(1)] \x3d (1));\n\nreturn statearr_24679;\n});\nvar cljs$core$async$mult_$_state_machine__21555__auto____1 \x3d (function (state_24501){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_24501);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e24682){var ex__21558__auto__ \x3d e24682;\nvar statearr_24684_27417 \x3d state_24501;\n(statearr_24684_27417[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_24501[(4)]))){\nvar statearr_24685_27418 \x3d state_24501;\n(statearr_24685_27418[(1)] \x3d cljs.core.first((state_24501[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27419 \x3d state_24501;\nstate_24501 \x3d G__27419;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$mult_$_state_machine__21555__auto__ \x3d function(state_24501){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$mult_$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$mult_$_state_machine__21555__auto____1.call(this,state_24501);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$mult_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$mult_$_state_machine__21555__auto____0;\ncljs$core$async$mult_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$mult_$_state_machine__21555__auto____1;\nreturn cljs$core$async$mult_$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_24690 \x3d f__22635__auto__();\n(statearr_24690[(6)] \x3d c__22634__auto___27320);\n\nreturn statearr_24690;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn m;\n});\n/**\n * Copies the mult source onto the supplied channel.\n * \n *   By default the channel will be closed when the source closes,\n *   but can be determined by the close? parameter.\n */\ncljs.core.async.tap \x3d (function cljs$core$async$tap(var_args){\nvar G__24692 \x3d arguments.length;\nswitch (G__24692) {\ncase 2:\nreturn cljs.core.async.tap.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.tap.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.tap.cljs$core$IFn$_invoke$arity$2 \x3d (function (mult,ch){\nreturn cljs.core.async.tap.cljs$core$IFn$_invoke$arity$3(mult,ch,true);\n}));\n\n(cljs.core.async.tap.cljs$core$IFn$_invoke$arity$3 \x3d (function (mult,ch,close_QMARK_){\ncljs.core.async.tap_STAR_(mult,ch,close_QMARK_);\n\nreturn ch;\n}));\n\n(cljs.core.async.tap.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Disconnects a target channel from a mult\n */\ncljs.core.async.untap \x3d (function cljs$core$async$untap(mult,ch){\nreturn cljs.core.async.untap_STAR_(mult,ch);\n});\n/**\n * Disconnects all target channels from a mult\n */\ncljs.core.async.untap_all \x3d (function cljs$core$async$untap_all(mult){\nreturn cljs.core.async.untap_all_STAR_(mult);\n});\n\n/**\n * @interface\n */\ncljs.core.async.Mix \x3d function(){};\n\nvar cljs$core$async$Mix$admix_STAR_$dyn_27430 \x3d (function (m,ch){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.admix_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(m,ch) : m__5351__auto__.call(null, m,ch));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.admix_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(m,ch) : m__5349__auto__.call(null, m,ch));\n} else {\nthrow cljs.core.missing_protocol(\x22Mix.admix*\x22,m);\n}\n}\n});\ncljs.core.async.admix_STAR_ \x3d (function cljs$core$async$admix_STAR_(m,ch){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mix$admix_STAR_$arity$2 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mix$admix_STAR_$arity$2(m,ch);\n} else {\nreturn cljs$core$async$Mix$admix_STAR_$dyn_27430(m,ch);\n}\n});\n\nvar cljs$core$async$Mix$unmix_STAR_$dyn_27431 \x3d (function (m,ch){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.unmix_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(m,ch) : m__5351__auto__.call(null, m,ch));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.unmix_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(m,ch) : m__5349__auto__.call(null, m,ch));\n} else {\nthrow cljs.core.missing_protocol(\x22Mix.unmix*\x22,m);\n}\n}\n});\ncljs.core.async.unmix_STAR_ \x3d (function cljs$core$async$unmix_STAR_(m,ch){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mix$unmix_STAR_$arity$2 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mix$unmix_STAR_$arity$2(m,ch);\n} else {\nreturn cljs$core$async$Mix$unmix_STAR_$dyn_27431(m,ch);\n}\n});\n\nvar cljs$core$async$Mix$unmix_all_STAR_$dyn_27433 \x3d (function (m){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.unmix_all_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(m) : m__5351__auto__.call(null, m));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.unmix_all_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(m) : m__5349__auto__.call(null, m));\n} else {\nthrow cljs.core.missing_protocol(\x22Mix.unmix-all*\x22,m);\n}\n}\n});\ncljs.core.async.unmix_all_STAR_ \x3d (function cljs$core$async$unmix_all_STAR_(m){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mix$unmix_all_STAR_$arity$1 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mix$unmix_all_STAR_$arity$1(m);\n} else {\nreturn cljs$core$async$Mix$unmix_all_STAR_$dyn_27433(m);\n}\n});\n\nvar cljs$core$async$Mix$toggle_STAR_$dyn_27438 \x3d (function (m,state_map){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.toggle_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(m,state_map) : m__5351__auto__.call(null, m,state_map));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.toggle_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(m,state_map) : m__5349__auto__.call(null, m,state_map));\n} else {\nthrow cljs.core.missing_protocol(\x22Mix.toggle*\x22,m);\n}\n}\n});\ncljs.core.async.toggle_STAR_ \x3d (function cljs$core$async$toggle_STAR_(m,state_map){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mix$toggle_STAR_$arity$2 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mix$toggle_STAR_$arity$2(m,state_map);\n} else {\nreturn cljs$core$async$Mix$toggle_STAR_$dyn_27438(m,state_map);\n}\n});\n\nvar cljs$core$async$Mix$solo_mode_STAR_$dyn_27439 \x3d (function (m,mode){\nvar x__5350__auto__ \x3d (((m \x3d\x3d null))?null:m);\nvar m__5351__auto__ \x3d (cljs.core.async.solo_mode_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(m,mode) : m__5351__auto__.call(null, m,mode));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.solo_mode_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(m,mode) : m__5349__auto__.call(null, m,mode));\n} else {\nthrow cljs.core.missing_protocol(\x22Mix.solo-mode*\x22,m);\n}\n}\n});\ncljs.core.async.solo_mode_STAR_ \x3d (function cljs$core$async$solo_mode_STAR_(m,mode){\nif((((!((m \x3d\x3d null)))) \x26\x26 ((!((m.cljs$core$async$Mix$solo_mode_STAR_$arity$2 \x3d\x3d null)))))){\nreturn m.cljs$core$async$Mix$solo_mode_STAR_$arity$2(m,mode);\n} else {\nreturn cljs$core$async$Mix$solo_mode_STAR_$dyn_27439(m,mode);\n}\n});\n\ncljs.core.async.ioc_alts_BANG_ \x3d (function cljs$core$async$ioc_alts_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27440 \x3d arguments.length;\nvar i__5727__auto___27441 \x3d (0);\nwhile(true){\nif((i__5727__auto___27441 \x3c len__5726__auto___27440)){\nargs__5732__auto__.push((arguments[i__5727__auto___27441]));\n\nvar G__27442 \x3d (i__5727__auto___27441 + (1));\ni__5727__auto___27441 \x3d G__27442;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((3) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((3)),(0),null)):null);\nreturn cljs.core.async.ioc_alts_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5733__auto__);\n});\n\n(cljs.core.async.ioc_alts_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (state,cont_block,ports,p__24737){\nvar map__24738 \x3d p__24737;\nvar map__24738__$1 \x3d cljs.core.__destructure_map(map__24738);\nvar opts \x3d map__24738__$1;\nvar statearr_24739_27444 \x3d state;\n(statearr_24739_27444[(1)] \x3d cont_block);\n\n\nvar temp__5804__auto__ \x3d cljs.core.async.do_alts((function (val){\nvar statearr_24741_27445 \x3d state;\n(statearr_24741_27445[(2)] \x3d val);\n\n\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state);\n}),ports,opts);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar cb \x3d temp__5804__auto__;\nvar statearr_24742_27449 \x3d state;\n(statearr_24742_27449[(2)] \x3d cljs.core.deref(cb));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.async.ioc_alts_BANG_.cljs$lang$maxFixedArity \x3d (3));\n\n/** @this {Function} */\n(cljs.core.async.ioc_alts_BANG_.cljs$lang$applyTo \x3d (function (seq24730){\nvar G__24731 \x3d cljs.core.first(seq24730);\nvar seq24730__$1 \x3d cljs.core.next(seq24730);\nvar G__24732 \x3d cljs.core.first(seq24730__$1);\nvar seq24730__$2 \x3d cljs.core.next(seq24730__$1);\nvar G__24733 \x3d cljs.core.first(seq24730__$2);\nvar seq24730__$3 \x3d cljs.core.next(seq24730__$2);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__24731,G__24732,G__24733,seq24730__$3);\n}));\n\n\n/**\n* @constructor\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.async.Mix}\n * @implements {cljs.core.async.Mux}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async24757 \x3d (function (change,solo_mode,pick,cs,calc_state,out,changed,solo_modes,attrs,meta24758){\nthis.change \x3d change;\nthis.solo_mode \x3d solo_mode;\nthis.pick \x3d pick;\nthis.cs \x3d cs;\nthis.calc_state \x3d calc_state;\nthis.out \x3d out;\nthis.changed \x3d changed;\nthis.solo_modes \x3d solo_modes;\nthis.attrs \x3d attrs;\nthis.meta24758 \x3d meta24758;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24759,meta24758__$1){\nvar self__ \x3d this;\nvar _24759__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async24757(self__.change,self__.solo_mode,self__.pick,self__.cs,self__.calc_state,self__.out,self__.changed,self__.solo_modes,self__.attrs,meta24758__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24759){\nvar self__ \x3d this;\nvar _24759__$1 \x3d this;\nreturn self__.meta24758;\n}));\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mux$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mux$muxch_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.out;\n}));\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mix$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mix$admix_STAR_$arity$2 \x3d (function (_,ch){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.cs,cljs.core.assoc,ch,cljs.core.PersistentArrayMap.EMPTY);\n\nreturn (self__.changed.cljs$core$IFn$_invoke$arity$0 ? self__.changed.cljs$core$IFn$_invoke$arity$0() : self__.changed.call(null, ));\n}));\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mix$unmix_STAR_$arity$2 \x3d (function (_,ch){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(self__.cs,cljs.core.dissoc,ch);\n\nreturn (self__.changed.cljs$core$IFn$_invoke$arity$0 ? self__.changed.cljs$core$IFn$_invoke$arity$0() : self__.changed.call(null, ));\n}));\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mix$unmix_all_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.reset_BANG_(self__.cs,cljs.core.PersistentArrayMap.EMPTY);\n\nreturn (self__.changed.cljs$core$IFn$_invoke$arity$0 ? self__.changed.cljs$core$IFn$_invoke$arity$0() : self__.changed.call(null, ));\n}));\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mix$toggle_STAR_$arity$2 \x3d (function (_,state_map){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(self__.cs,cljs.core.partial.cljs$core$IFn$_invoke$arity$2(cljs.core.merge_with,cljs.core.merge),state_map);\n\nreturn (self__.changed.cljs$core$IFn$_invoke$arity$0 ? self__.changed.cljs$core$IFn$_invoke$arity$0() : self__.changed.call(null, ));\n}));\n\n(cljs.core.async.t_cljs$core$async24757.prototype.cljs$core$async$Mix$solo_mode_STAR_$arity$2 \x3d (function (_,mode){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_((self__.solo_modes.cljs$core$IFn$_invoke$arity$1 ? self__.solo_modes.cljs$core$IFn$_invoke$arity$1(mode) : self__.solo_modes.call(null, mode)))){\n} else {\nthrow (new Error([\x22Assert failed: \x22,[\x22mode must be one of: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.solo_modes)].join(\x27\x27),\x22\\n\x22,\x22(solo-modes mode)\x22].join(\x27\x27)));\n}\n\ncljs.core.reset_BANG_(self__.solo_mode,mode);\n\nreturn (self__.changed.cljs$core$IFn$_invoke$arity$0 ? self__.changed.cljs$core$IFn$_invoke$arity$0() : self__.changed.call(null, ));\n}));\n\n(cljs.core.async.t_cljs$core$async24757.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 10, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22change\x22,\x22change\x22,477485025,null),new cljs.core.Symbol(null,\x22solo-mode\x22,\x22solo-mode\x22,2031788074,null),new cljs.core.Symbol(null,\x22pick\x22,\x22pick\x22,1300068175,null),new cljs.core.Symbol(null,\x22cs\x22,\x22cs\x22,-117024463,null),new cljs.core.Symbol(null,\x22calc-state\x22,\x22calc-state\x22,-349968968,null),new cljs.core.Symbol(null,\x22out\x22,\x22out\x22,729986010,null),new cljs.core.Symbol(null,\x22changed\x22,\x22changed\x22,-2083710852,null),new cljs.core.Symbol(null,\x22solo-modes\x22,\x22solo-modes\x22,882180540,null),new cljs.core.Symbol(null,\x22attrs\x22,\x22attrs\x22,-450137186,null),new cljs.core.Symbol(null,\x22meta24758\x22,\x22meta24758\x22,-518829566,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async24757.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async24757.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async24757\x22);\n\n(cljs.core.async.t_cljs$core$async24757.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async24757\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async24757.\n */\ncljs.core.async.__GT_t_cljs$core$async24757 \x3d (function cljs$core$async$__GT_t_cljs$core$async24757(change,solo_mode,pick,cs,calc_state,out,changed,solo_modes,attrs,meta24758){\nreturn (new cljs.core.async.t_cljs$core$async24757(change,solo_mode,pick,cs,calc_state,out,changed,solo_modes,attrs,meta24758));\n});\n\n\n/**\n * Creates and returns a mix of one or more input channels which will\n *   be put on the supplied out channel. Input sources can be added to\n *   the mix with \x27admix\x27, and removed with \x27unmix\x27. A mix supports\n *   soloing, muting and pausing multiple inputs atomically using\n *   \x27toggle\x27, and can solo using either muting or pausing as determined\n *   by \x27solo-mode\x27.\n * \n *   Each channel can have zero or more boolean modes set via \x27toggle\x27:\n * \n *   :solo - when true, only this (ond other soloed) channel(s) will appear\n *        in the mix output channel. :mute and :pause states of soloed\n *        channels are ignored. If solo-mode is :mute, non-soloed\n *        channels are muted, if :pause, non-soloed channels are\n *        paused.\n * \n *   :mute - muted channels will have their contents consumed but not included in the mix\n *   :pause - paused channels will not have their contents consumed (and thus also not included in the mix)\n */\ncljs.core.async.mix \x3d (function cljs$core$async$mix(out){\nvar cs \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar solo_modes \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22pause\x22,\x22pause\x22,-2095325672),null,new cljs.core.Keyword(null,\x22mute\x22,\x22mute\x22,1151223646),null], null), null);\nvar attrs \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(solo_modes,new cljs.core.Keyword(null,\x22solo\x22,\x22solo\x22,-316350075));\nvar solo_mode \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22mute\x22,\x22mute\x22,1151223646));\nvar change \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(cljs.core.async.sliding_buffer((1)));\nvar changed \x3d (function (){\nreturn cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(change,true);\n});\nvar pick \x3d (function (attr,chs){\nreturn cljs.core.reduce_kv((function (ret,c,v){\nif(cljs.core.truth_((attr.cljs$core$IFn$_invoke$arity$1 ? attr.cljs$core$IFn$_invoke$arity$1(v) : attr.call(null, v)))){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ret,c);\n} else {\nreturn ret;\n}\n}),cljs.core.PersistentHashSet.EMPTY,chs);\n});\nvar calc_state \x3d (function (){\nvar chs \x3d cljs.core.deref(cs);\nvar mode \x3d cljs.core.deref(solo_mode);\nvar solos \x3d pick(new cljs.core.Keyword(null,\x22solo\x22,\x22solo\x22,-316350075),chs);\nvar pauses \x3d pick(new cljs.core.Keyword(null,\x22pause\x22,\x22pause\x22,-2095325672),chs);\nreturn new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22solos\x22,\x22solos\x22,1441458643),solos,new cljs.core.Keyword(null,\x22mutes\x22,\x22mutes\x22,1068806309),pick(new cljs.core.Keyword(null,\x22mute\x22,\x22mute\x22,1151223646),chs),new cljs.core.Keyword(null,\x22reads\x22,\x22reads\x22,-1215067361),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(((((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(mode,new cljs.core.Keyword(null,\x22pause\x22,\x22pause\x22,-2095325672))) \x26\x26 ((!(cljs.core.empty_QMARK_(solos))))))?cljs.core.vec(solos):cljs.core.vec(cljs.core.remove.cljs$core$IFn$_invoke$arity$2(pauses,cljs.core.keys(chs)))),change)], null);\n});\nvar m \x3d (new cljs.core.async.t_cljs$core$async24757(change,solo_mode,pick,cs,calc_state,out,changed,solo_modes,attrs,cljs.core.PersistentArrayMap.EMPTY));\nvar c__22634__auto___27465 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_24890){\nvar state_val_24891 \x3d (state_24890[(1)]);\nif((state_val_24891 \x3d\x3d\x3d (7))){\nvar inst_24844 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nif(cljs.core.truth_(inst_24844)){\nvar statearr_24892_27466 \x3d state_24890__$1;\n(statearr_24892_27466[(1)] \x3d (8));\n\n} else {\nvar statearr_24893_27467 \x3d state_24890__$1;\n(statearr_24893_27467[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (20))){\nvar inst_24834 \x3d (state_24890[(7)]);\nvar state_24890__$1 \x3d state_24890;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_24890__$1,(23),out,inst_24834);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (1))){\nvar inst_24805 \x3d calc_state();\nvar inst_24807 \x3d cljs.core.__destructure_map(inst_24805);\nvar inst_24808 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(inst_24807,new cljs.core.Keyword(null,\x22solos\x22,\x22solos\x22,1441458643));\nvar inst_24810 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(inst_24807,new cljs.core.Keyword(null,\x22mutes\x22,\x22mutes\x22,1068806309));\nvar inst_24811 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(inst_24807,new cljs.core.Keyword(null,\x22reads\x22,\x22reads\x22,-1215067361));\nvar inst_24812 \x3d inst_24805;\nvar state_24890__$1 \x3d (function (){var statearr_24894 \x3d state_24890;\n(statearr_24894[(8)] \x3d inst_24812);\n\n(statearr_24894[(9)] \x3d inst_24810);\n\n(statearr_24894[(10)] \x3d inst_24808);\n\n(statearr_24894[(11)] \x3d inst_24811);\n\nreturn statearr_24894;\n})();\nvar statearr_24895_27474 \x3d state_24890__$1;\n(statearr_24895_27474[(2)] \x3d null);\n\n(statearr_24895_27474[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (24))){\nvar inst_24822 \x3d (state_24890[(12)]);\nvar inst_24812 \x3d inst_24822;\nvar state_24890__$1 \x3d (function (){var statearr_24897 \x3d state_24890;\n(statearr_24897[(8)] \x3d inst_24812);\n\nreturn statearr_24897;\n})();\nvar statearr_24898_27478 \x3d state_24890__$1;\n(statearr_24898_27478[(2)] \x3d null);\n\n(statearr_24898_27478[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (4))){\nvar inst_24839 \x3d (state_24890[(13)]);\nvar inst_24834 \x3d (state_24890[(7)]);\nvar inst_24833 \x3d (state_24890[(2)]);\nvar inst_24834__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_24833,(0),null);\nvar inst_24835 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_24833,(1),null);\nvar inst_24839__$1 \x3d (inst_24834__$1 \x3d\x3d null);\nvar state_24890__$1 \x3d (function (){var statearr_24902 \x3d state_24890;\n(statearr_24902[(13)] \x3d inst_24839__$1);\n\n(statearr_24902[(14)] \x3d inst_24835);\n\n(statearr_24902[(7)] \x3d inst_24834__$1);\n\nreturn statearr_24902;\n})();\nif(cljs.core.truth_(inst_24839__$1)){\nvar statearr_24903_27479 \x3d state_24890__$1;\n(statearr_24903_27479[(1)] \x3d (5));\n\n} else {\nvar statearr_24904_27480 \x3d state_24890__$1;\n(statearr_24904_27480[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (15))){\nvar inst_24858 \x3d (state_24890[(15)]);\nvar inst_24823 \x3d (state_24890[(16)]);\nvar inst_24858__$1 \x3d cljs.core.empty_QMARK_(inst_24823);\nvar state_24890__$1 \x3d (function (){var statearr_24910 \x3d state_24890;\n(statearr_24910[(15)] \x3d inst_24858__$1);\n\nreturn statearr_24910;\n})();\nif(inst_24858__$1){\nvar statearr_24912_27481 \x3d state_24890__$1;\n(statearr_24912_27481[(1)] \x3d (17));\n\n} else {\nvar statearr_24913_27482 \x3d state_24890__$1;\n(statearr_24913_27482[(1)] \x3d (18));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (21))){\nvar inst_24822 \x3d (state_24890[(12)]);\nvar inst_24812 \x3d inst_24822;\nvar state_24890__$1 \x3d (function (){var statearr_24914 \x3d state_24890;\n(statearr_24914[(8)] \x3d inst_24812);\n\nreturn statearr_24914;\n})();\nvar statearr_24915_27483 \x3d state_24890__$1;\n(statearr_24915_27483[(2)] \x3d null);\n\n(statearr_24915_27483[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (13))){\nvar inst_24851 \x3d (state_24890[(2)]);\nvar inst_24852 \x3d calc_state();\nvar inst_24812 \x3d inst_24852;\nvar state_24890__$1 \x3d (function (){var statearr_24916 \x3d state_24890;\n(statearr_24916[(8)] \x3d inst_24812);\n\n(statearr_24916[(17)] \x3d inst_24851);\n\nreturn statearr_24916;\n})();\nvar statearr_24917_27484 \x3d state_24890__$1;\n(statearr_24917_27484[(2)] \x3d null);\n\n(statearr_24917_27484[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (22))){\nvar inst_24878 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24919_27485 \x3d state_24890__$1;\n(statearr_24919_27485[(2)] \x3d inst_24878);\n\n(statearr_24919_27485[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (6))){\nvar inst_24835 \x3d (state_24890[(14)]);\nvar inst_24842 \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(inst_24835,change);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24920_27486 \x3d state_24890__$1;\n(statearr_24920_27486[(2)] \x3d inst_24842);\n\n(statearr_24920_27486[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (25))){\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24921_27489 \x3d state_24890__$1;\n(statearr_24921_27489[(2)] \x3d null);\n\n(statearr_24921_27489[(1)] \x3d (26));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (17))){\nvar inst_24835 \x3d (state_24890[(14)]);\nvar inst_24824 \x3d (state_24890[(18)]);\nvar inst_24860 \x3d (inst_24824.cljs$core$IFn$_invoke$arity$1 ? inst_24824.cljs$core$IFn$_invoke$arity$1(inst_24835) : inst_24824.call(null, inst_24835));\nvar inst_24861 \x3d cljs.core.not(inst_24860);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24923_27491 \x3d state_24890__$1;\n(statearr_24923_27491[(2)] \x3d inst_24861);\n\n(statearr_24923_27491[(1)] \x3d (19));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (3))){\nvar inst_24882 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_24890__$1,inst_24882);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (12))){\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24926_27492 \x3d state_24890__$1;\n(statearr_24926_27492[(2)] \x3d null);\n\n(statearr_24926_27492[(1)] \x3d (13));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (2))){\nvar inst_24812 \x3d (state_24890[(8)]);\nvar inst_24822 \x3d (state_24890[(12)]);\nvar inst_24822__$1 \x3d cljs.core.__destructure_map(inst_24812);\nvar inst_24823 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(inst_24822__$1,new cljs.core.Keyword(null,\x22solos\x22,\x22solos\x22,1441458643));\nvar inst_24824 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(inst_24822__$1,new cljs.core.Keyword(null,\x22mutes\x22,\x22mutes\x22,1068806309));\nvar inst_24825 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(inst_24822__$1,new cljs.core.Keyword(null,\x22reads\x22,\x22reads\x22,-1215067361));\nvar state_24890__$1 \x3d (function (){var statearr_24927 \x3d state_24890;\n(statearr_24927[(12)] \x3d inst_24822__$1);\n\n(statearr_24927[(18)] \x3d inst_24824);\n\n(statearr_24927[(16)] \x3d inst_24823);\n\nreturn statearr_24927;\n})();\nreturn cljs.core.async.ioc_alts_BANG_(state_24890__$1,(4),inst_24825);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (23))){\nvar inst_24869 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nif(cljs.core.truth_(inst_24869)){\nvar statearr_24928_27496 \x3d state_24890__$1;\n(statearr_24928_27496[(1)] \x3d (24));\n\n} else {\nvar statearr_24929_27497 \x3d state_24890__$1;\n(statearr_24929_27497[(1)] \x3d (25));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (19))){\nvar inst_24864 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24930_27498 \x3d state_24890__$1;\n(statearr_24930_27498[(2)] \x3d inst_24864);\n\n(statearr_24930_27498[(1)] \x3d (16));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (11))){\nvar inst_24835 \x3d (state_24890[(14)]);\nvar inst_24848 \x3d cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(cs,cljs.core.dissoc,inst_24835);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24931_27499 \x3d state_24890__$1;\n(statearr_24931_27499[(2)] \x3d inst_24848);\n\n(statearr_24931_27499[(1)] \x3d (13));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (9))){\nvar inst_24835 \x3d (state_24890[(14)]);\nvar inst_24855 \x3d (state_24890[(19)]);\nvar inst_24823 \x3d (state_24890[(16)]);\nvar inst_24855__$1 \x3d (inst_24823.cljs$core$IFn$_invoke$arity$1 ? inst_24823.cljs$core$IFn$_invoke$arity$1(inst_24835) : inst_24823.call(null, inst_24835));\nvar state_24890__$1 \x3d (function (){var statearr_24932 \x3d state_24890;\n(statearr_24932[(19)] \x3d inst_24855__$1);\n\nreturn statearr_24932;\n})();\nif(cljs.core.truth_(inst_24855__$1)){\nvar statearr_24933_27500 \x3d state_24890__$1;\n(statearr_24933_27500[(1)] \x3d (14));\n\n} else {\nvar statearr_24935_27501 \x3d state_24890__$1;\n(statearr_24935_27501[(1)] \x3d (15));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (5))){\nvar inst_24839 \x3d (state_24890[(13)]);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24936_27502 \x3d state_24890__$1;\n(statearr_24936_27502[(2)] \x3d inst_24839);\n\n(statearr_24936_27502[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (14))){\nvar inst_24855 \x3d (state_24890[(19)]);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24938_27503 \x3d state_24890__$1;\n(statearr_24938_27503[(2)] \x3d inst_24855);\n\n(statearr_24938_27503[(1)] \x3d (16));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (26))){\nvar inst_24874 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24942_27505 \x3d state_24890__$1;\n(statearr_24942_27505[(2)] \x3d inst_24874);\n\n(statearr_24942_27505[(1)] \x3d (22));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (16))){\nvar inst_24866 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nif(cljs.core.truth_(inst_24866)){\nvar statearr_24943_27506 \x3d state_24890__$1;\n(statearr_24943_27506[(1)] \x3d (20));\n\n} else {\nvar statearr_24944_27507 \x3d state_24890__$1;\n(statearr_24944_27507[(1)] \x3d (21));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (10))){\nvar inst_24880 \x3d (state_24890[(2)]);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24947_27508 \x3d state_24890__$1;\n(statearr_24947_27508[(2)] \x3d inst_24880);\n\n(statearr_24947_27508[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (18))){\nvar inst_24858 \x3d (state_24890[(15)]);\nvar state_24890__$1 \x3d state_24890;\nvar statearr_24954_27509 \x3d state_24890__$1;\n(statearr_24954_27509[(2)] \x3d inst_24858);\n\n(statearr_24954_27509[(1)] \x3d (19));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_24891 \x3d\x3d\x3d (8))){\nvar inst_24834 \x3d (state_24890[(7)]);\nvar inst_24846 \x3d (inst_24834 \x3d\x3d null);\nvar state_24890__$1 \x3d state_24890;\nif(cljs.core.truth_(inst_24846)){\nvar statearr_24955_27510 \x3d state_24890__$1;\n(statearr_24955_27510[(1)] \x3d (11));\n\n} else {\nvar statearr_24956_27511 \x3d state_24890__$1;\n(statearr_24956_27511[(1)] \x3d (12));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$mix_$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$mix_$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_24960 \x3d [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_24960[(0)] \x3d cljs$core$async$mix_$_state_machine__21555__auto__);\n\n(statearr_24960[(1)] \x3d (1));\n\nreturn statearr_24960;\n});\nvar cljs$core$async$mix_$_state_machine__21555__auto____1 \x3d (function (state_24890){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_24890);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e24962){var ex__21558__auto__ \x3d e24962;\nvar statearr_24963_27513 \x3d state_24890;\n(statearr_24963_27513[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_24890[(4)]))){\nvar statearr_24965_27514 \x3d state_24890;\n(statearr_24965_27514[(1)] \x3d cljs.core.first((state_24890[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27515 \x3d state_24890;\nstate_24890 \x3d G__27515;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$mix_$_state_machine__21555__auto__ \x3d function(state_24890){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$mix_$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$mix_$_state_machine__21555__auto____1.call(this,state_24890);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$mix_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$mix_$_state_machine__21555__auto____0;\ncljs$core$async$mix_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$mix_$_state_machine__21555__auto____1;\nreturn cljs$core$async$mix_$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_24966 \x3d f__22635__auto__();\n(statearr_24966[(6)] \x3d c__22634__auto___27465);\n\nreturn statearr_24966;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn m;\n});\n/**\n * Adds ch as an input to the mix\n */\ncljs.core.async.admix \x3d (function cljs$core$async$admix(mix,ch){\nreturn cljs.core.async.admix_STAR_(mix,ch);\n});\n/**\n * Removes ch as an input to the mix\n */\ncljs.core.async.unmix \x3d (function cljs$core$async$unmix(mix,ch){\nreturn cljs.core.async.unmix_STAR_(mix,ch);\n});\n/**\n * removes all inputs from the mix\n */\ncljs.core.async.unmix_all \x3d (function cljs$core$async$unmix_all(mix){\nreturn cljs.core.async.unmix_all_STAR_(mix);\n});\n/**\n * Atomically sets the state(s) of one or more channels in a mix. The\n *   state map is a map of channels -\x3e channel-state-map. A\n *   channel-state-map is a map of attrs -\x3e boolean, where attr is one or\n *   more of :mute, :pause or :solo. Any states supplied are merged with\n *   the current state.\n * \n *   Note that channels can be added to a mix via toggle, which can be\n *   used to add channels in a particular (e.g. paused) state.\n */\ncljs.core.async.toggle \x3d (function cljs$core$async$toggle(mix,state_map){\nreturn cljs.core.async.toggle_STAR_(mix,state_map);\n});\n/**\n * Sets the solo mode of the mix. mode must be one of :mute or :pause\n */\ncljs.core.async.solo_mode \x3d (function cljs$core$async$solo_mode(mix,mode){\nreturn cljs.core.async.solo_mode_STAR_(mix,mode);\n});\n\n/**\n * @interface\n */\ncljs.core.async.Pub \x3d function(){};\n\nvar cljs$core$async$Pub$sub_STAR_$dyn_27525 \x3d (function (p,v,ch,close_QMARK_){\nvar x__5350__auto__ \x3d (((p \x3d\x3d null))?null:p);\nvar m__5351__auto__ \x3d (cljs.core.async.sub_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$4(p,v,ch,close_QMARK_) : m__5351__auto__.call(null, p,v,ch,close_QMARK_));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.sub_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$4(p,v,ch,close_QMARK_) : m__5349__auto__.call(null, p,v,ch,close_QMARK_));\n} else {\nthrow cljs.core.missing_protocol(\x22Pub.sub*\x22,p);\n}\n}\n});\ncljs.core.async.sub_STAR_ \x3d (function cljs$core$async$sub_STAR_(p,v,ch,close_QMARK_){\nif((((!((p \x3d\x3d null)))) \x26\x26 ((!((p.cljs$core$async$Pub$sub_STAR_$arity$4 \x3d\x3d null)))))){\nreturn p.cljs$core$async$Pub$sub_STAR_$arity$4(p,v,ch,close_QMARK_);\n} else {\nreturn cljs$core$async$Pub$sub_STAR_$dyn_27525(p,v,ch,close_QMARK_);\n}\n});\n\nvar cljs$core$async$Pub$unsub_STAR_$dyn_27528 \x3d (function (p,v,ch){\nvar x__5350__auto__ \x3d (((p \x3d\x3d null))?null:p);\nvar m__5351__auto__ \x3d (cljs.core.async.unsub_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(p,v,ch) : m__5351__auto__.call(null, p,v,ch));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.unsub_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(p,v,ch) : m__5349__auto__.call(null, p,v,ch));\n} else {\nthrow cljs.core.missing_protocol(\x22Pub.unsub*\x22,p);\n}\n}\n});\ncljs.core.async.unsub_STAR_ \x3d (function cljs$core$async$unsub_STAR_(p,v,ch){\nif((((!((p \x3d\x3d null)))) \x26\x26 ((!((p.cljs$core$async$Pub$unsub_STAR_$arity$3 \x3d\x3d null)))))){\nreturn p.cljs$core$async$Pub$unsub_STAR_$arity$3(p,v,ch);\n} else {\nreturn cljs$core$async$Pub$unsub_STAR_$dyn_27528(p,v,ch);\n}\n});\n\nvar cljs$core$async$Pub$unsub_all_STAR_$dyn_27530 \x3d (function() {\nvar G__27531 \x3d null;\nvar G__27531__1 \x3d (function (p){\nvar x__5350__auto__ \x3d (((p \x3d\x3d null))?null:p);\nvar m__5351__auto__ \x3d (cljs.core.async.unsub_all_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(p) : m__5351__auto__.call(null, p));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.unsub_all_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(p) : m__5349__auto__.call(null, p));\n} else {\nthrow cljs.core.missing_protocol(\x22Pub.unsub-all*\x22,p);\n}\n}\n});\nvar G__27531__2 \x3d (function (p,v){\nvar x__5350__auto__ \x3d (((p \x3d\x3d null))?null:p);\nvar m__5351__auto__ \x3d (cljs.core.async.unsub_all_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(p,v) : m__5351__auto__.call(null, p,v));\n} else {\nvar m__5349__auto__ \x3d (cljs.core.async.unsub_all_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(p,v) : m__5349__auto__.call(null, p,v));\n} else {\nthrow cljs.core.missing_protocol(\x22Pub.unsub-all*\x22,p);\n}\n}\n});\nG__27531 \x3d function(p,v){\nswitch(arguments.length){\ncase 1:\nreturn G__27531__1.call(this,p);\ncase 2:\nreturn G__27531__2.call(this,p,v);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__27531.cljs$core$IFn$_invoke$arity$1 \x3d G__27531__1;\nG__27531.cljs$core$IFn$_invoke$arity$2 \x3d G__27531__2;\nreturn G__27531;\n})()\n;\ncljs.core.async.unsub_all_STAR_ \x3d (function cljs$core$async$unsub_all_STAR_(var_args){\nvar G__24982 \x3d arguments.length;\nswitch (G__24982) {\ncase 1:\nreturn cljs.core.async.unsub_all_STAR_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.unsub_all_STAR_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.unsub_all_STAR_.cljs$core$IFn$_invoke$arity$1 \x3d (function (p){\nif((((!((p \x3d\x3d null)))) \x26\x26 ((!((p.cljs$core$async$Pub$unsub_all_STAR_$arity$1 \x3d\x3d null)))))){\nreturn p.cljs$core$async$Pub$unsub_all_STAR_$arity$1(p);\n} else {\nreturn cljs$core$async$Pub$unsub_all_STAR_$dyn_27530(p);\n}\n}));\n\n(cljs.core.async.unsub_all_STAR_.cljs$core$IFn$_invoke$arity$2 \x3d (function (p,v){\nif((((!((p \x3d\x3d null)))) \x26\x26 ((!((p.cljs$core$async$Pub$unsub_all_STAR_$arity$2 \x3d\x3d null)))))){\nreturn p.cljs$core$async$Pub$unsub_all_STAR_$arity$2(p,v);\n} else {\nreturn cljs$core$async$Pub$unsub_all_STAR_$dyn_27530(p,v);\n}\n}));\n\n(cljs.core.async.unsub_all_STAR_.cljs$lang$maxFixedArity \x3d 2);\n\n\n\n/**\n* @constructor\n * @implements {cljs.core.async.Pub}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.async.Mux}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async24994 \x3d (function (ch,topic_fn,buf_fn,mults,ensure_mult,meta24995){\nthis.ch \x3d ch;\nthis.topic_fn \x3d topic_fn;\nthis.buf_fn \x3d buf_fn;\nthis.mults \x3d mults;\nthis.ensure_mult \x3d ensure_mult;\nthis.meta24995 \x3d meta24995;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24996,meta24995__$1){\nvar self__ \x3d this;\nvar _24996__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async24994(self__.ch,self__.topic_fn,self__.buf_fn,self__.mults,self__.ensure_mult,meta24995__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24996){\nvar self__ \x3d this;\nvar _24996__$1 \x3d this;\nreturn self__.meta24995;\n}));\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$async$Mux$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$async$Mux$muxch_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.ch;\n}));\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$async$Pub$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$async$Pub$sub_STAR_$arity$4 \x3d (function (p,topic,ch__$1,close_QMARK_){\nvar self__ \x3d this;\nvar p__$1 \x3d this;\nvar m \x3d (self__.ensure_mult.cljs$core$IFn$_invoke$arity$1 ? self__.ensure_mult.cljs$core$IFn$_invoke$arity$1(topic) : self__.ensure_mult.call(null, topic));\nreturn cljs.core.async.tap.cljs$core$IFn$_invoke$arity$3(m,ch__$1,close_QMARK_);\n}));\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$async$Pub$unsub_STAR_$arity$3 \x3d (function (p,topic,ch__$1){\nvar self__ \x3d this;\nvar p__$1 \x3d this;\nvar temp__5804__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(self__.mults),topic);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar m \x3d temp__5804__auto__;\nreturn cljs.core.async.untap(m,ch__$1);\n} else {\nreturn null;\n}\n}));\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$async$Pub$unsub_all_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.reset_BANG_(self__.mults,cljs.core.PersistentArrayMap.EMPTY);\n}));\n\n(cljs.core.async.t_cljs$core$async24994.prototype.cljs$core$async$Pub$unsub_all_STAR_$arity$2 \x3d (function (_,topic){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(self__.mults,cljs.core.dissoc,topic);\n}));\n\n(cljs.core.async.t_cljs$core$async24994.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22ch\x22,\x22ch\x22,1085813622,null),new cljs.core.Symbol(null,\x22topic-fn\x22,\x22topic-fn\x22,-862449736,null),new cljs.core.Symbol(null,\x22buf-fn\x22,\x22buf-fn\x22,-1200281591,null),new cljs.core.Symbol(null,\x22mults\x22,\x22mults\x22,-461114485,null),new cljs.core.Symbol(null,\x22ensure-mult\x22,\x22ensure-mult\x22,1796584816,null),new cljs.core.Symbol(null,\x22meta24995\x22,\x22meta24995\x22,-1489634401,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async24994.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async24994.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async24994\x22);\n\n(cljs.core.async.t_cljs$core$async24994.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async24994\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async24994.\n */\ncljs.core.async.__GT_t_cljs$core$async24994 \x3d (function cljs$core$async$__GT_t_cljs$core$async24994(ch,topic_fn,buf_fn,mults,ensure_mult,meta24995){\nreturn (new cljs.core.async.t_cljs$core$async24994(ch,topic_fn,buf_fn,mults,ensure_mult,meta24995));\n});\n\n\n/**\n * Creates and returns a pub(lication) of the supplied channel,\n *   partitioned into topics by the topic-fn. topic-fn will be applied to\n *   each value on the channel and the result will determine the \x27topic\x27\n *   on which that value will be put. Channels can be subscribed to\n *   receive copies of topics using \x27sub\x27, and unsubscribed using\n *   \x27unsub\x27. Each topic will be handled by an internal mult on a\n *   dedicated channel. By default these internal channels are\n *   unbuffered, but a buf-fn can be supplied which, given a topic,\n *   creates a buffer with desired properties.\n * \n *   Each item is distributed to all subs in parallel and synchronously,\n *   i.e. each sub must accept before the next item is distributed. Use\n *   buffering/windowing to prevent slow subs from holding up the pub.\n * \n *   Items received when there are no matching subs get dropped.\n * \n *   Note that if buf-fns are used then each topic is handled\n *   asynchronously, i.e. if a channel is subscribed to more than one\n *   topic it should not expect them to be interleaved identically with\n *   the source.\n */\ncljs.core.async.pub \x3d (function cljs$core$async$pub(var_args){\nvar G__24993 \x3d arguments.length;\nswitch (G__24993) {\ncase 2:\nreturn cljs.core.async.pub.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.pub.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.pub.cljs$core$IFn$_invoke$arity$2 \x3d (function (ch,topic_fn){\nreturn cljs.core.async.pub.cljs$core$IFn$_invoke$arity$3(ch,topic_fn,cljs.core.constantly(null));\n}));\n\n(cljs.core.async.pub.cljs$core$IFn$_invoke$arity$3 \x3d (function (ch,topic_fn,buf_fn){\nvar mults \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar ensure_mult \x3d (function (topic){\nvar or__5002__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(mults),topic);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(mults,(function (p1__24990_SHARP_){\nif(cljs.core.truth_((p1__24990_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__24990_SHARP_.cljs$core$IFn$_invoke$arity$1(topic) : p1__24990_SHARP_.call(null, topic)))){\nreturn p1__24990_SHARP_;\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(p1__24990_SHARP_,topic,cljs.core.async.mult(cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((buf_fn.cljs$core$IFn$_invoke$arity$1 ? buf_fn.cljs$core$IFn$_invoke$arity$1(topic) : buf_fn.call(null, topic)))));\n}\n})),topic);\n}\n});\nvar p \x3d (new cljs.core.async.t_cljs$core$async24994(ch,topic_fn,buf_fn,mults,ensure_mult,cljs.core.PersistentArrayMap.EMPTY));\nvar c__22634__auto___27555 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_25123){\nvar state_val_25124 \x3d (state_25123[(1)]);\nif((state_val_25124 \x3d\x3d\x3d (7))){\nvar inst_25109 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25135_27556 \x3d state_25123__$1;\n(statearr_25135_27556[(2)] \x3d inst_25109);\n\n(statearr_25135_27556[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (20))){\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25136_27557 \x3d state_25123__$1;\n(statearr_25136_27557[(2)] \x3d null);\n\n(statearr_25136_27557[(1)] \x3d (21));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (1))){\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25145_27558 \x3d state_25123__$1;\n(statearr_25145_27558[(2)] \x3d null);\n\n(statearr_25145_27558[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (24))){\nvar inst_25092 \x3d (state_25123[(7)]);\nvar inst_25101 \x3d cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(mults,cljs.core.dissoc,inst_25092);\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25150_27559 \x3d state_25123__$1;\n(statearr_25150_27559[(2)] \x3d inst_25101);\n\n(statearr_25150_27559[(1)] \x3d (25));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (4))){\nvar inst_25015 \x3d (state_25123[(8)]);\nvar inst_25015__$1 \x3d (state_25123[(2)]);\nvar inst_25016 \x3d (inst_25015__$1 \x3d\x3d null);\nvar state_25123__$1 \x3d (function (){var statearr_25151 \x3d state_25123;\n(statearr_25151[(8)] \x3d inst_25015__$1);\n\nreturn statearr_25151;\n})();\nif(cljs.core.truth_(inst_25016)){\nvar statearr_25159_27560 \x3d state_25123__$1;\n(statearr_25159_27560[(1)] \x3d (5));\n\n} else {\nvar statearr_25160_27561 \x3d state_25123__$1;\n(statearr_25160_27561[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (15))){\nvar inst_25083 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25169_27564 \x3d state_25123__$1;\n(statearr_25169_27564[(2)] \x3d inst_25083);\n\n(statearr_25169_27564[(1)] \x3d (12));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (21))){\nvar inst_25106 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d (function (){var statearr_25170 \x3d state_25123;\n(statearr_25170[(9)] \x3d inst_25106);\n\nreturn statearr_25170;\n})();\nvar statearr_25171_27566 \x3d state_25123__$1;\n(statearr_25171_27566[(2)] \x3d null);\n\n(statearr_25171_27566[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (13))){\nvar inst_25040 \x3d (state_25123[(10)]);\nvar inst_25048 \x3d cljs.core.chunked_seq_QMARK_(inst_25040);\nvar state_25123__$1 \x3d state_25123;\nif(inst_25048){\nvar statearr_25174_27567 \x3d state_25123__$1;\n(statearr_25174_27567[(1)] \x3d (16));\n\n} else {\nvar statearr_25175_27568 \x3d state_25123__$1;\n(statearr_25175_27568[(1)] \x3d (17));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (22))){\nvar inst_25098 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nif(cljs.core.truth_(inst_25098)){\nvar statearr_25182_27569 \x3d state_25123__$1;\n(statearr_25182_27569[(1)] \x3d (23));\n\n} else {\nvar statearr_25183_27570 \x3d state_25123__$1;\n(statearr_25183_27570[(1)] \x3d (24));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (6))){\nvar inst_25092 \x3d (state_25123[(7)]);\nvar inst_25094 \x3d (state_25123[(11)]);\nvar inst_25015 \x3d (state_25123[(8)]);\nvar inst_25092__$1 \x3d (topic_fn.cljs$core$IFn$_invoke$arity$1 ? topic_fn.cljs$core$IFn$_invoke$arity$1(inst_25015) : topic_fn.call(null, inst_25015));\nvar inst_25093 \x3d cljs.core.deref(mults);\nvar inst_25094__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(inst_25093,inst_25092__$1);\nvar state_25123__$1 \x3d (function (){var statearr_25185 \x3d state_25123;\n(statearr_25185[(7)] \x3d inst_25092__$1);\n\n(statearr_25185[(11)] \x3d inst_25094__$1);\n\nreturn statearr_25185;\n})();\nif(cljs.core.truth_(inst_25094__$1)){\nvar statearr_25186_27575 \x3d state_25123__$1;\n(statearr_25186_27575[(1)] \x3d (19));\n\n} else {\nvar statearr_25187_27576 \x3d state_25123__$1;\n(statearr_25187_27576[(1)] \x3d (20));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (25))){\nvar inst_25103 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25188_27577 \x3d state_25123__$1;\n(statearr_25188_27577[(2)] \x3d inst_25103);\n\n(statearr_25188_27577[(1)] \x3d (21));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (17))){\nvar inst_25040 \x3d (state_25123[(10)]);\nvar inst_25067 \x3d cljs.core.first(inst_25040);\nvar inst_25072 \x3d cljs.core.async.muxch_STAR_(inst_25067);\nvar inst_25073 \x3d cljs.core.async.close_BANG_(inst_25072);\nvar inst_25077 \x3d cljs.core.next(inst_25040);\nvar inst_25026 \x3d inst_25077;\nvar inst_25027 \x3d null;\nvar inst_25028 \x3d (0);\nvar inst_25029 \x3d (0);\nvar state_25123__$1 \x3d (function (){var statearr_25193 \x3d state_25123;\n(statearr_25193[(12)] \x3d inst_25028);\n\n(statearr_25193[(13)] \x3d inst_25029);\n\n(statearr_25193[(14)] \x3d inst_25073);\n\n(statearr_25193[(15)] \x3d inst_25026);\n\n(statearr_25193[(16)] \x3d inst_25027);\n\nreturn statearr_25193;\n})();\nvar statearr_25194_27578 \x3d state_25123__$1;\n(statearr_25194_27578[(2)] \x3d null);\n\n(statearr_25194_27578[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (3))){\nvar inst_25111 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_25123__$1,inst_25111);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (12))){\nvar inst_25085 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25195_27580 \x3d state_25123__$1;\n(statearr_25195_27580[(2)] \x3d inst_25085);\n\n(statearr_25195_27580[(1)] \x3d (9));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (2))){\nvar state_25123__$1 \x3d state_25123;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_25123__$1,(4),ch);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (23))){\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25201_27584 \x3d state_25123__$1;\n(statearr_25201_27584[(2)] \x3d null);\n\n(statearr_25201_27584[(1)] \x3d (25));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (19))){\nvar inst_25094 \x3d (state_25123[(11)]);\nvar inst_25015 \x3d (state_25123[(8)]);\nvar inst_25096 \x3d cljs.core.async.muxch_STAR_(inst_25094);\nvar state_25123__$1 \x3d state_25123;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_25123__$1,(22),inst_25096,inst_25015);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (11))){\nvar inst_25040 \x3d (state_25123[(10)]);\nvar inst_25026 \x3d (state_25123[(15)]);\nvar inst_25040__$1 \x3d cljs.core.seq(inst_25026);\nvar state_25123__$1 \x3d (function (){var statearr_25203 \x3d state_25123;\n(statearr_25203[(10)] \x3d inst_25040__$1);\n\nreturn statearr_25203;\n})();\nif(inst_25040__$1){\nvar statearr_25206_27585 \x3d state_25123__$1;\n(statearr_25206_27585[(1)] \x3d (13));\n\n} else {\nvar statearr_25207_27586 \x3d state_25123__$1;\n(statearr_25207_27586[(1)] \x3d (14));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (9))){\nvar inst_25087 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25208_27587 \x3d state_25123__$1;\n(statearr_25208_27587[(2)] \x3d inst_25087);\n\n(statearr_25208_27587[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (5))){\nvar inst_25023 \x3d cljs.core.deref(mults);\nvar inst_25024 \x3d cljs.core.vals(inst_25023);\nvar inst_25025 \x3d cljs.core.seq(inst_25024);\nvar inst_25026 \x3d inst_25025;\nvar inst_25027 \x3d null;\nvar inst_25028 \x3d (0);\nvar inst_25029 \x3d (0);\nvar state_25123__$1 \x3d (function (){var statearr_25218 \x3d state_25123;\n(statearr_25218[(12)] \x3d inst_25028);\n\n(statearr_25218[(13)] \x3d inst_25029);\n\n(statearr_25218[(15)] \x3d inst_25026);\n\n(statearr_25218[(16)] \x3d inst_25027);\n\nreturn statearr_25218;\n})();\nvar statearr_25221_27591 \x3d state_25123__$1;\n(statearr_25221_27591[(2)] \x3d null);\n\n(statearr_25221_27591[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (14))){\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25236_27592 \x3d state_25123__$1;\n(statearr_25236_27592[(2)] \x3d null);\n\n(statearr_25236_27592[(1)] \x3d (15));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (16))){\nvar inst_25040 \x3d (state_25123[(10)]);\nvar inst_25059 \x3d cljs.core.chunk_first(inst_25040);\nvar inst_25063 \x3d cljs.core.chunk_rest(inst_25040);\nvar inst_25064 \x3d cljs.core.count(inst_25059);\nvar inst_25026 \x3d inst_25063;\nvar inst_25027 \x3d inst_25059;\nvar inst_25028 \x3d inst_25064;\nvar inst_25029 \x3d (0);\nvar state_25123__$1 \x3d (function (){var statearr_25240 \x3d state_25123;\n(statearr_25240[(12)] \x3d inst_25028);\n\n(statearr_25240[(13)] \x3d inst_25029);\n\n(statearr_25240[(15)] \x3d inst_25026);\n\n(statearr_25240[(16)] \x3d inst_25027);\n\nreturn statearr_25240;\n})();\nvar statearr_25243_27593 \x3d state_25123__$1;\n(statearr_25243_27593[(2)] \x3d null);\n\n(statearr_25243_27593[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (10))){\nvar inst_25028 \x3d (state_25123[(12)]);\nvar inst_25029 \x3d (state_25123[(13)]);\nvar inst_25026 \x3d (state_25123[(15)]);\nvar inst_25027 \x3d (state_25123[(16)]);\nvar inst_25034 \x3d cljs.core._nth(inst_25027,inst_25029);\nvar inst_25035 \x3d cljs.core.async.muxch_STAR_(inst_25034);\nvar inst_25036 \x3d cljs.core.async.close_BANG_(inst_25035);\nvar inst_25037 \x3d (inst_25029 + (1));\nvar tmp25223 \x3d inst_25028;\nvar tmp25224 \x3d inst_25026;\nvar tmp25225 \x3d inst_25027;\nvar inst_25026__$1 \x3d tmp25224;\nvar inst_25027__$1 \x3d tmp25225;\nvar inst_25028__$1 \x3d tmp25223;\nvar inst_25029__$1 \x3d inst_25037;\nvar state_25123__$1 \x3d (function (){var statearr_25250 \x3d state_25123;\n(statearr_25250[(12)] \x3d inst_25028__$1);\n\n(statearr_25250[(13)] \x3d inst_25029__$1);\n\n(statearr_25250[(15)] \x3d inst_25026__$1);\n\n(statearr_25250[(16)] \x3d inst_25027__$1);\n\n(statearr_25250[(17)] \x3d inst_25036);\n\nreturn statearr_25250;\n})();\nvar statearr_25254_27598 \x3d state_25123__$1;\n(statearr_25254_27598[(2)] \x3d null);\n\n(statearr_25254_27598[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (18))){\nvar inst_25080 \x3d (state_25123[(2)]);\nvar state_25123__$1 \x3d state_25123;\nvar statearr_25259_27600 \x3d state_25123__$1;\n(statearr_25259_27600[(2)] \x3d inst_25080);\n\n(statearr_25259_27600[(1)] \x3d (15));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25124 \x3d\x3d\x3d (8))){\nvar inst_25028 \x3d (state_25123[(12)]);\nvar inst_25029 \x3d (state_25123[(13)]);\nvar inst_25031 \x3d (inst_25029 \x3c inst_25028);\nvar inst_25032 \x3d inst_25031;\nvar state_25123__$1 \x3d state_25123;\nif(cljs.core.truth_(inst_25032)){\nvar statearr_25264_27601 \x3d state_25123__$1;\n(statearr_25264_27601[(1)] \x3d (10));\n\n} else {\nvar statearr_25265_27602 \x3d state_25123__$1;\n(statearr_25265_27602[(1)] \x3d (11));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_25268 \x3d [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_25268[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_25268[(1)] \x3d (1));\n\nreturn statearr_25268;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_25123){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_25123);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e25272){var ex__21558__auto__ \x3d e25272;\nvar statearr_25273_27603 \x3d state_25123;\n(statearr_25273_27603[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_25123[(4)]))){\nvar statearr_25274_27607 \x3d state_25123;\n(statearr_25274_27607[(1)] \x3d cljs.core.first((state_25123[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27608 \x3d state_25123;\nstate_25123 \x3d G__27608;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_25123){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_25123);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_25276 \x3d f__22635__auto__();\n(statearr_25276[(6)] \x3d c__22634__auto___27555);\n\nreturn statearr_25276;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn p;\n}));\n\n(cljs.core.async.pub.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Subscribes a channel to a topic of a pub.\n * \n *   By default the channel will be closed when the source closes,\n *   but can be determined by the close? parameter.\n */\ncljs.core.async.sub \x3d (function cljs$core$async$sub(var_args){\nvar G__25281 \x3d arguments.length;\nswitch (G__25281) {\ncase 3:\nreturn cljs.core.async.sub.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.core.async.sub.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.sub.cljs$core$IFn$_invoke$arity$3 \x3d (function (p,topic,ch){\nreturn cljs.core.async.sub.cljs$core$IFn$_invoke$arity$4(p,topic,ch,true);\n}));\n\n(cljs.core.async.sub.cljs$core$IFn$_invoke$arity$4 \x3d (function (p,topic,ch,close_QMARK_){\nreturn cljs.core.async.sub_STAR_(p,topic,ch,close_QMARK_);\n}));\n\n(cljs.core.async.sub.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Unsubscribes a channel from a topic of a pub\n */\ncljs.core.async.unsub \x3d (function cljs$core$async$unsub(p,topic,ch){\nreturn cljs.core.async.unsub_STAR_(p,topic,ch);\n});\n/**\n * Unsubscribes all channels from a pub, or a topic of a pub\n */\ncljs.core.async.unsub_all \x3d (function cljs$core$async$unsub_all(var_args){\nvar G__25288 \x3d arguments.length;\nswitch (G__25288) {\ncase 1:\nreturn cljs.core.async.unsub_all.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.unsub_all.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.unsub_all.cljs$core$IFn$_invoke$arity$1 \x3d (function (p){\nreturn cljs.core.async.unsub_all_STAR_(p);\n}));\n\n(cljs.core.async.unsub_all.cljs$core$IFn$_invoke$arity$2 \x3d (function (p,topic){\nreturn cljs.core.async.unsub_all_STAR_(p,topic);\n}));\n\n(cljs.core.async.unsub_all.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Takes a function and a collection of source channels, and returns a\n *   channel which contains the values produced by applying f to the set\n *   of first items taken from each source channel, followed by applying\n *   f to the set of second items from each channel, until any one of the\n *   channels is closed, at which point the output channel will be\n *   closed. The returned channel will be unbuffered by default, or a\n *   buf-or-n can be supplied\n */\ncljs.core.async.map \x3d (function cljs$core$async$map(var_args){\nvar G__25304 \x3d arguments.length;\nswitch (G__25304) {\ncase 2:\nreturn cljs.core.async.map.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.map.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.map.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,chs){\nreturn cljs.core.async.map.cljs$core$IFn$_invoke$arity$3(f,chs,null);\n}));\n\n(cljs.core.async.map.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,chs,buf_or_n){\nvar chs__$1 \x3d cljs.core.vec(chs);\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\nvar cnt \x3d cljs.core.count(chs__$1);\nvar rets \x3d cljs.core.object_array.cljs$core$IFn$_invoke$arity$1(cnt);\nvar dchan \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\nvar dctr \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(null);\nvar done \x3d cljs.core.mapv.cljs$core$IFn$_invoke$arity$2((function (i){\nreturn (function (ret){\n(rets[i] \x3d ret);\n\nif((cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(dctr,cljs.core.dec) \x3d\x3d\x3d (0))){\nreturn cljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(dchan,rets.slice((0)));\n} else {\nreturn null;\n}\n});\n}),cljs.core.range.cljs$core$IFn$_invoke$arity$1(cnt));\nif((cnt \x3d\x3d\x3d (0))){\ncljs.core.async.close_BANG_(out);\n} else {\nvar c__22634__auto___27625 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_25387){\nvar state_val_25388 \x3d (state_25387[(1)]);\nif((state_val_25388 \x3d\x3d\x3d (7))){\nvar state_25387__$1 \x3d state_25387;\nvar statearr_25390_27626 \x3d state_25387__$1;\n(statearr_25390_27626[(2)] \x3d null);\n\n(statearr_25390_27626[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (1))){\nvar state_25387__$1 \x3d state_25387;\nvar statearr_25392_27627 \x3d state_25387__$1;\n(statearr_25392_27627[(2)] \x3d null);\n\n(statearr_25392_27627[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (4))){\nvar inst_25318 \x3d (state_25387[(7)]);\nvar inst_25317 \x3d (state_25387[(8)]);\nvar inst_25320 \x3d (inst_25318 \x3c inst_25317);\nvar state_25387__$1 \x3d state_25387;\nif(cljs.core.truth_(inst_25320)){\nvar statearr_25393_27628 \x3d state_25387__$1;\n(statearr_25393_27628[(1)] \x3d (6));\n\n} else {\nvar statearr_25394_27629 \x3d state_25387__$1;\n(statearr_25394_27629[(1)] \x3d (7));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (15))){\nvar inst_25365 \x3d (state_25387[(9)]);\nvar inst_25370 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,inst_25365);\nvar state_25387__$1 \x3d state_25387;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_25387__$1,(17),out,inst_25370);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (13))){\nvar inst_25365 \x3d (state_25387[(9)]);\nvar inst_25365__$1 \x3d (state_25387[(2)]);\nvar inst_25366 \x3d cljs.core.some(cljs.core.nil_QMARK_,inst_25365__$1);\nvar state_25387__$1 \x3d (function (){var statearr_25395 \x3d state_25387;\n(statearr_25395[(9)] \x3d inst_25365__$1);\n\nreturn statearr_25395;\n})();\nif(cljs.core.truth_(inst_25366)){\nvar statearr_25396_27631 \x3d state_25387__$1;\n(statearr_25396_27631[(1)] \x3d (14));\n\n} else {\nvar statearr_25397_27632 \x3d state_25387__$1;\n(statearr_25397_27632[(1)] \x3d (15));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (6))){\nvar state_25387__$1 \x3d state_25387;\nvar statearr_25398_27633 \x3d state_25387__$1;\n(statearr_25398_27633[(2)] \x3d null);\n\n(statearr_25398_27633[(1)] \x3d (9));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (17))){\nvar inst_25372 \x3d (state_25387[(2)]);\nvar state_25387__$1 \x3d (function (){var statearr_25413 \x3d state_25387;\n(statearr_25413[(10)] \x3d inst_25372);\n\nreturn statearr_25413;\n})();\nvar statearr_25414_27634 \x3d state_25387__$1;\n(statearr_25414_27634[(2)] \x3d null);\n\n(statearr_25414_27634[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (3))){\nvar inst_25381 \x3d (state_25387[(2)]);\nvar state_25387__$1 \x3d state_25387;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_25387__$1,inst_25381);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (12))){\nvar _ \x3d (function (){var statearr_25416 \x3d state_25387;\n(statearr_25416[(4)] \x3d cljs.core.rest((state_25387[(4)])));\n\nreturn statearr_25416;\n})();\nvar state_25387__$1 \x3d state_25387;\nvar ex25412 \x3d (state_25387__$1[(2)]);\nvar statearr_25417_27635 \x3d state_25387__$1;\n(statearr_25417_27635[(5)] \x3d ex25412);\n\n\nif((ex25412 instanceof Object)){\nvar statearr_25427_27636 \x3d state_25387__$1;\n(statearr_25427_27636[(1)] \x3d (11));\n\n(statearr_25427_27636[(5)] \x3d null);\n\n} else {\nthrow ex25412;\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (2))){\nvar inst_25316 \x3d cljs.core.reset_BANG_(dctr,cnt);\nvar inst_25317 \x3d cnt;\nvar inst_25318 \x3d (0);\nvar state_25387__$1 \x3d (function (){var statearr_25442 \x3d state_25387;\n(statearr_25442[(11)] \x3d inst_25316);\n\n(statearr_25442[(7)] \x3d inst_25318);\n\n(statearr_25442[(8)] \x3d inst_25317);\n\nreturn statearr_25442;\n})();\nvar statearr_25447_27638 \x3d state_25387__$1;\n(statearr_25447_27638[(2)] \x3d null);\n\n(statearr_25447_27638[(1)] \x3d (4));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (11))){\nvar inst_25341 \x3d (state_25387[(2)]);\nvar inst_25342 \x3d cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(dctr,cljs.core.dec);\nvar state_25387__$1 \x3d (function (){var statearr_25451 \x3d state_25387;\n(statearr_25451[(12)] \x3d inst_25341);\n\nreturn statearr_25451;\n})();\nvar statearr_25452_27639 \x3d state_25387__$1;\n(statearr_25452_27639[(2)] \x3d inst_25342);\n\n(statearr_25452_27639[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (9))){\nvar inst_25318 \x3d (state_25387[(7)]);\nvar _ \x3d (function (){var statearr_25454 \x3d state_25387;\n(statearr_25454[(4)] \x3d cljs.core.cons((12),(state_25387[(4)])));\n\nreturn statearr_25454;\n})();\nvar inst_25348 \x3d (chs__$1.cljs$core$IFn$_invoke$arity$1 ? chs__$1.cljs$core$IFn$_invoke$arity$1(inst_25318) : chs__$1.call(null, inst_25318));\nvar inst_25352 \x3d (done.cljs$core$IFn$_invoke$arity$1 ? done.cljs$core$IFn$_invoke$arity$1(inst_25318) : done.call(null, inst_25318));\nvar inst_25353 \x3d cljs.core.async.take_BANG_.cljs$core$IFn$_invoke$arity$2(inst_25348,inst_25352);\nvar ___$1 \x3d (function (){var statearr_25455 \x3d state_25387;\n(statearr_25455[(4)] \x3d cljs.core.rest((state_25387[(4)])));\n\nreturn statearr_25455;\n})();\nvar state_25387__$1 \x3d state_25387;\nvar statearr_25456_27640 \x3d state_25387__$1;\n(statearr_25456_27640[(2)] \x3d inst_25353);\n\n(statearr_25456_27640[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (5))){\nvar inst_25363 \x3d (state_25387[(2)]);\nvar state_25387__$1 \x3d (function (){var statearr_25467 \x3d state_25387;\n(statearr_25467[(13)] \x3d inst_25363);\n\nreturn statearr_25467;\n})();\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_25387__$1,(13),dchan);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (14))){\nvar inst_25368 \x3d cljs.core.async.close_BANG_(out);\nvar state_25387__$1 \x3d state_25387;\nvar statearr_25470_27645 \x3d state_25387__$1;\n(statearr_25470_27645[(2)] \x3d inst_25368);\n\n(statearr_25470_27645[(1)] \x3d (16));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (16))){\nvar inst_25377 \x3d (state_25387[(2)]);\nvar state_25387__$1 \x3d state_25387;\nvar statearr_25476_27646 \x3d state_25387__$1;\n(statearr_25476_27646[(2)] \x3d inst_25377);\n\n(statearr_25476_27646[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (10))){\nvar inst_25318 \x3d (state_25387[(7)]);\nvar inst_25356 \x3d (state_25387[(2)]);\nvar inst_25357 \x3d (inst_25318 + (1));\nvar inst_25318__$1 \x3d inst_25357;\nvar state_25387__$1 \x3d (function (){var statearr_25477 \x3d state_25387;\n(statearr_25477[(14)] \x3d inst_25356);\n\n(statearr_25477[(7)] \x3d inst_25318__$1);\n\nreturn statearr_25477;\n})();\nvar statearr_25478_27647 \x3d state_25387__$1;\n(statearr_25478_27647[(2)] \x3d null);\n\n(statearr_25478_27647[(1)] \x3d (4));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25388 \x3d\x3d\x3d (8))){\nvar inst_25361 \x3d (state_25387[(2)]);\nvar state_25387__$1 \x3d state_25387;\nvar statearr_25479_27648 \x3d state_25387__$1;\n(statearr_25479_27648[(2)] \x3d inst_25361);\n\n(statearr_25479_27648[(1)] \x3d (5));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_25481 \x3d [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_25481[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_25481[(1)] \x3d (1));\n\nreturn statearr_25481;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_25387){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_25387);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e25485){var ex__21558__auto__ \x3d e25485;\nvar statearr_25487_27649 \x3d state_25387;\n(statearr_25487_27649[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_25387[(4)]))){\nvar statearr_25488_27650 \x3d state_25387;\n(statearr_25488_27650[(1)] \x3d cljs.core.first((state_25387[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27651 \x3d state_25387;\nstate_25387 \x3d G__27651;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_25387){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_25387);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_25492 \x3d f__22635__auto__();\n(statearr_25492[(6)] \x3d c__22634__auto___27625);\n\nreturn statearr_25492;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n}\n\nreturn out;\n}));\n\n(cljs.core.async.map.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Takes a collection of source channels and returns a channel which\n *   contains all values taken from them. The returned channel will be\n *   unbuffered by default, or a buf-or-n can be supplied. The channel\n *   will close after all the source channels have closed.\n */\ncljs.core.async.merge \x3d (function cljs$core$async$merge(var_args){\nvar G__25500 \x3d arguments.length;\nswitch (G__25500) {\ncase 1:\nreturn cljs.core.async.merge.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.merge.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.merge.cljs$core$IFn$_invoke$arity$1 \x3d (function (chs){\nreturn cljs.core.async.merge.cljs$core$IFn$_invoke$arity$2(chs,null);\n}));\n\n(cljs.core.async.merge.cljs$core$IFn$_invoke$arity$2 \x3d (function (chs,buf_or_n){\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\nvar c__22634__auto___27653 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_25555){\nvar state_val_25556 \x3d (state_25555[(1)]);\nif((state_val_25556 \x3d\x3d\x3d (7))){\nvar inst_25530 \x3d (state_25555[(7)]);\nvar inst_25531 \x3d (state_25555[(8)]);\nvar inst_25530__$1 \x3d (state_25555[(2)]);\nvar inst_25531__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_25530__$1,(0),null);\nvar inst_25532 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(inst_25530__$1,(1),null);\nvar inst_25533 \x3d (inst_25531__$1 \x3d\x3d null);\nvar state_25555__$1 \x3d (function (){var statearr_25563 \x3d state_25555;\n(statearr_25563[(9)] \x3d inst_25532);\n\n(statearr_25563[(7)] \x3d inst_25530__$1);\n\n(statearr_25563[(8)] \x3d inst_25531__$1);\n\nreturn statearr_25563;\n})();\nif(cljs.core.truth_(inst_25533)){\nvar statearr_25565_27654 \x3d state_25555__$1;\n(statearr_25565_27654[(1)] \x3d (8));\n\n} else {\nvar statearr_25566_27655 \x3d state_25555__$1;\n(statearr_25566_27655[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (1))){\nvar inst_25514 \x3d cljs.core.vec(chs);\nvar inst_25515 \x3d inst_25514;\nvar state_25555__$1 \x3d (function (){var statearr_25567 \x3d state_25555;\n(statearr_25567[(10)] \x3d inst_25515);\n\nreturn statearr_25567;\n})();\nvar statearr_25568_27656 \x3d state_25555__$1;\n(statearr_25568_27656[(2)] \x3d null);\n\n(statearr_25568_27656[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (4))){\nvar inst_25515 \x3d (state_25555[(10)]);\nvar state_25555__$1 \x3d state_25555;\nreturn cljs.core.async.ioc_alts_BANG_(state_25555__$1,(7),inst_25515);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (6))){\nvar inst_25549 \x3d (state_25555[(2)]);\nvar state_25555__$1 \x3d state_25555;\nvar statearr_25575_27657 \x3d state_25555__$1;\n(statearr_25575_27657[(2)] \x3d inst_25549);\n\n(statearr_25575_27657[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (3))){\nvar inst_25551 \x3d (state_25555[(2)]);\nvar state_25555__$1 \x3d state_25555;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_25555__$1,inst_25551);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (2))){\nvar inst_25515 \x3d (state_25555[(10)]);\nvar inst_25517 \x3d cljs.core.count(inst_25515);\nvar inst_25518 \x3d (inst_25517 \x3e (0));\nvar state_25555__$1 \x3d state_25555;\nif(cljs.core.truth_(inst_25518)){\nvar statearr_25582_27658 \x3d state_25555__$1;\n(statearr_25582_27658[(1)] \x3d (4));\n\n} else {\nvar statearr_25583_27659 \x3d state_25555__$1;\n(statearr_25583_27659[(1)] \x3d (5));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (11))){\nvar inst_25515 \x3d (state_25555[(10)]);\nvar inst_25542 \x3d (state_25555[(2)]);\nvar tmp25576 \x3d inst_25515;\nvar inst_25515__$1 \x3d tmp25576;\nvar state_25555__$1 \x3d (function (){var statearr_25586 \x3d state_25555;\n(statearr_25586[(11)] \x3d inst_25542);\n\n(statearr_25586[(10)] \x3d inst_25515__$1);\n\nreturn statearr_25586;\n})();\nvar statearr_25587_27660 \x3d state_25555__$1;\n(statearr_25587_27660[(2)] \x3d null);\n\n(statearr_25587_27660[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (9))){\nvar inst_25531 \x3d (state_25555[(8)]);\nvar state_25555__$1 \x3d state_25555;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_25555__$1,(11),out,inst_25531);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (5))){\nvar inst_25547 \x3d cljs.core.async.close_BANG_(out);\nvar state_25555__$1 \x3d state_25555;\nvar statearr_25595_27661 \x3d state_25555__$1;\n(statearr_25595_27661[(2)] \x3d inst_25547);\n\n(statearr_25595_27661[(1)] \x3d (6));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (10))){\nvar inst_25545 \x3d (state_25555[(2)]);\nvar state_25555__$1 \x3d state_25555;\nvar statearr_25599_27662 \x3d state_25555__$1;\n(statearr_25599_27662[(2)] \x3d inst_25545);\n\n(statearr_25599_27662[(1)] \x3d (6));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25556 \x3d\x3d\x3d (8))){\nvar inst_25532 \x3d (state_25555[(9)]);\nvar inst_25530 \x3d (state_25555[(7)]);\nvar inst_25531 \x3d (state_25555[(8)]);\nvar inst_25515 \x3d (state_25555[(10)]);\nvar inst_25537 \x3d (function (){var cs \x3d inst_25515;\nvar vec__25520 \x3d inst_25530;\nvar v \x3d inst_25531;\nvar c \x3d inst_25532;\nreturn (function (p1__25494_SHARP_){\nreturn cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(c,p1__25494_SHARP_);\n});\n})();\nvar inst_25538 \x3d cljs.core.filterv(inst_25537,inst_25515);\nvar inst_25515__$1 \x3d inst_25538;\nvar state_25555__$1 \x3d (function (){var statearr_25619 \x3d state_25555;\n(statearr_25619[(10)] \x3d inst_25515__$1);\n\nreturn statearr_25619;\n})();\nvar statearr_25620_27663 \x3d state_25555__$1;\n(statearr_25620_27663[(2)] \x3d null);\n\n(statearr_25620_27663[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_25621 \x3d [null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_25621[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_25621[(1)] \x3d (1));\n\nreturn statearr_25621;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_25555){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_25555);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e25622){var ex__21558__auto__ \x3d e25622;\nvar statearr_25623_27665 \x3d state_25555;\n(statearr_25623_27665[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_25555[(4)]))){\nvar statearr_25630_27666 \x3d state_25555;\n(statearr_25630_27666[(1)] \x3d cljs.core.first((state_25555[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27668 \x3d state_25555;\nstate_25555 \x3d G__27668;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_25555){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_25555);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_25631 \x3d f__22635__auto__();\n(statearr_25631[(6)] \x3d c__22634__auto___27653);\n\nreturn statearr_25631;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn out;\n}));\n\n(cljs.core.async.merge.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Returns a channel containing the single (collection) result of the\n *   items taken from the channel conjoined to the supplied\n *   collection. ch must close before into produces a result.\n */\ncljs.core.async.into \x3d (function cljs$core$async$into(coll,ch){\nreturn cljs.core.async.reduce(cljs.core.conj,coll,ch);\n});\n/**\n * Returns a channel that will return, at most, n items from ch. After n items\n * have been returned, or ch has been closed, the return chanel will close.\n * \n *   The output channel is unbuffered by default, unless buf-or-n is given.\n */\ncljs.core.async.take \x3d (function cljs$core$async$take(var_args){\nvar G__25646 \x3d arguments.length;\nswitch (G__25646) {\ncase 2:\nreturn cljs.core.async.take.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.take.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.take.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,ch){\nreturn cljs.core.async.take.cljs$core$IFn$_invoke$arity$3(n,ch,null);\n}));\n\n(cljs.core.async.take.cljs$core$IFn$_invoke$arity$3 \x3d (function (n,ch,buf_or_n){\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\nvar c__22634__auto___27670 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_25688){\nvar state_val_25689 \x3d (state_25688[(1)]);\nif((state_val_25689 \x3d\x3d\x3d (7))){\nvar inst_25662 \x3d (state_25688[(7)]);\nvar inst_25662__$1 \x3d (state_25688[(2)]);\nvar inst_25663 \x3d (inst_25662__$1 \x3d\x3d null);\nvar inst_25664 \x3d cljs.core.not(inst_25663);\nvar state_25688__$1 \x3d (function (){var statearr_25697 \x3d state_25688;\n(statearr_25697[(7)] \x3d inst_25662__$1);\n\nreturn statearr_25697;\n})();\nif(inst_25664){\nvar statearr_25698_27671 \x3d state_25688__$1;\n(statearr_25698_27671[(1)] \x3d (8));\n\n} else {\nvar statearr_25699_27672 \x3d state_25688__$1;\n(statearr_25699_27672[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (1))){\nvar inst_25655 \x3d (0);\nvar state_25688__$1 \x3d (function (){var statearr_25700 \x3d state_25688;\n(statearr_25700[(8)] \x3d inst_25655);\n\nreturn statearr_25700;\n})();\nvar statearr_25701_27673 \x3d state_25688__$1;\n(statearr_25701_27673[(2)] \x3d null);\n\n(statearr_25701_27673[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (4))){\nvar state_25688__$1 \x3d state_25688;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_25688__$1,(7),ch);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (6))){\nvar inst_25678 \x3d (state_25688[(2)]);\nvar state_25688__$1 \x3d state_25688;\nvar statearr_25709_27674 \x3d state_25688__$1;\n(statearr_25709_27674[(2)] \x3d inst_25678);\n\n(statearr_25709_27674[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (3))){\nvar inst_25680 \x3d (state_25688[(2)]);\nvar inst_25681 \x3d cljs.core.async.close_BANG_(out);\nvar state_25688__$1 \x3d (function (){var statearr_25710 \x3d state_25688;\n(statearr_25710[(9)] \x3d inst_25680);\n\nreturn statearr_25710;\n})();\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_25688__$1,inst_25681);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (2))){\nvar inst_25655 \x3d (state_25688[(8)]);\nvar inst_25658 \x3d (inst_25655 \x3c n);\nvar state_25688__$1 \x3d state_25688;\nif(cljs.core.truth_(inst_25658)){\nvar statearr_25715_27677 \x3d state_25688__$1;\n(statearr_25715_27677[(1)] \x3d (4));\n\n} else {\nvar statearr_25719_27678 \x3d state_25688__$1;\n(statearr_25719_27678[(1)] \x3d (5));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (11))){\nvar inst_25655 \x3d (state_25688[(8)]);\nvar inst_25670 \x3d (state_25688[(2)]);\nvar inst_25671 \x3d (inst_25655 + (1));\nvar inst_25655__$1 \x3d inst_25671;\nvar state_25688__$1 \x3d (function (){var statearr_25722 \x3d state_25688;\n(statearr_25722[(8)] \x3d inst_25655__$1);\n\n(statearr_25722[(10)] \x3d inst_25670);\n\nreturn statearr_25722;\n})();\nvar statearr_25728_27679 \x3d state_25688__$1;\n(statearr_25728_27679[(2)] \x3d null);\n\n(statearr_25728_27679[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (9))){\nvar state_25688__$1 \x3d state_25688;\nvar statearr_25730_27680 \x3d state_25688__$1;\n(statearr_25730_27680[(2)] \x3d null);\n\n(statearr_25730_27680[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (5))){\nvar state_25688__$1 \x3d state_25688;\nvar statearr_25731_27681 \x3d state_25688__$1;\n(statearr_25731_27681[(2)] \x3d null);\n\n(statearr_25731_27681[(1)] \x3d (6));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (10))){\nvar inst_25675 \x3d (state_25688[(2)]);\nvar state_25688__$1 \x3d state_25688;\nvar statearr_25732_27682 \x3d state_25688__$1;\n(statearr_25732_27682[(2)] \x3d inst_25675);\n\n(statearr_25732_27682[(1)] \x3d (6));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25689 \x3d\x3d\x3d (8))){\nvar inst_25662 \x3d (state_25688[(7)]);\nvar state_25688__$1 \x3d state_25688;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_25688__$1,(11),out,inst_25662);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_25745 \x3d [null,null,null,null,null,null,null,null,null,null,null];\n(statearr_25745[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_25745[(1)] \x3d (1));\n\nreturn statearr_25745;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_25688){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_25688);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e25746){var ex__21558__auto__ \x3d e25746;\nvar statearr_25747_27684 \x3d state_25688;\n(statearr_25747_27684[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_25688[(4)]))){\nvar statearr_25749_27685 \x3d state_25688;\n(statearr_25749_27685[(1)] \x3d cljs.core.first((state_25688[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27686 \x3d state_25688;\nstate_25688 \x3d G__27686;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_25688){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_25688);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_25753 \x3d f__22635__auto__();\n(statearr_25753[(6)] \x3d c__22634__auto___27670);\n\nreturn statearr_25753;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn out;\n}));\n\n(cljs.core.async.take.cljs$lang$maxFixedArity \x3d 3);\n\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Handler}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async25771 \x3d (function (f,ch,meta25763,_,fn1,meta25772){\nthis.f \x3d f;\nthis.ch \x3d ch;\nthis.meta25763 \x3d meta25763;\nthis._ \x3d _;\nthis.fn1 \x3d fn1;\nthis.meta25772 \x3d meta25772;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async25771.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25773,meta25772__$1){\nvar self__ \x3d this;\nvar _25773__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async25771(self__.f,self__.ch,self__.meta25763,self__._,self__.fn1,meta25772__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async25771.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25773){\nvar self__ \x3d this;\nvar _25773__$1 \x3d this;\nreturn self__.meta25772;\n}));\n\n(cljs.core.async.t_cljs$core$async25771.prototype.cljs$core$async$impl$protocols$Handler$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25771.prototype.cljs$core$async$impl$protocols$Handler$active_QMARK_$arity$1 \x3d (function (___$1){\nvar self__ \x3d this;\nvar ___$2 \x3d this;\nreturn cljs.core.async.impl.protocols.active_QMARK_(self__.fn1);\n}));\n\n(cljs.core.async.t_cljs$core$async25771.prototype.cljs$core$async$impl$protocols$Handler$blockable_QMARK_$arity$1 \x3d (function (___$1){\nvar self__ \x3d this;\nvar ___$2 \x3d this;\nreturn true;\n}));\n\n(cljs.core.async.t_cljs$core$async25771.prototype.cljs$core$async$impl$protocols$Handler$commit$arity$1 \x3d (function (___$1){\nvar self__ \x3d this;\nvar ___$2 \x3d this;\nvar f1 \x3d cljs.core.async.impl.protocols.commit(self__.fn1);\nreturn (function (p1__25754_SHARP_){\nvar G__25781 \x3d (((p1__25754_SHARP_ \x3d\x3d null))?null:(self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(p1__25754_SHARP_) : self__.f.call(null, p1__25754_SHARP_)));\nreturn (f1.cljs$core$IFn$_invoke$arity$1 ? f1.cljs$core$IFn$_invoke$arity$1(G__25781) : f1.call(null, G__25781));\n});\n}));\n\n(cljs.core.async.t_cljs$core$async25771.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),new cljs.core.Symbol(null,\x22ch\x22,\x22ch\x22,1085813622,null),new cljs.core.Symbol(null,\x22meta25763\x22,\x22meta25763\x22,-454238064,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22_\x22,\x22_\x22,-1201019570,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(\x22cljs.core.async\x22,\x22t_cljs$core$async25762\x22,\x22cljs.core.async/t_cljs$core$async25762\x22,-1599690578,null)], null)),new cljs.core.Symbol(null,\x22fn1\x22,\x22fn1\x22,895834444,null),new cljs.core.Symbol(null,\x22meta25772\x22,\x22meta25772\x22,-2082129957,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async25771.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async25771.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async25771\x22);\n\n(cljs.core.async.t_cljs$core$async25771.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async25771\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async25771.\n */\ncljs.core.async.__GT_t_cljs$core$async25771 \x3d (function cljs$core$async$__GT_t_cljs$core$async25771(f,ch,meta25763,_,fn1,meta25772){\nreturn (new cljs.core.async.t_cljs$core$async25771(f,ch,meta25763,_,fn1,meta25772));\n});\n\n\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Channel}\n * @implements {cljs.core.async.impl.protocols.WritePort}\n * @implements {cljs.core.async.impl.protocols.ReadPort}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async25762 \x3d (function (f,ch,meta25763){\nthis.f \x3d f;\nthis.ch \x3d ch;\nthis.meta25763 \x3d meta25763;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25764,meta25763__$1){\nvar self__ \x3d this;\nvar _25764__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async25762(self__.f,self__.ch,meta25763__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25764){\nvar self__ \x3d this;\nvar _25764__$1 \x3d this;\nreturn self__.meta25763;\n}));\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$async$impl$protocols$Channel$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.close_BANG_(self__.ch);\n}));\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$async$impl$protocols$Channel$closed_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.closed_QMARK_(self__.ch);\n}));\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$async$impl$protocols$ReadPort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2 \x3d (function (_,fn1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar ret \x3d cljs.core.async.impl.protocols.take_BANG_(self__.ch,(new cljs.core.async.t_cljs$core$async25771(self__.f,self__.ch,self__.meta25763,___$1,fn1,cljs.core.PersistentArrayMap.EMPTY)));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d ret;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (!((cljs.core.deref(ret) \x3d\x3d null)));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn cljs.core.async.impl.channels.box((function (){var G__25788 \x3d cljs.core.deref(ret);\nreturn (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(G__25788) : self__.f.call(null, G__25788));\n})());\n} else {\nreturn ret;\n}\n}));\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$async$impl$protocols$WritePort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25762.prototype.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3 \x3d (function (_,val,fn1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.put_BANG_(self__.ch,val,fn1);\n}));\n\n(cljs.core.async.t_cljs$core$async25762.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),new cljs.core.Symbol(null,\x22ch\x22,\x22ch\x22,1085813622,null),new cljs.core.Symbol(null,\x22meta25763\x22,\x22meta25763\x22,-454238064,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async25762.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async25762.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async25762\x22);\n\n(cljs.core.async.t_cljs$core$async25762.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async25762\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async25762.\n */\ncljs.core.async.__GT_t_cljs$core$async25762 \x3d (function cljs$core$async$__GT_t_cljs$core$async25762(f,ch,meta25763){\nreturn (new cljs.core.async.t_cljs$core$async25762(f,ch,meta25763));\n});\n\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.map_LT_ \x3d (function cljs$core$async$map_LT_(f,ch){\nreturn (new cljs.core.async.t_cljs$core$async25762(f,ch,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Channel}\n * @implements {cljs.core.async.impl.protocols.WritePort}\n * @implements {cljs.core.async.impl.protocols.ReadPort}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async25792 \x3d (function (f,ch,meta25793){\nthis.f \x3d f;\nthis.ch \x3d ch;\nthis.meta25793 \x3d meta25793;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25794,meta25793__$1){\nvar self__ \x3d this;\nvar _25794__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async25792(self__.f,self__.ch,meta25793__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25794){\nvar self__ \x3d this;\nvar _25794__$1 \x3d this;\nreturn self__.meta25793;\n}));\n\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$async$impl$protocols$Channel$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.close_BANG_(self__.ch);\n}));\n\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$async$impl$protocols$ReadPort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2 \x3d (function (_,fn1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.take_BANG_(self__.ch,fn1);\n}));\n\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$async$impl$protocols$WritePort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25792.prototype.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3 \x3d (function (_,val,fn1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.put_BANG_(self__.ch,(self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(val) : self__.f.call(null, val)),fn1);\n}));\n\n(cljs.core.async.t_cljs$core$async25792.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),new cljs.core.Symbol(null,\x22ch\x22,\x22ch\x22,1085813622,null),new cljs.core.Symbol(null,\x22meta25793\x22,\x22meta25793\x22,-879877987,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async25792.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async25792.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async25792\x22);\n\n(cljs.core.async.t_cljs$core$async25792.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async25792\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async25792.\n */\ncljs.core.async.__GT_t_cljs$core$async25792 \x3d (function cljs$core$async$__GT_t_cljs$core$async25792(f,ch,meta25793){\nreturn (new cljs.core.async.t_cljs$core$async25792(f,ch,meta25793));\n});\n\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.map_GT_ \x3d (function cljs$core$async$map_GT_(f,ch){\nreturn (new cljs.core.async.t_cljs$core$async25792(f,ch,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.async.impl.protocols.Channel}\n * @implements {cljs.core.async.impl.protocols.WritePort}\n * @implements {cljs.core.async.impl.protocols.ReadPort}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.core.async.t_cljs$core$async25803 \x3d (function (p,ch,meta25804){\nthis.p \x3d p;\nthis.ch \x3d ch;\nthis.meta25804 \x3d meta25804;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25805,meta25804__$1){\nvar self__ \x3d this;\nvar _25805__$1 \x3d this;\nreturn (new cljs.core.async.t_cljs$core$async25803(self__.p,self__.ch,meta25804__$1));\n}));\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25805){\nvar self__ \x3d this;\nvar _25805__$1 \x3d this;\nreturn self__.meta25804;\n}));\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$async$impl$protocols$Channel$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$async$impl$protocols$Channel$close_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.close_BANG_(self__.ch);\n}));\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$async$impl$protocols$Channel$closed_QMARK_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.closed_QMARK_(self__.ch);\n}));\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$async$impl$protocols$ReadPort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2 \x3d (function (_,fn1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.async.impl.protocols.take_BANG_(self__.ch,fn1);\n}));\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$async$impl$protocols$WritePort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.async.t_cljs$core$async25803.prototype.cljs$core$async$impl$protocols$WritePort$put_BANG_$arity$3 \x3d (function (_,val,fn1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_((self__.p.cljs$core$IFn$_invoke$arity$1 ? self__.p.cljs$core$IFn$_invoke$arity$1(val) : self__.p.call(null, val)))){\nreturn cljs.core.async.impl.protocols.put_BANG_(self__.ch,val,fn1);\n} else {\nreturn cljs.core.async.impl.channels.box(cljs.core.not(cljs.core.async.impl.protocols.closed_QMARK_(self__.ch)));\n}\n}));\n\n(cljs.core.async.t_cljs$core$async25803.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22p\x22,\x22p\x22,1791580836,null),new cljs.core.Symbol(null,\x22ch\x22,\x22ch\x22,1085813622,null),new cljs.core.Symbol(null,\x22meta25804\x22,\x22meta25804\x22,-1169325572,null)], null);\n}));\n\n(cljs.core.async.t_cljs$core$async25803.cljs$lang$type \x3d true);\n\n(cljs.core.async.t_cljs$core$async25803.cljs$lang$ctorStr \x3d \x22cljs.core.async/t_cljs$core$async25803\x22);\n\n(cljs.core.async.t_cljs$core$async25803.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.core.async/t_cljs$core$async25803\x22);\n}));\n\n/**\n * Positional factory function for cljs.core.async/t_cljs$core$async25803.\n */\ncljs.core.async.__GT_t_cljs$core$async25803 \x3d (function cljs$core$async$__GT_t_cljs$core$async25803(p,ch,meta25804){\nreturn (new cljs.core.async.t_cljs$core$async25803(p,ch,meta25804));\n});\n\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.filter_GT_ \x3d (function cljs$core$async$filter_GT_(p,ch){\nreturn (new cljs.core.async.t_cljs$core$async25803(p,ch,cljs.core.PersistentArrayMap.EMPTY));\n});\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.remove_GT_ \x3d (function cljs$core$async$remove_GT_(p,ch){\nreturn cljs.core.async.filter_GT_(cljs.core.complement(p),ch);\n});\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.filter_LT_ \x3d (function cljs$core$async$filter_LT_(var_args){\nvar G__25836 \x3d arguments.length;\nswitch (G__25836) {\ncase 2:\nreturn cljs.core.async.filter_LT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.filter_LT_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.filter_LT_.cljs$core$IFn$_invoke$arity$2 \x3d (function (p,ch){\nreturn cljs.core.async.filter_LT_.cljs$core$IFn$_invoke$arity$3(p,ch,null);\n}));\n\n(cljs.core.async.filter_LT_.cljs$core$IFn$_invoke$arity$3 \x3d (function (p,ch,buf_or_n){\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\nvar c__22634__auto___27691 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_25880){\nvar state_val_25881 \x3d (state_25880[(1)]);\nif((state_val_25881 \x3d\x3d\x3d (7))){\nvar inst_25875 \x3d (state_25880[(2)]);\nvar state_25880__$1 \x3d state_25880;\nvar statearr_25887_27692 \x3d state_25880__$1;\n(statearr_25887_27692[(2)] \x3d inst_25875);\n\n(statearr_25887_27692[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (1))){\nvar state_25880__$1 \x3d state_25880;\nvar statearr_25888_27693 \x3d state_25880__$1;\n(statearr_25888_27693[(2)] \x3d null);\n\n(statearr_25888_27693[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (4))){\nvar inst_25859 \x3d (state_25880[(7)]);\nvar inst_25859__$1 \x3d (state_25880[(2)]);\nvar inst_25860 \x3d (inst_25859__$1 \x3d\x3d null);\nvar state_25880__$1 \x3d (function (){var statearr_25892 \x3d state_25880;\n(statearr_25892[(7)] \x3d inst_25859__$1);\n\nreturn statearr_25892;\n})();\nif(cljs.core.truth_(inst_25860)){\nvar statearr_25893_27694 \x3d state_25880__$1;\n(statearr_25893_27694[(1)] \x3d (5));\n\n} else {\nvar statearr_25895_27695 \x3d state_25880__$1;\n(statearr_25895_27695[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (6))){\nvar inst_25859 \x3d (state_25880[(7)]);\nvar inst_25864 \x3d (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(inst_25859) : p.call(null, inst_25859));\nvar state_25880__$1 \x3d state_25880;\nif(cljs.core.truth_(inst_25864)){\nvar statearr_25899_27696 \x3d state_25880__$1;\n(statearr_25899_27696[(1)] \x3d (8));\n\n} else {\nvar statearr_25902_27698 \x3d state_25880__$1;\n(statearr_25902_27698[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (3))){\nvar inst_25878 \x3d (state_25880[(2)]);\nvar state_25880__$1 \x3d state_25880;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_25880__$1,inst_25878);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (2))){\nvar state_25880__$1 \x3d state_25880;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_25880__$1,(4),ch);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (11))){\nvar inst_25868 \x3d (state_25880[(2)]);\nvar state_25880__$1 \x3d state_25880;\nvar statearr_25908_27699 \x3d state_25880__$1;\n(statearr_25908_27699[(2)] \x3d inst_25868);\n\n(statearr_25908_27699[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (9))){\nvar state_25880__$1 \x3d state_25880;\nvar statearr_25911_27700 \x3d state_25880__$1;\n(statearr_25911_27700[(2)] \x3d null);\n\n(statearr_25911_27700[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (5))){\nvar inst_25862 \x3d cljs.core.async.close_BANG_(out);\nvar state_25880__$1 \x3d state_25880;\nvar statearr_25914_27705 \x3d state_25880__$1;\n(statearr_25914_27705[(2)] \x3d inst_25862);\n\n(statearr_25914_27705[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (10))){\nvar inst_25872 \x3d (state_25880[(2)]);\nvar state_25880__$1 \x3d (function (){var statearr_25916 \x3d state_25880;\n(statearr_25916[(8)] \x3d inst_25872);\n\nreturn statearr_25916;\n})();\nvar statearr_25917_27706 \x3d state_25880__$1;\n(statearr_25917_27706[(2)] \x3d null);\n\n(statearr_25917_27706[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_25881 \x3d\x3d\x3d (8))){\nvar inst_25859 \x3d (state_25880[(7)]);\nvar state_25880__$1 \x3d state_25880;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_25880__$1,(11),out,inst_25859);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_25919 \x3d [null,null,null,null,null,null,null,null,null];\n(statearr_25919[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_25919[(1)] \x3d (1));\n\nreturn statearr_25919;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_25880){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_25880);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e25920){var ex__21558__auto__ \x3d e25920;\nvar statearr_25921_27714 \x3d state_25880;\n(statearr_25921_27714[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_25880[(4)]))){\nvar statearr_25922_27715 \x3d state_25880;\n(statearr_25922_27715[(1)] \x3d cljs.core.first((state_25880[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27716 \x3d state_25880;\nstate_25880 \x3d G__27716;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_25880){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_25880);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_25924 \x3d f__22635__auto__();\n(statearr_25924[(6)] \x3d c__22634__auto___27691);\n\nreturn statearr_25924;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn out;\n}));\n\n(cljs.core.async.filter_LT_.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.remove_LT_ \x3d (function cljs$core$async$remove_LT_(var_args){\nvar G__25926 \x3d arguments.length;\nswitch (G__25926) {\ncase 2:\nreturn cljs.core.async.remove_LT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.remove_LT_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.remove_LT_.cljs$core$IFn$_invoke$arity$2 \x3d (function (p,ch){\nreturn cljs.core.async.remove_LT_.cljs$core$IFn$_invoke$arity$3(p,ch,null);\n}));\n\n(cljs.core.async.remove_LT_.cljs$core$IFn$_invoke$arity$3 \x3d (function (p,ch,buf_or_n){\nreturn cljs.core.async.filter_LT_.cljs$core$IFn$_invoke$arity$3(cljs.core.complement(p),ch,buf_or_n);\n}));\n\n(cljs.core.async.remove_LT_.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.core.async.mapcat_STAR_ \x3d (function cljs$core$async$mapcat_STAR_(f,in$,out){\nvar c__22634__auto__ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_26003){\nvar state_val_26004 \x3d (state_26003[(1)]);\nif((state_val_26004 \x3d\x3d\x3d (7))){\nvar inst_25998 \x3d (state_26003[(2)]);\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26011_27722 \x3d state_26003__$1;\n(statearr_26011_27722[(2)] \x3d inst_25998);\n\n(statearr_26011_27722[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (20))){\nvar inst_25963 \x3d (state_26003[(7)]);\nvar inst_25977 \x3d (state_26003[(2)]);\nvar inst_25978 \x3d cljs.core.next(inst_25963);\nvar inst_25949 \x3d inst_25978;\nvar inst_25950 \x3d null;\nvar inst_25951 \x3d (0);\nvar inst_25952 \x3d (0);\nvar state_26003__$1 \x3d (function (){var statearr_26012 \x3d state_26003;\n(statearr_26012[(8)] \x3d inst_25951);\n\n(statearr_26012[(9)] \x3d inst_25952);\n\n(statearr_26012[(10)] \x3d inst_25949);\n\n(statearr_26012[(11)] \x3d inst_25977);\n\n(statearr_26012[(12)] \x3d inst_25950);\n\nreturn statearr_26012;\n})();\nvar statearr_26017_27726 \x3d state_26003__$1;\n(statearr_26017_27726[(2)] \x3d null);\n\n(statearr_26017_27726[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (1))){\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26018_27727 \x3d state_26003__$1;\n(statearr_26018_27727[(2)] \x3d null);\n\n(statearr_26018_27727[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (4))){\nvar inst_25938 \x3d (state_26003[(13)]);\nvar inst_25938__$1 \x3d (state_26003[(2)]);\nvar inst_25939 \x3d (inst_25938__$1 \x3d\x3d null);\nvar state_26003__$1 \x3d (function (){var statearr_26027 \x3d state_26003;\n(statearr_26027[(13)] \x3d inst_25938__$1);\n\nreturn statearr_26027;\n})();\nif(cljs.core.truth_(inst_25939)){\nvar statearr_26032_27728 \x3d state_26003__$1;\n(statearr_26032_27728[(1)] \x3d (5));\n\n} else {\nvar statearr_26033_27729 \x3d state_26003__$1;\n(statearr_26033_27729[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (15))){\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26040_27730 \x3d state_26003__$1;\n(statearr_26040_27730[(2)] \x3d null);\n\n(statearr_26040_27730[(1)] \x3d (16));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (21))){\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26041_27731 \x3d state_26003__$1;\n(statearr_26041_27731[(2)] \x3d null);\n\n(statearr_26041_27731[(1)] \x3d (23));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (13))){\nvar inst_25951 \x3d (state_26003[(8)]);\nvar inst_25952 \x3d (state_26003[(9)]);\nvar inst_25949 \x3d (state_26003[(10)]);\nvar inst_25950 \x3d (state_26003[(12)]);\nvar inst_25959 \x3d (state_26003[(2)]);\nvar inst_25960 \x3d (inst_25952 + (1));\nvar tmp26037 \x3d inst_25951;\nvar tmp26038 \x3d inst_25949;\nvar tmp26039 \x3d inst_25950;\nvar inst_25949__$1 \x3d tmp26038;\nvar inst_25950__$1 \x3d tmp26039;\nvar inst_25951__$1 \x3d tmp26037;\nvar inst_25952__$1 \x3d inst_25960;\nvar state_26003__$1 \x3d (function (){var statearr_26042 \x3d state_26003;\n(statearr_26042[(14)] \x3d inst_25959);\n\n(statearr_26042[(8)] \x3d inst_25951__$1);\n\n(statearr_26042[(9)] \x3d inst_25952__$1);\n\n(statearr_26042[(10)] \x3d inst_25949__$1);\n\n(statearr_26042[(12)] \x3d inst_25950__$1);\n\nreturn statearr_26042;\n})();\nvar statearr_26053_27736 \x3d state_26003__$1;\n(statearr_26053_27736[(2)] \x3d null);\n\n(statearr_26053_27736[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (22))){\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26066_27737 \x3d state_26003__$1;\n(statearr_26066_27737[(2)] \x3d null);\n\n(statearr_26066_27737[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (6))){\nvar inst_25938 \x3d (state_26003[(13)]);\nvar inst_25947 \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(inst_25938) : f.call(null, inst_25938));\nvar inst_25948 \x3d cljs.core.seq(inst_25947);\nvar inst_25949 \x3d inst_25948;\nvar inst_25950 \x3d null;\nvar inst_25951 \x3d (0);\nvar inst_25952 \x3d (0);\nvar state_26003__$1 \x3d (function (){var statearr_26079 \x3d state_26003;\n(statearr_26079[(8)] \x3d inst_25951);\n\n(statearr_26079[(9)] \x3d inst_25952);\n\n(statearr_26079[(10)] \x3d inst_25949);\n\n(statearr_26079[(12)] \x3d inst_25950);\n\nreturn statearr_26079;\n})();\nvar statearr_26082_27738 \x3d state_26003__$1;\n(statearr_26082_27738[(2)] \x3d null);\n\n(statearr_26082_27738[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (17))){\nvar inst_25963 \x3d (state_26003[(7)]);\nvar inst_25969 \x3d cljs.core.chunk_first(inst_25963);\nvar inst_25971 \x3d cljs.core.chunk_rest(inst_25963);\nvar inst_25972 \x3d cljs.core.count(inst_25969);\nvar inst_25949 \x3d inst_25971;\nvar inst_25950 \x3d inst_25969;\nvar inst_25951 \x3d inst_25972;\nvar inst_25952 \x3d (0);\nvar state_26003__$1 \x3d (function (){var statearr_26094 \x3d state_26003;\n(statearr_26094[(8)] \x3d inst_25951);\n\n(statearr_26094[(9)] \x3d inst_25952);\n\n(statearr_26094[(10)] \x3d inst_25949);\n\n(statearr_26094[(12)] \x3d inst_25950);\n\nreturn statearr_26094;\n})();\nvar statearr_26100_27740 \x3d state_26003__$1;\n(statearr_26100_27740[(2)] \x3d null);\n\n(statearr_26100_27740[(1)] \x3d (8));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (3))){\nvar inst_26001 \x3d (state_26003[(2)]);\nvar state_26003__$1 \x3d state_26003;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_26003__$1,inst_26001);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (12))){\nvar inst_25986 \x3d (state_26003[(2)]);\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26103_27742 \x3d state_26003__$1;\n(statearr_26103_27742[(2)] \x3d inst_25986);\n\n(statearr_26103_27742[(1)] \x3d (9));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (2))){\nvar state_26003__$1 \x3d state_26003;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_26003__$1,(4),in$);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (23))){\nvar inst_25996 \x3d (state_26003[(2)]);\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26104_27747 \x3d state_26003__$1;\n(statearr_26104_27747[(2)] \x3d inst_25996);\n\n(statearr_26104_27747[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (19))){\nvar inst_25981 \x3d (state_26003[(2)]);\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26105_27749 \x3d state_26003__$1;\n(statearr_26105_27749[(2)] \x3d inst_25981);\n\n(statearr_26105_27749[(1)] \x3d (16));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (11))){\nvar inst_25963 \x3d (state_26003[(7)]);\nvar inst_25949 \x3d (state_26003[(10)]);\nvar inst_25963__$1 \x3d cljs.core.seq(inst_25949);\nvar state_26003__$1 \x3d (function (){var statearr_26110 \x3d state_26003;\n(statearr_26110[(7)] \x3d inst_25963__$1);\n\nreturn statearr_26110;\n})();\nif(inst_25963__$1){\nvar statearr_26115_27750 \x3d state_26003__$1;\n(statearr_26115_27750[(1)] \x3d (14));\n\n} else {\nvar statearr_26117_27751 \x3d state_26003__$1;\n(statearr_26117_27751[(1)] \x3d (15));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (9))){\nvar inst_25988 \x3d (state_26003[(2)]);\nvar inst_25989 \x3d cljs.core.async.impl.protocols.closed_QMARK_(out);\nvar state_26003__$1 \x3d (function (){var statearr_26123 \x3d state_26003;\n(statearr_26123[(15)] \x3d inst_25988);\n\nreturn statearr_26123;\n})();\nif(cljs.core.truth_(inst_25989)){\nvar statearr_26124_27752 \x3d state_26003__$1;\n(statearr_26124_27752[(1)] \x3d (21));\n\n} else {\nvar statearr_26126_27753 \x3d state_26003__$1;\n(statearr_26126_27753[(1)] \x3d (22));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (5))){\nvar inst_25941 \x3d cljs.core.async.close_BANG_(out);\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26127_27754 \x3d state_26003__$1;\n(statearr_26127_27754[(2)] \x3d inst_25941);\n\n(statearr_26127_27754[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (14))){\nvar inst_25963 \x3d (state_26003[(7)]);\nvar inst_25966 \x3d cljs.core.chunked_seq_QMARK_(inst_25963);\nvar state_26003__$1 \x3d state_26003;\nif(inst_25966){\nvar statearr_26128_27755 \x3d state_26003__$1;\n(statearr_26128_27755[(1)] \x3d (17));\n\n} else {\nvar statearr_26129_27756 \x3d state_26003__$1;\n(statearr_26129_27756[(1)] \x3d (18));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (16))){\nvar inst_25984 \x3d (state_26003[(2)]);\nvar state_26003__$1 \x3d state_26003;\nvar statearr_26130_27757 \x3d state_26003__$1;\n(statearr_26130_27757[(2)] \x3d inst_25984);\n\n(statearr_26130_27757[(1)] \x3d (12));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (10))){\nvar inst_25952 \x3d (state_26003[(9)]);\nvar inst_25950 \x3d (state_26003[(12)]);\nvar inst_25957 \x3d cljs.core._nth(inst_25950,inst_25952);\nvar state_26003__$1 \x3d state_26003;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_26003__$1,(13),out,inst_25957);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (18))){\nvar inst_25963 \x3d (state_26003[(7)]);\nvar inst_25975 \x3d cljs.core.first(inst_25963);\nvar state_26003__$1 \x3d state_26003;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_26003__$1,(20),out,inst_25975);\n} else {\nif((state_val_26004 \x3d\x3d\x3d (8))){\nvar inst_25951 \x3d (state_26003[(8)]);\nvar inst_25952 \x3d (state_26003[(9)]);\nvar inst_25954 \x3d (inst_25952 \x3c inst_25951);\nvar inst_25955 \x3d inst_25954;\nvar state_26003__$1 \x3d state_26003;\nif(cljs.core.truth_(inst_25955)){\nvar statearr_26132_27759 \x3d state_26003__$1;\n(statearr_26132_27759[(1)] \x3d (10));\n\n} else {\nvar statearr_26133_27760 \x3d state_26003__$1;\n(statearr_26133_27760[(1)] \x3d (11));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$mapcat_STAR__$_state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$mapcat_STAR__$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_26134 \x3d [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_26134[(0)] \x3d cljs$core$async$mapcat_STAR__$_state_machine__21555__auto__);\n\n(statearr_26134[(1)] \x3d (1));\n\nreturn statearr_26134;\n});\nvar cljs$core$async$mapcat_STAR__$_state_machine__21555__auto____1 \x3d (function (state_26003){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_26003);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e26140){var ex__21558__auto__ \x3d e26140;\nvar statearr_26141_27764 \x3d state_26003;\n(statearr_26141_27764[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_26003[(4)]))){\nvar statearr_26142_27765 \x3d state_26003;\n(statearr_26142_27765[(1)] \x3d cljs.core.first((state_26003[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27766 \x3d state_26003;\nstate_26003 \x3d G__27766;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$mapcat_STAR__$_state_machine__21555__auto__ \x3d function(state_26003){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$mapcat_STAR__$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$mapcat_STAR__$_state_machine__21555__auto____1.call(this,state_26003);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$mapcat_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$mapcat_STAR__$_state_machine__21555__auto____0;\ncljs$core$async$mapcat_STAR__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$mapcat_STAR__$_state_machine__21555__auto____1;\nreturn cljs$core$async$mapcat_STAR__$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_26149 \x3d f__22635__auto__();\n(statearr_26149[(6)] \x3d c__22634__auto__);\n\nreturn statearr_26149;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\nreturn c__22634__auto__;\n});\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.mapcat_LT_ \x3d (function cljs$core$async$mapcat_LT_(var_args){\nvar G__26157 \x3d arguments.length;\nswitch (G__26157) {\ncase 2:\nreturn cljs.core.async.mapcat_LT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.mapcat_LT_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.mapcat_LT_.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,in$){\nreturn cljs.core.async.mapcat_LT_.cljs$core$IFn$_invoke$arity$3(f,in$,null);\n}));\n\n(cljs.core.async.mapcat_LT_.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,in$,buf_or_n){\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\ncljs.core.async.mapcat_STAR_(f,in$,out);\n\nreturn out;\n}));\n\n(cljs.core.async.mapcat_LT_.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.mapcat_GT_ \x3d (function cljs$core$async$mapcat_GT_(var_args){\nvar G__26170 \x3d arguments.length;\nswitch (G__26170) {\ncase 2:\nreturn cljs.core.async.mapcat_GT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.mapcat_GT_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.mapcat_GT_.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,out){\nreturn cljs.core.async.mapcat_GT_.cljs$core$IFn$_invoke$arity$3(f,out,null);\n}));\n\n(cljs.core.async.mapcat_GT_.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,out,buf_or_n){\nvar in$ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\ncljs.core.async.mapcat_STAR_(f,in$,out);\n\nreturn in$;\n}));\n\n(cljs.core.async.mapcat_GT_.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.unique \x3d (function cljs$core$async$unique(var_args){\nvar G__26183 \x3d arguments.length;\nswitch (G__26183) {\ncase 1:\nreturn cljs.core.async.unique.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.core.async.unique.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.unique.cljs$core$IFn$_invoke$arity$1 \x3d (function (ch){\nreturn cljs.core.async.unique.cljs$core$IFn$_invoke$arity$2(ch,null);\n}));\n\n(cljs.core.async.unique.cljs$core$IFn$_invoke$arity$2 \x3d (function (ch,buf_or_n){\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\nvar c__22634__auto___27773 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_26214){\nvar state_val_26215 \x3d (state_26214[(1)]);\nif((state_val_26215 \x3d\x3d\x3d (7))){\nvar inst_26206 \x3d (state_26214[(2)]);\nvar state_26214__$1 \x3d state_26214;\nvar statearr_26224_27774 \x3d state_26214__$1;\n(statearr_26224_27774[(2)] \x3d inst_26206);\n\n(statearr_26224_27774[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (1))){\nvar inst_26188 \x3d null;\nvar state_26214__$1 \x3d (function (){var statearr_26225 \x3d state_26214;\n(statearr_26225[(7)] \x3d inst_26188);\n\nreturn statearr_26225;\n})();\nvar statearr_26226_27779 \x3d state_26214__$1;\n(statearr_26226_27779[(2)] \x3d null);\n\n(statearr_26226_27779[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (4))){\nvar inst_26191 \x3d (state_26214[(8)]);\nvar inst_26191__$1 \x3d (state_26214[(2)]);\nvar inst_26192 \x3d (inst_26191__$1 \x3d\x3d null);\nvar inst_26193 \x3d cljs.core.not(inst_26192);\nvar state_26214__$1 \x3d (function (){var statearr_26228 \x3d state_26214;\n(statearr_26228[(8)] \x3d inst_26191__$1);\n\nreturn statearr_26228;\n})();\nif(inst_26193){\nvar statearr_26229_27780 \x3d state_26214__$1;\n(statearr_26229_27780[(1)] \x3d (5));\n\n} else {\nvar statearr_26230_27781 \x3d state_26214__$1;\n(statearr_26230_27781[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (6))){\nvar state_26214__$1 \x3d state_26214;\nvar statearr_26231_27782 \x3d state_26214__$1;\n(statearr_26231_27782[(2)] \x3d null);\n\n(statearr_26231_27782[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (3))){\nvar inst_26211 \x3d (state_26214[(2)]);\nvar inst_26212 \x3d cljs.core.async.close_BANG_(out);\nvar state_26214__$1 \x3d (function (){var statearr_26232 \x3d state_26214;\n(statearr_26232[(9)] \x3d inst_26211);\n\nreturn statearr_26232;\n})();\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_26214__$1,inst_26212);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (2))){\nvar state_26214__$1 \x3d state_26214;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_26214__$1,(4),ch);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (11))){\nvar inst_26191 \x3d (state_26214[(8)]);\nvar inst_26200 \x3d (state_26214[(2)]);\nvar inst_26188 \x3d inst_26191;\nvar state_26214__$1 \x3d (function (){var statearr_26234 \x3d state_26214;\n(statearr_26234[(10)] \x3d inst_26200);\n\n(statearr_26234[(7)] \x3d inst_26188);\n\nreturn statearr_26234;\n})();\nvar statearr_26235_27786 \x3d state_26214__$1;\n(statearr_26235_27786[(2)] \x3d null);\n\n(statearr_26235_27786[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (9))){\nvar inst_26191 \x3d (state_26214[(8)]);\nvar state_26214__$1 \x3d state_26214;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_26214__$1,(11),out,inst_26191);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (5))){\nvar inst_26191 \x3d (state_26214[(8)]);\nvar inst_26188 \x3d (state_26214[(7)]);\nvar inst_26195 \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(inst_26191,inst_26188);\nvar state_26214__$1 \x3d state_26214;\nif(inst_26195){\nvar statearr_26238_27787 \x3d state_26214__$1;\n(statearr_26238_27787[(1)] \x3d (8));\n\n} else {\nvar statearr_26239_27788 \x3d state_26214__$1;\n(statearr_26239_27788[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (10))){\nvar inst_26203 \x3d (state_26214[(2)]);\nvar state_26214__$1 \x3d state_26214;\nvar statearr_26241_27790 \x3d state_26214__$1;\n(statearr_26241_27790[(2)] \x3d inst_26203);\n\n(statearr_26241_27790[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26215 \x3d\x3d\x3d (8))){\nvar inst_26188 \x3d (state_26214[(7)]);\nvar tmp26236 \x3d inst_26188;\nvar inst_26188__$1 \x3d tmp26236;\nvar state_26214__$1 \x3d (function (){var statearr_26242 \x3d state_26214;\n(statearr_26242[(7)] \x3d inst_26188__$1);\n\nreturn statearr_26242;\n})();\nvar statearr_26243_27793 \x3d state_26214__$1;\n(statearr_26243_27793[(2)] \x3d null);\n\n(statearr_26243_27793[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_26244 \x3d [null,null,null,null,null,null,null,null,null,null,null];\n(statearr_26244[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_26244[(1)] \x3d (1));\n\nreturn statearr_26244;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_26214){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_26214);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e26246){var ex__21558__auto__ \x3d e26246;\nvar statearr_26247_27794 \x3d state_26214;\n(statearr_26247_27794[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_26214[(4)]))){\nvar statearr_26248_27795 \x3d state_26214;\n(statearr_26248_27795[(1)] \x3d cljs.core.first((state_26214[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27796 \x3d state_26214;\nstate_26214 \x3d G__27796;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_26214){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_26214);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_26250 \x3d f__22635__auto__();\n(statearr_26250[(6)] \x3d c__22634__auto___27773);\n\nreturn statearr_26250;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn out;\n}));\n\n(cljs.core.async.unique.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.partition \x3d (function cljs$core$async$partition(var_args){\nvar G__26255 \x3d arguments.length;\nswitch (G__26255) {\ncase 2:\nreturn cljs.core.async.partition.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.partition.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.partition.cljs$core$IFn$_invoke$arity$2 \x3d (function (n,ch){\nreturn cljs.core.async.partition.cljs$core$IFn$_invoke$arity$3(n,ch,null);\n}));\n\n(cljs.core.async.partition.cljs$core$IFn$_invoke$arity$3 \x3d (function (n,ch,buf_or_n){\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\nvar c__22634__auto___27799 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_26305){\nvar state_val_26306 \x3d (state_26305[(1)]);\nif((state_val_26306 \x3d\x3d\x3d (7))){\nvar inst_26300 \x3d (state_26305[(2)]);\nvar state_26305__$1 \x3d state_26305;\nvar statearr_26309_27804 \x3d state_26305__$1;\n(statearr_26309_27804[(2)] \x3d inst_26300);\n\n(statearr_26309_27804[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (1))){\nvar inst_26265 \x3d (new Array(n));\nvar inst_26266 \x3d inst_26265;\nvar inst_26267 \x3d (0);\nvar state_26305__$1 \x3d (function (){var statearr_26314 \x3d state_26305;\n(statearr_26314[(7)] \x3d inst_26266);\n\n(statearr_26314[(8)] \x3d inst_26267);\n\nreturn statearr_26314;\n})();\nvar statearr_26315_27806 \x3d state_26305__$1;\n(statearr_26315_27806[(2)] \x3d null);\n\n(statearr_26315_27806[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (4))){\nvar inst_26270 \x3d (state_26305[(9)]);\nvar inst_26270__$1 \x3d (state_26305[(2)]);\nvar inst_26271 \x3d (inst_26270__$1 \x3d\x3d null);\nvar inst_26272 \x3d cljs.core.not(inst_26271);\nvar state_26305__$1 \x3d (function (){var statearr_26318 \x3d state_26305;\n(statearr_26318[(9)] \x3d inst_26270__$1);\n\nreturn statearr_26318;\n})();\nif(inst_26272){\nvar statearr_26319_27810 \x3d state_26305__$1;\n(statearr_26319_27810[(1)] \x3d (5));\n\n} else {\nvar statearr_26320_27812 \x3d state_26305__$1;\n(statearr_26320_27812[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (15))){\nvar inst_26294 \x3d (state_26305[(2)]);\nvar state_26305__$1 \x3d state_26305;\nvar statearr_26327_27815 \x3d state_26305__$1;\n(statearr_26327_27815[(2)] \x3d inst_26294);\n\n(statearr_26327_27815[(1)] \x3d (14));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (13))){\nvar state_26305__$1 \x3d state_26305;\nvar statearr_26329_27816 \x3d state_26305__$1;\n(statearr_26329_27816[(2)] \x3d null);\n\n(statearr_26329_27816[(1)] \x3d (14));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (6))){\nvar inst_26267 \x3d (state_26305[(8)]);\nvar inst_26290 \x3d (inst_26267 \x3e (0));\nvar state_26305__$1 \x3d state_26305;\nif(cljs.core.truth_(inst_26290)){\nvar statearr_26330_27819 \x3d state_26305__$1;\n(statearr_26330_27819[(1)] \x3d (12));\n\n} else {\nvar statearr_26331_27820 \x3d state_26305__$1;\n(statearr_26331_27820[(1)] \x3d (13));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (3))){\nvar inst_26302 \x3d (state_26305[(2)]);\nvar state_26305__$1 \x3d state_26305;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_26305__$1,inst_26302);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (12))){\nvar inst_26266 \x3d (state_26305[(7)]);\nvar inst_26292 \x3d cljs.core.vec(inst_26266);\nvar state_26305__$1 \x3d state_26305;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_26305__$1,(15),out,inst_26292);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (2))){\nvar state_26305__$1 \x3d state_26305;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_26305__$1,(4),ch);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (11))){\nvar inst_26282 \x3d (state_26305[(2)]);\nvar inst_26284 \x3d (new Array(n));\nvar inst_26266 \x3d inst_26284;\nvar inst_26267 \x3d (0);\nvar state_26305__$1 \x3d (function (){var statearr_26334 \x3d state_26305;\n(statearr_26334[(10)] \x3d inst_26282);\n\n(statearr_26334[(7)] \x3d inst_26266);\n\n(statearr_26334[(8)] \x3d inst_26267);\n\nreturn statearr_26334;\n})();\nvar statearr_26338_27821 \x3d state_26305__$1;\n(statearr_26338_27821[(2)] \x3d null);\n\n(statearr_26338_27821[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (9))){\nvar inst_26266 \x3d (state_26305[(7)]);\nvar inst_26280 \x3d cljs.core.vec(inst_26266);\nvar state_26305__$1 \x3d state_26305;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_26305__$1,(11),out,inst_26280);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (5))){\nvar inst_26275 \x3d (state_26305[(11)]);\nvar inst_26270 \x3d (state_26305[(9)]);\nvar inst_26266 \x3d (state_26305[(7)]);\nvar inst_26267 \x3d (state_26305[(8)]);\nvar inst_26274 \x3d (inst_26266[inst_26267] \x3d inst_26270);\nvar inst_26275__$1 \x3d (inst_26267 + (1));\nvar inst_26276 \x3d (inst_26275__$1 \x3c n);\nvar state_26305__$1 \x3d (function (){var statearr_26342 \x3d state_26305;\n(statearr_26342[(11)] \x3d inst_26275__$1);\n\n(statearr_26342[(12)] \x3d inst_26274);\n\nreturn statearr_26342;\n})();\nif(cljs.core.truth_(inst_26276)){\nvar statearr_26343_27827 \x3d state_26305__$1;\n(statearr_26343_27827[(1)] \x3d (8));\n\n} else {\nvar statearr_26344_27828 \x3d state_26305__$1;\n(statearr_26344_27828[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (14))){\nvar inst_26297 \x3d (state_26305[(2)]);\nvar inst_26298 \x3d cljs.core.async.close_BANG_(out);\nvar state_26305__$1 \x3d (function (){var statearr_26347 \x3d state_26305;\n(statearr_26347[(13)] \x3d inst_26297);\n\nreturn statearr_26347;\n})();\nvar statearr_26349_27829 \x3d state_26305__$1;\n(statearr_26349_27829[(2)] \x3d inst_26298);\n\n(statearr_26349_27829[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (10))){\nvar inst_26287 \x3d (state_26305[(2)]);\nvar state_26305__$1 \x3d state_26305;\nvar statearr_26350_27830 \x3d state_26305__$1;\n(statearr_26350_27830[(2)] \x3d inst_26287);\n\n(statearr_26350_27830[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26306 \x3d\x3d\x3d (8))){\nvar inst_26275 \x3d (state_26305[(11)]);\nvar inst_26266 \x3d (state_26305[(7)]);\nvar tmp26345 \x3d inst_26266;\nvar inst_26266__$1 \x3d tmp26345;\nvar inst_26267 \x3d inst_26275;\nvar state_26305__$1 \x3d (function (){var statearr_26351 \x3d state_26305;\n(statearr_26351[(7)] \x3d inst_26266__$1);\n\n(statearr_26351[(8)] \x3d inst_26267);\n\nreturn statearr_26351;\n})();\nvar statearr_26352_27831 \x3d state_26305__$1;\n(statearr_26352_27831[(2)] \x3d null);\n\n(statearr_26352_27831[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_26360 \x3d [null,null,null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_26360[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_26360[(1)] \x3d (1));\n\nreturn statearr_26360;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_26305){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_26305);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e26382){var ex__21558__auto__ \x3d e26382;\nvar statearr_26386_27837 \x3d state_26305;\n(statearr_26386_27837[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_26305[(4)]))){\nvar statearr_26387_27838 \x3d state_26305;\n(statearr_26387_27838[(1)] \x3d cljs.core.first((state_26305[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27839 \x3d state_26305;\nstate_26305 \x3d G__27839;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_26305){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_26305);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_26395 \x3d f__22635__auto__();\n(statearr_26395[(6)] \x3d c__22634__auto___27799);\n\nreturn statearr_26395;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn out;\n}));\n\n(cljs.core.async.partition.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Deprecated - this function will be removed. Use transducer instead\n */\ncljs.core.async.partition_by \x3d (function cljs$core$async$partition_by(var_args){\nvar G__26420 \x3d arguments.length;\nswitch (G__26420) {\ncase 2:\nreturn cljs.core.async.partition_by.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.core.async.partition_by.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.core.async.partition_by.cljs$core$IFn$_invoke$arity$2 \x3d (function (f,ch){\nreturn cljs.core.async.partition_by.cljs$core$IFn$_invoke$arity$3(f,ch,null);\n}));\n\n(cljs.core.async.partition_by.cljs$core$IFn$_invoke$arity$3 \x3d (function (f,ch,buf_or_n){\nvar out \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1(buf_or_n);\nvar c__22634__auto___27842 \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_26535){\nvar state_val_26536 \x3d (state_26535[(1)]);\nif((state_val_26536 \x3d\x3d\x3d (7))){\nvar inst_26527 \x3d (state_26535[(2)]);\nvar state_26535__$1 \x3d state_26535;\nvar statearr_26542_27844 \x3d state_26535__$1;\n(statearr_26542_27844[(2)] \x3d inst_26527);\n\n(statearr_26542_27844[(1)] \x3d (3));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (1))){\nvar inst_26454 \x3d [];\nvar inst_26455 \x3d inst_26454;\nvar inst_26456 \x3d new cljs.core.Keyword(\x22cljs.core.async\x22,\x22nothing\x22,\x22cljs.core.async/nothing\x22,-69252123);\nvar state_26535__$1 \x3d (function (){var statearr_26544 \x3d state_26535;\n(statearr_26544[(7)] \x3d inst_26456);\n\n(statearr_26544[(8)] \x3d inst_26455);\n\nreturn statearr_26544;\n})();\nvar statearr_26545_27845 \x3d state_26535__$1;\n(statearr_26545_27845[(2)] \x3d null);\n\n(statearr_26545_27845[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (4))){\nvar inst_26464 \x3d (state_26535[(9)]);\nvar inst_26464__$1 \x3d (state_26535[(2)]);\nvar inst_26466 \x3d (inst_26464__$1 \x3d\x3d null);\nvar inst_26468 \x3d cljs.core.not(inst_26466);\nvar state_26535__$1 \x3d (function (){var statearr_26547 \x3d state_26535;\n(statearr_26547[(9)] \x3d inst_26464__$1);\n\nreturn statearr_26547;\n})();\nif(inst_26468){\nvar statearr_26548_27846 \x3d state_26535__$1;\n(statearr_26548_27846[(1)] \x3d (5));\n\n} else {\nvar statearr_26549_27847 \x3d state_26535__$1;\n(statearr_26549_27847[(1)] \x3d (6));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (15))){\nvar inst_26455 \x3d (state_26535[(8)]);\nvar inst_26518 \x3d cljs.core.vec(inst_26455);\nvar state_26535__$1 \x3d state_26535;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_26535__$1,(18),out,inst_26518);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (13))){\nvar inst_26511 \x3d (state_26535[(2)]);\nvar state_26535__$1 \x3d state_26535;\nvar statearr_26555_27850 \x3d state_26535__$1;\n(statearr_26555_27850[(2)] \x3d inst_26511);\n\n(statearr_26555_27850[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (6))){\nvar inst_26455 \x3d (state_26535[(8)]);\nvar inst_26513 \x3d inst_26455.length;\nvar inst_26514 \x3d (inst_26513 \x3e (0));\nvar state_26535__$1 \x3d state_26535;\nif(cljs.core.truth_(inst_26514)){\nvar statearr_26560_27851 \x3d state_26535__$1;\n(statearr_26560_27851[(1)] \x3d (15));\n\n} else {\nvar statearr_26563_27852 \x3d state_26535__$1;\n(statearr_26563_27852[(1)] \x3d (16));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (17))){\nvar inst_26524 \x3d (state_26535[(2)]);\nvar inst_26525 \x3d cljs.core.async.close_BANG_(out);\nvar state_26535__$1 \x3d (function (){var statearr_26566 \x3d state_26535;\n(statearr_26566[(10)] \x3d inst_26524);\n\nreturn statearr_26566;\n})();\nvar statearr_26569_27853 \x3d state_26535__$1;\n(statearr_26569_27853[(2)] \x3d inst_26525);\n\n(statearr_26569_27853[(1)] \x3d (7));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (3))){\nvar inst_26529 \x3d (state_26535[(2)]);\nvar state_26535__$1 \x3d state_26535;\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_26535__$1,inst_26529);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (12))){\nvar inst_26455 \x3d (state_26535[(8)]);\nvar inst_26498 \x3d cljs.core.vec(inst_26455);\nvar state_26535__$1 \x3d state_26535;\nreturn cljs.core.async.impl.ioc_helpers.put_BANG_(state_26535__$1,(14),out,inst_26498);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (2))){\nvar state_26535__$1 \x3d state_26535;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_26535__$1,(4),ch);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (11))){\nvar inst_26464 \x3d (state_26535[(9)]);\nvar inst_26455 \x3d (state_26535[(8)]);\nvar inst_26474 \x3d (state_26535[(11)]);\nvar inst_26490 \x3d inst_26455.push(inst_26464);\nvar tmp26572 \x3d inst_26455;\nvar inst_26455__$1 \x3d tmp26572;\nvar inst_26456 \x3d inst_26474;\nvar state_26535__$1 \x3d (function (){var statearr_26585 \x3d state_26535;\n(statearr_26585[(12)] \x3d inst_26490);\n\n(statearr_26585[(7)] \x3d inst_26456);\n\n(statearr_26585[(8)] \x3d inst_26455__$1);\n\nreturn statearr_26585;\n})();\nvar statearr_26587_27855 \x3d state_26535__$1;\n(statearr_26587_27855[(2)] \x3d null);\n\n(statearr_26587_27855[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (9))){\nvar inst_26456 \x3d (state_26535[(7)]);\nvar inst_26486 \x3d cljs.core.keyword_identical_QMARK_(inst_26456,new cljs.core.Keyword(\x22cljs.core.async\x22,\x22nothing\x22,\x22cljs.core.async/nothing\x22,-69252123));\nvar state_26535__$1 \x3d state_26535;\nvar statearr_26595_27860 \x3d state_26535__$1;\n(statearr_26595_27860[(2)] \x3d inst_26486);\n\n(statearr_26595_27860[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (5))){\nvar inst_26479 \x3d (state_26535[(13)]);\nvar inst_26464 \x3d (state_26535[(9)]);\nvar inst_26456 \x3d (state_26535[(7)]);\nvar inst_26474 \x3d (state_26535[(11)]);\nvar inst_26474__$1 \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(inst_26464) : f.call(null, inst_26464));\nvar inst_26479__$1 \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(inst_26474__$1,inst_26456);\nvar state_26535__$1 \x3d (function (){var statearr_26601 \x3d state_26535;\n(statearr_26601[(13)] \x3d inst_26479__$1);\n\n(statearr_26601[(11)] \x3d inst_26474__$1);\n\nreturn statearr_26601;\n})();\nif(inst_26479__$1){\nvar statearr_26604_27863 \x3d state_26535__$1;\n(statearr_26604_27863[(1)] \x3d (8));\n\n} else {\nvar statearr_26606_27864 \x3d state_26535__$1;\n(statearr_26606_27864[(1)] \x3d (9));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (14))){\nvar inst_26464 \x3d (state_26535[(9)]);\nvar inst_26474 \x3d (state_26535[(11)]);\nvar inst_26500 \x3d (state_26535[(2)]);\nvar inst_26506 \x3d [];\nvar inst_26507 \x3d inst_26506.push(inst_26464);\nvar inst_26455 \x3d inst_26506;\nvar inst_26456 \x3d inst_26474;\nvar state_26535__$1 \x3d (function (){var statearr_26610 \x3d state_26535;\n(statearr_26610[(14)] \x3d inst_26507);\n\n(statearr_26610[(15)] \x3d inst_26500);\n\n(statearr_26610[(7)] \x3d inst_26456);\n\n(statearr_26610[(8)] \x3d inst_26455);\n\nreturn statearr_26610;\n})();\nvar statearr_26621_27865 \x3d state_26535__$1;\n(statearr_26621_27865[(2)] \x3d null);\n\n(statearr_26621_27865[(1)] \x3d (2));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (16))){\nvar state_26535__$1 \x3d state_26535;\nvar statearr_26635_27870 \x3d state_26535__$1;\n(statearr_26635_27870[(2)] \x3d null);\n\n(statearr_26635_27870[(1)] \x3d (17));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (10))){\nvar inst_26488 \x3d (state_26535[(2)]);\nvar state_26535__$1 \x3d state_26535;\nif(cljs.core.truth_(inst_26488)){\nvar statearr_26644_27873 \x3d state_26535__$1;\n(statearr_26644_27873[(1)] \x3d (11));\n\n} else {\nvar statearr_26646_27874 \x3d state_26535__$1;\n(statearr_26646_27874[(1)] \x3d (12));\n\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (18))){\nvar inst_26520 \x3d (state_26535[(2)]);\nvar state_26535__$1 \x3d state_26535;\nvar statearr_26648_27875 \x3d state_26535__$1;\n(statearr_26648_27875[(2)] \x3d inst_26520);\n\n(statearr_26648_27875[(1)] \x3d (17));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nif((state_val_26536 \x3d\x3d\x3d (8))){\nvar inst_26479 \x3d (state_26535[(13)]);\nvar state_26535__$1 \x3d state_26535;\nvar statearr_26651_27876 \x3d state_26535__$1;\n(statearr_26651_27876[(2)] \x3d inst_26479);\n\n(statearr_26651_27876[(1)] \x3d (10));\n\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n} else {\nreturn null;\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n});\nreturn (function() {\nvar cljs$core$async$state_machine__21555__auto__ \x3d null;\nvar cljs$core$async$state_machine__21555__auto____0 \x3d (function (){\nvar statearr_26654 \x3d [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null];\n(statearr_26654[(0)] \x3d cljs$core$async$state_machine__21555__auto__);\n\n(statearr_26654[(1)] \x3d (1));\n\nreturn statearr_26654;\n});\nvar cljs$core$async$state_machine__21555__auto____1 \x3d (function (state_26535){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_26535);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e26656){var ex__21558__auto__ \x3d e26656;\nvar statearr_26657_27877 \x3d state_26535;\n(statearr_26657_27877[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_26535[(4)]))){\nvar statearr_26658_27878 \x3d state_26535;\n(statearr_26658_27878[(1)] \x3d cljs.core.first((state_26535[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__27879 \x3d state_26535;\nstate_26535 \x3d G__27879;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\ncljs$core$async$state_machine__21555__auto__ \x3d function(state_26535){\nswitch(arguments.length){\ncase 0:\nreturn cljs$core$async$state_machine__21555__auto____0.call(this);\ncase 1:\nreturn cljs$core$async$state_machine__21555__auto____1.call(this,state_26535);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d cljs$core$async$state_machine__21555__auto____0;\ncljs$core$async$state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d cljs$core$async$state_machine__21555__auto____1;\nreturn cljs$core$async$state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_26673 \x3d f__22635__auto__();\n(statearr_26673[(6)] \x3d c__22634__auto___27842);\n\nreturn statearr_26673;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\n\nreturn out;\n}));\n\n(cljs.core.async.partition_by.cljs$lang$maxFixedArity \x3d 3);\n\n");
SHADOW_ENV.evalLoad("clojure.data.js", true, "goog.provide(\x27clojure.data\x27);\n/**\n * Internal helper for diff.\n */\nclojure.data.atom_diff \x3d (function clojure$data$atom_diff(a,b){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a,b)){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [a,b,null], null);\n}\n});\n/**\n * Convert an associative-by-numeric-index collection into\n * an equivalent vector, with nil for any missing keys\n */\nclojure.data.vectorize \x3d (function clojure$data$vectorize(m){\nif(cljs.core.seq(m)){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (result,p__21724){\nvar vec__21726 \x3d p__21724;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21726,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21726,(1),null);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(result,k,v);\n}),cljs.core.vec(cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.max,cljs.core.keys(m)),null)),m);\n} else {\nreturn null;\n}\n});\n/**\n * Diff associative things a and b, comparing only the key k.\n */\nclojure.data.diff_associative_key \x3d (function clojure$data$diff_associative_key(a,b,k){\nvar va \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(a,k);\nvar vb \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(b,k);\nvar vec__21734 \x3d clojure.data.diff(va,vb);\nvar a_STAR_ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21734,(0),null);\nvar b_STAR_ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21734,(1),null);\nvar ab \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21734,(2),null);\nvar in_a \x3d cljs.core.contains_QMARK_(a,k);\nvar in_b \x3d cljs.core.contains_QMARK_(b,k);\nvar same \x3d ((in_a) \x26\x26 (((in_b) \x26\x26 ((((!((ab \x3d\x3d null)))) || ((((va \x3d\x3d null)) \x26\x26 ((vb \x3d\x3d null)))))))));\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [((((in_a) \x26\x26 ((((!((a_STAR_ \x3d\x3d null)))) || ((!(same)))))))?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,a_STAR_]):null),((((in_b) \x26\x26 ((((!((b_STAR_ \x3d\x3d null)))) || ((!(same)))))))?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,b_STAR_]):null),((same)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,ab]):null)], null);\n});\n/**\n * Diff associative things a and b, comparing only keys in ks (if supplied).\n */\nclojure.data.diff_associative \x3d (function clojure$data$diff_associative(var_args){\nvar G__21773 \x3d arguments.length;\nswitch (G__21773) {\ncase 2:\nreturn clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2 \x3d (function (a,b){\nreturn clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3(a,b,clojure.set.union.cljs$core$IFn$_invoke$arity$2(cljs.core.keys(a),cljs.core.keys(b)));\n}));\n\n(clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3 \x3d (function (a,b,ks){\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (diff1,diff2){\nreturn cljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$3(cljs.core.merge,diff1,diff2));\n}),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,null], null),cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.partial.cljs$core$IFn$_invoke$arity$3(clojure.data.diff_associative_key,a,b),ks));\n}));\n\n(clojure.data.diff_associative.cljs$lang$maxFixedArity \x3d 3);\n\nclojure.data.diff_sequential \x3d (function clojure$data$diff_sequential(a,b){\nreturn cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2(clojure.data.vectorize,clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3(((cljs.core.vector_QMARK_(a))?a:cljs.core.vec(a)),((cljs.core.vector_QMARK_(b))?b:cljs.core.vec(b)),cljs.core.range.cljs$core$IFn$_invoke$arity$1((function (){var x__5087__auto__ \x3d cljs.core.count(a);\nvar y__5088__auto__ \x3d cljs.core.count(b);\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})()))));\n});\nclojure.data.diff_set \x3d (function clojure$data$diff_set(a,b){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.not_empty(clojure.set.difference.cljs$core$IFn$_invoke$arity$2(a,b)),cljs.core.not_empty(clojure.set.difference.cljs$core$IFn$_invoke$arity$2(b,a)),cljs.core.not_empty(clojure.set.intersection.cljs$core$IFn$_invoke$arity$2(a,b))], null);\n});\n\n/**\n * Implementation detail. Subject to change.\n * @interface\n */\nclojure.data.EqualityPartition \x3d function(){};\n\nvar clojure$data$EqualityPartition$equality_partition$dyn_21967 \x3d (function (x){\nvar x__5350__auto__ \x3d (((x \x3d\x3d null))?null:x);\nvar m__5351__auto__ \x3d (clojure.data.equality_partition[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5351__auto__.call(null, x));\n} else {\nvar m__5349__auto__ \x3d (clojure.data.equality_partition[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5349__auto__.call(null, x));\n} else {\nthrow cljs.core.missing_protocol(\x22EqualityPartition.equality-partition\x22,x);\n}\n}\n});\n/**\n * Implementation detail. Subject to change.\n */\nclojure.data.equality_partition \x3d (function clojure$data$equality_partition(x){\nif((((!((x \x3d\x3d null)))) \x26\x26 ((!((x.clojure$data$EqualityPartition$equality_partition$arity$1 \x3d\x3d null)))))){\nreturn x.clojure$data$EqualityPartition$equality_partition$arity$1(x);\n} else {\nreturn clojure$data$EqualityPartition$equality_partition$dyn_21967(x);\n}\n});\n\n\n/**\n * Implementation detail. Subject to change.\n * @interface\n */\nclojure.data.Diff \x3d function(){};\n\nvar clojure$data$Diff$diff_similar$dyn_21976 \x3d (function (a,b){\nvar x__5350__auto__ \x3d (((a \x3d\x3d null))?null:a);\nvar m__5351__auto__ \x3d (clojure.data.diff_similar[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(a,b) : m__5351__auto__.call(null, a,b));\n} else {\nvar m__5349__auto__ \x3d (clojure.data.diff_similar[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(a,b) : m__5349__auto__.call(null, a,b));\n} else {\nthrow cljs.core.missing_protocol(\x22Diff.diff-similar\x22,a);\n}\n}\n});\n/**\n * Implementation detail. Subject to change.\n */\nclojure.data.diff_similar \x3d (function clojure$data$diff_similar(a,b){\nif((((!((a \x3d\x3d null)))) \x26\x26 ((!((a.clojure$data$Diff$diff_similar$arity$2 \x3d\x3d null)))))){\nreturn a.clojure$data$Diff$diff_similar$arity$2(a,b);\n} else {\nreturn clojure$data$Diff$diff_similar$dyn_21976(a,b);\n}\n});\n\n(clojure.data.EqualityPartition[\x22null\x22] \x3d true);\n\n(clojure.data.equality_partition[\x22null\x22] \x3d (function (x){\nreturn new cljs.core.Keyword(null,\x22atom\x22,\x22atom\x22,-397043653);\n}));\n\n(clojure.data.EqualityPartition[\x22string\x22] \x3d true);\n\n(clojure.data.equality_partition[\x22string\x22] \x3d (function (x){\nreturn new cljs.core.Keyword(null,\x22atom\x22,\x22atom\x22,-397043653);\n}));\n\n(clojure.data.EqualityPartition[\x22number\x22] \x3d true);\n\n(clojure.data.equality_partition[\x22number\x22] \x3d (function (x){\nreturn new cljs.core.Keyword(null,\x22atom\x22,\x22atom\x22,-397043653);\n}));\n\n(clojure.data.EqualityPartition[\x22array\x22] \x3d true);\n\n(clojure.data.equality_partition[\x22array\x22] \x3d (function (x){\nreturn new cljs.core.Keyword(null,\x22sequential\x22,\x22sequential\x22,-1082983960);\n}));\n\n(clojure.data.EqualityPartition[\x22function\x22] \x3d true);\n\n(clojure.data.equality_partition[\x22function\x22] \x3d (function (x){\nreturn new cljs.core.Keyword(null,\x22atom\x22,\x22atom\x22,-397043653);\n}));\n\n(clojure.data.EqualityPartition[\x22boolean\x22] \x3d true);\n\n(clojure.data.equality_partition[\x22boolean\x22] \x3d (function (x){\nreturn new cljs.core.Keyword(null,\x22atom\x22,\x22atom\x22,-397043653);\n}));\n\n(clojure.data.EqualityPartition[\x22_\x22] \x3d true);\n\n(clojure.data.equality_partition[\x22_\x22] \x3d (function (x){\nif((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition0$ \x26 (1024))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IMap$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x))){\nreturn new cljs.core.Keyword(null,\x22map\x22,\x22map\x22,1371690461);\n} else {\nif((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition0$ \x26 (4096))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$ISet$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x))){\nreturn new cljs.core.Keyword(null,\x22set\x22,\x22set\x22,304602554);\n} else {\nif((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition0$ \x26 (16777216))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$ISequential$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x))){\nreturn new cljs.core.Keyword(null,\x22sequential\x22,\x22sequential\x22,-1082983960);\n} else {\nreturn new cljs.core.Keyword(null,\x22atom\x22,\x22atom\x22,-397043653);\n\n}\n}\n}\n}));\n(clojure.data.Diff[\x22null\x22] \x3d true);\n\n(clojure.data.diff_similar[\x22null\x22] \x3d (function (a,b){\nreturn clojure.data.atom_diff(a,b);\n}));\n\n(clojure.data.Diff[\x22string\x22] \x3d true);\n\n(clojure.data.diff_similar[\x22string\x22] \x3d (function (a,b){\nreturn clojure.data.atom_diff(a,b);\n}));\n\n(clojure.data.Diff[\x22number\x22] \x3d true);\n\n(clojure.data.diff_similar[\x22number\x22] \x3d (function (a,b){\nreturn clojure.data.atom_diff(a,b);\n}));\n\n(clojure.data.Diff[\x22array\x22] \x3d true);\n\n(clojure.data.diff_similar[\x22array\x22] \x3d (function (a,b){\nreturn clojure.data.diff_sequential(a,b);\n}));\n\n(clojure.data.Diff[\x22function\x22] \x3d true);\n\n(clojure.data.diff_similar[\x22function\x22] \x3d (function (a,b){\nreturn clojure.data.atom_diff(a,b);\n}));\n\n(clojure.data.Diff[\x22boolean\x22] \x3d true);\n\n(clojure.data.diff_similar[\x22boolean\x22] \x3d (function (a,b){\nreturn clojure.data.atom_diff(a,b);\n}));\n\n(clojure.data.Diff[\x22_\x22] \x3d true);\n\n(clojure.data.diff_similar[\x22_\x22] \x3d (function (a,b){\nvar fexpr__21888 \x3d (function (){var G__21890 \x3d clojure.data.equality_partition(a);\nvar G__21890__$1 \x3d (((G__21890 instanceof cljs.core.Keyword))?G__21890.fqn:null);\nswitch (G__21890__$1) {\ncase \x22atom\x22:\nreturn clojure.data.atom_diff;\n\nbreak;\ncase \x22set\x22:\nreturn clojure.data.diff_set;\n\nbreak;\ncase \x22sequential\x22:\nreturn clojure.data.diff_sequential;\n\nbreak;\ncase \x22map\x22:\nreturn clojure.data.diff_associative;\n\nbreak;\ndefault:\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__21890__$1)].join(\x27\x27)));\n\n}\n})();\nreturn (fexpr__21888.cljs$core$IFn$_invoke$arity$2 ? fexpr__21888.cljs$core$IFn$_invoke$arity$2(a,b) : fexpr__21888.call(null, a,b));\n}));\n/**\n * Recursively compares a and b, returning a tuple of\n *   [things-only-in-a things-only-in-b things-in-both].\n *   Comparison rules:\n * \n *   * For equal a and b, return [nil nil a].\n *   * Maps are subdiffed where keys match and values differ.\n *   * Sets are never subdiffed.\n *   * All sequential things are treated as associative collections\n *  by their indexes, with results returned as vectors.\n *   * Everything else (including strings!) is treated as\n *  an atom and compared for equality.\n */\nclojure.data.diff \x3d (function clojure$data$diff(a,b){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a,b)){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(clojure.data.equality_partition(a),clojure.data.equality_partition(b))){\nreturn clojure.data.diff_similar(a,b);\n} else {\nreturn clojure.data.atom_diff(a,b);\n}\n}\n});\n");
SHADOW_ENV.evalLoad("shadow.util.js", true, "goog.provide(\x27shadow.util\x27);\nshadow.util.console_friendly \x3d (function shadow$util$console_friendly(a){\nif((a \x3d\x3d null)){\nreturn \x22nil\x22;\n} else {\nif((a instanceof cljs.core.Keyword)){\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(a);\n} else {\nif(typeof a \x3d\x3d\x3d \x27string\x27){\nreturn a;\n} else {\nif(typeof a \x3d\x3d\x3d \x27number\x27){\nreturn a;\n} else {\nif((((!((a \x3d\x3d null))))?(((((a.cljs$lang$protocol_mask$partition0$ \x26 (2147483648))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d a.cljs$core$IPrintWithWriter$))))?true:(((!a.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IPrintWithWriter,a):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IPrintWithWriter,a))){\nreturn cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([a], 0));\n} else {\nreturn a;\n\n}\n}\n}\n}\n}\n});\nshadow.util.console_QMARK_ \x3d (typeof console !\x3d\x3d \x27undefined\x27);\nshadow.util.log \x3d (function shadow$util$log(var_args){\nvar G__19796 \x3d arguments.length;\nswitch (G__19796) {\ncase 1:\nreturn shadow.util.log.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.util.log.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn shadow.util.log.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.util.log.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn shadow.util.log.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn shadow.util.log.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nvar args_arr__5751__auto__ \x3d [];\nvar len__5726__auto___19890 \x3d arguments.length;\nvar i__5727__auto___19891 \x3d (0);\nwhile(true){\nif((i__5727__auto___19891 \x3c len__5726__auto___19890)){\nargs_arr__5751__auto__.push((arguments[i__5727__auto___19891]));\n\nvar G__19893 \x3d (i__5727__auto___19891 + (1));\ni__5727__auto___19891 \x3d G__19893;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5752__auto__ \x3d ((((6) \x3c args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((6)),(0),null)):null);\nreturn shadow.util.log.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__5752__auto__);\n\n}\n});\n\n(shadow.util.log.cljs$core$IFn$_invoke$arity$1 \x3d (function (a1){\nif(shadow.util.console_QMARK_){\nreturn console.log(shadow.util.console_friendly(a1));\n} else {\nreturn null;\n}\n}));\n\n(shadow.util.log.cljs$core$IFn$_invoke$arity$2 \x3d (function (a1,a2){\nif(shadow.util.console_QMARK_){\nreturn console.log(shadow.util.console_friendly(a1),shadow.util.console_friendly(a2));\n} else {\nreturn null;\n}\n}));\n\n(shadow.util.log.cljs$core$IFn$_invoke$arity$3 \x3d (function (a1,a2,a3){\nif(shadow.util.console_QMARK_){\nreturn console.log(shadow.util.console_friendly(a1),shadow.util.console_friendly(a2),shadow.util.console_friendly(a3));\n} else {\nreturn null;\n}\n}));\n\n(shadow.util.log.cljs$core$IFn$_invoke$arity$4 \x3d (function (a1,a2,a3,a4){\nif(shadow.util.console_QMARK_){\nreturn console.log(shadow.util.console_friendly(a1),shadow.util.console_friendly(a2),shadow.util.console_friendly(a3),shadow.util.console_friendly(a4));\n} else {\nreturn null;\n}\n}));\n\n(shadow.util.log.cljs$core$IFn$_invoke$arity$5 \x3d (function (a1,a2,a3,a4,a5){\nif(shadow.util.console_QMARK_){\nreturn console.log(shadow.util.console_friendly(a1),shadow.util.console_friendly(a2),shadow.util.console_friendly(a3),shadow.util.console_friendly(a4),shadow.util.console_friendly(a5));\n} else {\nreturn null;\n}\n}));\n\n(shadow.util.log.cljs$core$IFn$_invoke$arity$6 \x3d (function (a1,a2,a3,a4,a5,a6){\nif(shadow.util.console_QMARK_){\nreturn console.log(shadow.util.console_friendly(a1),shadow.util.console_friendly(a2),shadow.util.console_friendly(a3),shadow.util.console_friendly(a4),shadow.util.console_friendly(a5),shadow.util.console_friendly(a6));\n} else {\nreturn null;\n}\n}));\n\n(shadow.util.log.cljs$core$IFn$_invoke$arity$variadic \x3d (function (a1,a2,a3,a4,a5,a6,more){\nif(shadow.util.console_QMARK_){\nreturn console.log(shadow.util.console_friendly(a1),shadow.util.console_friendly(a2),shadow.util.console_friendly(a3),shadow.util.console_friendly(a4),shadow.util.console_friendly(a5),shadow.util.console_friendly(a6),\x22more:\x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([more], 0)));\n} else {\nreturn null;\n}\n}));\n\n/** @this {Function} */\n(shadow.util.log.cljs$lang$applyTo \x3d (function (seq19789){\nvar G__19790 \x3d cljs.core.first(seq19789);\nvar seq19789__$1 \x3d cljs.core.next(seq19789);\nvar G__19791 \x3d cljs.core.first(seq19789__$1);\nvar seq19789__$2 \x3d cljs.core.next(seq19789__$1);\nvar G__19792 \x3d cljs.core.first(seq19789__$2);\nvar seq19789__$3 \x3d cljs.core.next(seq19789__$2);\nvar G__19793 \x3d cljs.core.first(seq19789__$3);\nvar seq19789__$4 \x3d cljs.core.next(seq19789__$3);\nvar G__19794 \x3d cljs.core.first(seq19789__$4);\nvar seq19789__$5 \x3d cljs.core.next(seq19789__$4);\nvar G__19795 \x3d cljs.core.first(seq19789__$5);\nvar seq19789__$6 \x3d cljs.core.next(seq19789__$5);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19790,G__19791,G__19792,G__19793,G__19794,G__19795,seq19789__$6);\n}));\n\n(shadow.util.log.cljs$lang$maxFixedArity \x3d (6));\n\nshadow.util.remove_from_vector \x3d (function shadow$util$remove_from_vector(coll,key){\nreturn cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (v,p__19824){\nvar vec__19826 \x3d p__19824;\nvar idx \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19826,(0),null);\nvar item \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__19826,(1),null);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(idx,key)){\nreturn v;\n} else {\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(v,item);\n}\n}),cljs.core.transient$(cljs.core.PersistentVector.EMPTY),cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2(cljs.core.vector,coll)));\n});\nshadow.util.remove_item_from_coll \x3d (function shadow$util$remove_item_from_coll(coll,key,value){\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (16384))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IVector$))))?true:(((!coll.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IVector,coll):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IVector,coll))){\nreturn shadow.util.remove_from_vector(coll,key);\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (1024))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$IMap$))))?true:(((!coll.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IMap,coll):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IMap,coll))){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(coll,key);\n} else {\nif((((!((coll \x3d\x3d null))))?(((((coll.cljs$lang$protocol_mask$partition0$ \x26 (4096))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d coll.cljs$core$ISet$))))?true:(((!coll.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISet,coll):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISet,coll))){\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$2(coll,value);\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22unknown coll type\x22,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22coll\x22,\x22coll\x22,1647737163),coll,new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),key,new cljs.core.Keyword(null,\x22value\x22,\x22value\x22,305978217),value], null));\n\n}\n}\n}\n});\n");
SHADOW_ENV.evalLoad("shadow.object.js", true, "goog.provide(\x27shadow.object\x27);\nshadow.object.console_friendly \x3d shadow.util.console_friendly;\nshadow.object.log \x3d shadow.util.log;\nshadow.object.debug \x3d shadow.util.log;\nshadow.object.info \x3d shadow.util.log;\nshadow.object.warn \x3d shadow.util.log;\nshadow.object.error \x3d shadow.util.log;\nshadow.object.obj_id \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0));\nshadow.object.next_id \x3d (function shadow$object$next_id(){\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(shadow.object.obj_id,cljs.core.inc);\n});\nshadow.object.object_defs \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nshadow.object.behavior_fns \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nshadow.object.instances \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nshadow.object.instance_parent \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nshadow.object.instance_children \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nshadow.object.events \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nshadow.object.define_event \x3d (function shadow$object$define_event(event_name,desc,args){\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(shadow.object.events,cljs.core.assoc,event_name,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),event_name,new cljs.core.Keyword(null,\x22description\x22,\x22description\x22,-1428560544),desc,new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),args], null));\n});\nshadow.object.unmunge \x3d (function shadow$object$unmunge(s){\nreturn clojure.string.replace(clojure.string.replace(s,/_DOT_/,\x22.\x22),/_/,\x22-\x22);\n});\nshadow.object.define_event(new cljs.core.Keyword(null,\x22init\x22,\x22init\x22,-1875481434),\x22object initialization\x22,cljs.core.PersistentVector.EMPTY);\nshadow.object.define_event(new cljs.core.Keyword(null,\x22destroy\x22,\x22destroy\x22,-843660405),\x22object descruction\x22,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22cause\x22,\x22cause\x22,231901252),\x22cause of destruction, :parent means the parent was destroyed, :direct is default\x22], null)], null));\nshadow.object.define_event(new cljs.core.Keyword(\x22dom\x22,\x22init\x22,\x22dom/init\x22,-1875647652),\x22called after the dom was created but has not entered the document yet\x22,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22dom\x22,\x22dom\x22,-1236537922),\x22the dom that was created\x22], null)], null));\nshadow.object.define_event(new cljs.core.Keyword(\x22dom\x22,\x22entered\x22,\x22dom/entered\x22,506699596),\x22should be called whenever a dom node is added to the document, since that\\n   is not in control of this library its up to you to call this\\n   use (so/notify-tree! your-obj :dom/entered) to notify the node and every child you created\x22,cljs.core.PersistentVector.EMPTY);\nshadow.object.define_event(new cljs.core.Keyword(null,\x22bind-children-update\x22,\x22bind-children-update\x22,-1610690160),\x22need to rethink this\x22,cljs.core.PersistentVector.EMPTY);\n\n/**\n * @interface\n */\nshadow.object.IObject \x3d function(){};\n\nvar shadow$object$IObject$_id$dyn_27930 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.object._id[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.object._id[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22IObject.-id\x22,this$);\n}\n}\n});\nshadow.object._id \x3d (function shadow$object$_id(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$object$IObject$_id$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$object$IObject$_id$arity$1(this$);\n} else {\nreturn shadow$object$IObject$_id$dyn_27930(this$);\n}\n});\n\nvar shadow$object$IObject$_type$dyn_27935 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.object._type[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.object._type[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22IObject.-type\x22,this$);\n}\n}\n});\nshadow.object._type \x3d (function shadow$object$_type(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$object$IObject$_type$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$object$IObject$_type$arity$1(this$);\n} else {\nreturn shadow$object$IObject$_type$dyn_27935(this$);\n}\n});\n\nvar shadow$object$IObject$_data$dyn_27937 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.object._data[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.object._data[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22IObject.-data\x22,this$);\n}\n}\n});\nshadow.object._data \x3d (function shadow$object$_data(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$object$IObject$_data$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$object$IObject$_data$arity$1(this$);\n} else {\nreturn shadow$object$IObject$_data$dyn_27937(this$);\n}\n});\n\nvar shadow$object$IObject$_update$dyn_27942 \x3d (function (this$,update_fn){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.object._update[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(this$,update_fn) : m__5351__auto__.call(null, this$,update_fn));\n} else {\nvar m__5349__auto__ \x3d (shadow.object._update[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(this$,update_fn) : m__5349__auto__.call(null, this$,update_fn));\n} else {\nthrow cljs.core.missing_protocol(\x22IObject.-update\x22,this$);\n}\n}\n});\n/**\n * update and notify watches\n */\nshadow.object._update \x3d (function shadow$object$_update(this$,update_fn){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$object$IObject$_update$arity$2 \x3d\x3d null)))))){\nreturn this$.shadow$object$IObject$_update$arity$2(this$,update_fn);\n} else {\nreturn shadow$object$IObject$_update$dyn_27942(this$,update_fn);\n}\n});\n\nvar shadow$object$IObject$_destroy_BANG_$dyn_27947 \x3d (function (this$,cause){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.object._destroy_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(this$,cause) : m__5351__auto__.call(null, this$,cause));\n} else {\nvar m__5349__auto__ \x3d (shadow.object._destroy_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(this$,cause) : m__5349__auto__.call(null, this$,cause));\n} else {\nthrow cljs.core.missing_protocol(\x22IObject.-destroy!\x22,this$);\n}\n}\n});\nshadow.object._destroy_BANG_ \x3d (function shadow$object$_destroy_BANG_(this$,cause){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$object$IObject$_destroy_BANG_$arity$2 \x3d\x3d null)))))){\nreturn this$.shadow$object$IObject$_destroy_BANG_$arity$2(this$,cause);\n} else {\nreturn shadow$object$IObject$_destroy_BANG_$dyn_27947(this$,cause);\n}\n});\n\nshadow.object.get_type \x3d (function shadow$object$get_type(this$){\nreturn shadow.object._type(this$);\n});\nshadow.object.get_type_attr \x3d (function shadow$object$get_type_attr(var_args){\nvar G__26912 \x3d arguments.length;\nswitch (G__26912) {\ncase 2:\nreturn shadow.object.get_type_attr.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn shadow.object.get_type_attr.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.get_type_attr.cljs$core$IFn$_invoke$arity$2 \x3d (function (oref,key){\nif((oref \x3d\x3d null)){\nreturn null;\n} else {\nvar type_id \x3d (((oref instanceof cljs.core.Keyword))?oref:shadow.object._type(oref));\nreturn cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.object.object_defs),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [type_id,key], null));\n}\n}));\n\n(shadow.object.get_type_attr.cljs$core$IFn$_invoke$arity$3 \x3d (function (oref,key,default$){\nif((oref \x3d\x3d null)){\nreturn default$;\n} else {\nvar type_id \x3d (((oref instanceof cljs.core.Keyword))?oref:shadow.object._type(oref));\nreturn cljs.core.get_in.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(shadow.object.object_defs),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [type_id,key], null),default$);\n}\n}));\n\n(shadow.object.get_type_attr.cljs$lang$maxFixedArity \x3d 3);\n\nshadow.object.get_dom \x3d (function shadow$object$get_dom(oref){\nreturn new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311).cljs$core$IFn$_invoke$arity$1(oref);\n});\ngoog.exportSymbol(\x27shadow.object.get_dom\x27, shadow.object.get_dom);\nshadow.object.get_by_id \x3d (function shadow$object$get_by_id(id){\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.object.instances),id);\n});\ngoog.exportSymbol(\x27shadow.object.get_by_id\x27, shadow.object.get_by_id);\nshadow.object.get_from_dom \x3d (function shadow$object$get_from_dom(dom){\nvar oid \x3d shadow.dom.data(dom,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334));\nif(cljs.core.truth_(oid)){\nreturn shadow.object.get_by_id(parseInt(oid,(10)));\n} else {\nreturn null;\n}\n});\ngoog.exportSymbol(\x27shadow.object.get_from_dom\x27, shadow.object.get_from_dom);\nshadow.object.is_object_QMARK_ \x3d (function shadow$object$is_object_QMARK_(obj_or_dom){\nvar or__5002__auto__ \x3d (((!((obj_or_dom \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d obj_or_dom.shadow$object$IObject$))))?true:(((!obj_or_dom.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(shadow.object.IObject,obj_or_dom):false)):cljs.core.native_satisfies_QMARK_(shadow.object.IObject,obj_or_dom));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn shadow.object.get_from_dom(obj_or_dom);\n}\n});\nshadow.object.equal_QMARK_ \x3d (function shadow$object$equal_QMARK_(obj,obj_or_dom){\nif((((!((obj \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d obj.shadow$object$IObject$))))?true:(((!obj.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(shadow.object.IObject,obj):false)):cljs.core.native_satisfies_QMARK_(shadow.object.IObject,obj))){\n} else {\nthrow (new Error([\x22Assert failed: \x22,\x22can only test objects\x22,\x22\\n\x22,\x22(satisfies? IObject obj)\x22].join(\x27\x27)));\n}\n\nif((((!((obj_or_dom \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d obj_or_dom.shadow$object$IObject$))))?true:(((!obj_or_dom.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(shadow.object.IObject,obj_or_dom):false)):cljs.core.native_satisfies_QMARK_(shadow.object.IObject,obj_or_dom))){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(shadow.object._id(obj),shadow.object._id(obj_or_dom));\n} else {\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(shadow.object._id(obj),(function (){var temp__5804__auto__ \x3d shadow.dom.data(obj_or_dom,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar oid \x3d temp__5804__auto__;\nreturn parseInt(oid,(10));\n} else {\nreturn null;\n}\n})());\n}\n});\nshadow.object.get_parent \x3d (function shadow$object$get_parent(oref){\nvar temp__5804__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.object.instance_parent),shadow.object._id(oref));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar parent_id \x3d temp__5804__auto__;\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.object.instances),parent_id);\n} else {\nreturn null;\n}\n});\ngoog.exportSymbol(\x27shadow.object.get_parent\x27, shadow.object.get_parent);\nshadow.object.get_parent_of_type \x3d (function shadow$object$get_parent_of_type(oref,parent_type){\nvar parent \x3d new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(oref);\nwhile(true){\nif(cljs.core.truth_(parent)){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(shadow.object._type(parent),parent_type)){\nreturn parent;\n} else {\nvar G__27955 \x3d new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(parent);\nparent \x3d G__27955;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});\ngoog.exportSymbol(\x27shadow.object.get_parent_of_type\x27, shadow.object.get_parent_of_type);\nshadow.object.get_children \x3d (function shadow$object$get_children(parent){\nvar parent_id \x3d shadow.object._id(parent);\nvar child_ids \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(shadow.object.instance_children),parent_id,cljs.core.PersistentVector.EMPTY);\nvar instances \x3d cljs.core.deref(shadow.object.instances);\nreturn cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__27001_SHARP_){\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(instances,p1__27001_SHARP_);\n}),child_ids));\n});\ngoog.exportSymbol(\x27shadow.object.get_children\x27, shadow.object.get_children);\nshadow.object.tree_seq \x3d (function shadow$object$tree_seq(var_args){\nvar G__27011 \x3d arguments.length;\nswitch (G__27011) {\ncase 1:\nreturn shadow.object.tree_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.object.tree_seq.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\ngoog.exportSymbol(\x27shadow.object.tree_seq\x27, shadow.object.tree_seq);\n\n(shadow.object.tree_seq.cljs$core$IFn$_invoke$arity$1 \x3d (function (root){\nreturn shadow.object.tree_seq.cljs$core$IFn$_invoke$arity$2(root,(function (node){\nreturn true;\n}));\n}));\n\n(shadow.object.tree_seq.cljs$core$IFn$_invoke$arity$2 \x3d (function (root,branch_QMARK_){\nreturn cljs.core.tree_seq(branch_QMARK_,shadow.object.get_children,root);\n}));\n\n(shadow.object.tree_seq.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.object.get_children_of_type \x3d (function shadow$object$get_children_of_type(oref,type){\nvar type_kw \x3d (((type instanceof cljs.core.Keyword))?type:shadow.object._type(type));\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__27020_SHARP_){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(type_kw,shadow.object._type(p1__27020_SHARP_));\n}),shadow.object.get_children(oref));\n});\n/**\n * basically (get-children (:parent this))\n */\nshadow.object.get_siblings \x3d (function shadow$object$get_siblings(p__27038){\nvar map__27040 \x3d p__27038;\nvar map__27040__$1 \x3d cljs.core.__destructure_map(map__27040);\nvar oref \x3d map__27040__$1;\nvar parent \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27040__$1,new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779));\nif(cljs.core.truth_(parent)){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22object has no parent, thus has no siblings\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22oref\x22,\x22oref\x22,-1547494840),oref], null));\n}\n\nreturn shadow.object.get_children(parent);\n});\n/**\n * returns set of all siblings of a common type\n */\nshadow.object.get_siblings_of_type \x3d (function shadow$object$get_siblings_of_type(var_args){\nvar G__27050 \x3d arguments.length;\nswitch (G__27050) {\ncase 1:\nreturn shadow.object.get_siblings_of_type.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.object.get_siblings_of_type.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.get_siblings_of_type.cljs$core$IFn$_invoke$arity$1 \x3d (function (oref){\nreturn shadow.object.get_siblings_of_type.cljs$core$IFn$_invoke$arity$2(oref,oref);\n}));\n\n(shadow.object.get_siblings_of_type.cljs$core$IFn$_invoke$arity$2 \x3d (function (oref,type){\nvar type_kw \x3d (((type instanceof cljs.core.Keyword))?type:shadow.object._type(type));\nreturn cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__27045_SHARP_){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(type_kw,shadow.object._type(p1__27045_SHARP_));\n}),shadow.object.get_siblings(oref));\n}));\n\n(shadow.object.get_siblings_of_type.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.object.get_collection_item \x3d (function shadow$object$get_collection_item(oref){\nvar item_key \x3d new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-item-key\x22,\x22shadow.object/coll-item-key\x22,1888444366).cljs$core$IFn$_invoke$arity$1(oref);\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(oref,item_key);\n});\n/**\n * find the object that contains this dom node\n */\nshadow.object.find_containing_object \x3d (function shadow$object$find_containing_object(dom){\nwhile(true){\nvar temp__5802__auto__ \x3d shadow.object.get_from_dom(dom);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar obj \x3d temp__5802__auto__;\nreturn obj;\n} else {\nvar temp__5804__auto__ \x3d dom.parentElement;\nif(cljs.core.truth_(temp__5804__auto__)){\nvar parent \x3d temp__5804__auto__;\nvar G__27968 \x3d parent;\ndom \x3d G__27968;\ncontinue;\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.object.notify_BANG_ \x3d (function shadow$object$notify_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27969 \x3d arguments.length;\nvar i__5727__auto___27971 \x3d (0);\nwhile(true){\nif((i__5727__auto___27971 \x3c len__5726__auto___27969)){\nargs__5732__auto__.push((arguments[i__5727__auto___27971]));\n\nvar G__27972 \x3d (i__5727__auto___27971 + (1));\ni__5727__auto___27971 \x3d G__27972;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn shadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(shadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (oref,ev,args){\nvar temp__5804__auto__ \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(oref,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22shadow.object\x22,\x22reactions\x22,\x22shadow.object/reactions\x22,1966199633),ev], null));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar reactions_to_trigger \x3d temp__5804__auto__;\nvar seq__27125 \x3d cljs.core.seq(reactions_to_trigger);\nvar chunk__27126 \x3d null;\nvar count__27127 \x3d (0);\nvar i__27128 \x3d (0);\nwhile(true){\nif((i__27128 \x3c count__27127)){\nvar rfn \x3d chunk__27126.cljs$core$IIndexed$_nth$arity$2(null, i__27128);\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2(rfn,cljs.core.cons(oref,args));\n\n\nvar G__27979 \x3d seq__27125;\nvar G__27980 \x3d chunk__27126;\nvar G__27981 \x3d count__27127;\nvar G__27982 \x3d (i__27128 + (1));\nseq__27125 \x3d G__27979;\nchunk__27126 \x3d G__27980;\ncount__27127 \x3d G__27981;\ni__27128 \x3d G__27982;\ncontinue;\n} else {\nvar temp__5804__auto____$1 \x3d cljs.core.seq(seq__27125);\nif(temp__5804__auto____$1){\nvar seq__27125__$1 \x3d temp__5804__auto____$1;\nif(cljs.core.chunked_seq_QMARK_(seq__27125__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__27125__$1);\nvar G__27983 \x3d cljs.core.chunk_rest(seq__27125__$1);\nvar G__27984 \x3d c__5525__auto__;\nvar G__27985 \x3d cljs.core.count(c__5525__auto__);\nvar G__27986 \x3d (0);\nseq__27125 \x3d G__27983;\nchunk__27126 \x3d G__27984;\ncount__27127 \x3d G__27985;\ni__27128 \x3d G__27986;\ncontinue;\n} else {\nvar rfn \x3d cljs.core.first(seq__27125__$1);\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2(rfn,cljs.core.cons(oref,args));\n\n\nvar G__27987 \x3d cljs.core.next(seq__27125__$1);\nvar G__27988 \x3d null;\nvar G__27989 \x3d (0);\nvar G__27990 \x3d (0);\nseq__27125 \x3d G__27987;\nchunk__27126 \x3d G__27988;\ncount__27127 \x3d G__27989;\ni__27128 \x3d G__27990;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n} else {\nreturn null;\n}\n}));\n\n(shadow.object.notify_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(shadow.object.notify_BANG_.cljs$lang$applyTo \x3d (function (seq27098){\nvar G__27104 \x3d cljs.core.first(seq27098);\nvar seq27098__$1 \x3d cljs.core.next(seq27098);\nvar G__27105 \x3d cljs.core.first(seq27098__$1);\nvar seq27098__$2 \x3d cljs.core.next(seq27098__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__27104,G__27105,seq27098__$2);\n}));\n\nshadow.object.do_notify_tree \x3d (function shadow$object$do_notify_tree(current_obj,ev,notify_fn){\nvar seq__27177_27993 \x3d cljs.core.seq(shadow.object.get_children(current_obj));\nvar chunk__27178_27994 \x3d null;\nvar count__27179_27995 \x3d (0);\nvar i__27180_27996 \x3d (0);\nwhile(true){\nif((i__27180_27996 \x3c count__27179_27995)){\nvar child_27997 \x3d chunk__27178_27994.cljs$core$IIndexed$_nth$arity$2(null, i__27180_27996);\n(shadow.object.do_notify_tree.cljs$core$IFn$_invoke$arity$3 ? shadow.object.do_notify_tree.cljs$core$IFn$_invoke$arity$3(child_27997,ev,notify_fn) : shadow.object.do_notify_tree.call(null, child_27997,ev,notify_fn));\n\n\nvar G__27998 \x3d seq__27177_27993;\nvar G__27999 \x3d chunk__27178_27994;\nvar G__28000 \x3d count__27179_27995;\nvar G__28001 \x3d (i__27180_27996 + (1));\nseq__27177_27993 \x3d G__27998;\nchunk__27178_27994 \x3d G__27999;\ncount__27179_27995 \x3d G__28000;\ni__27180_27996 \x3d G__28001;\ncontinue;\n} else {\nvar temp__5804__auto___28002 \x3d cljs.core.seq(seq__27177_27993);\nif(temp__5804__auto___28002){\nvar seq__27177_28003__$1 \x3d temp__5804__auto___28002;\nif(cljs.core.chunked_seq_QMARK_(seq__27177_28003__$1)){\nvar c__5525__auto___28005 \x3d cljs.core.chunk_first(seq__27177_28003__$1);\nvar G__28006 \x3d cljs.core.chunk_rest(seq__27177_28003__$1);\nvar G__28007 \x3d c__5525__auto___28005;\nvar G__28008 \x3d cljs.core.count(c__5525__auto___28005);\nvar G__28009 \x3d (0);\nseq__27177_27993 \x3d G__28006;\nchunk__27178_27994 \x3d G__28007;\ncount__27179_27995 \x3d G__28008;\ni__27180_27996 \x3d G__28009;\ncontinue;\n} else {\nvar child_28011 \x3d cljs.core.first(seq__27177_28003__$1);\n(shadow.object.do_notify_tree.cljs$core$IFn$_invoke$arity$3 ? shadow.object.do_notify_tree.cljs$core$IFn$_invoke$arity$3(child_28011,ev,notify_fn) : shadow.object.do_notify_tree.call(null, child_28011,ev,notify_fn));\n\n\nvar G__28012 \x3d cljs.core.next(seq__27177_28003__$1);\nvar G__28013 \x3d null;\nvar G__28014 \x3d (0);\nvar G__28015 \x3d (0);\nseq__27177_27993 \x3d G__28012;\nchunk__27178_27994 \x3d G__28013;\ncount__27179_27995 \x3d G__28014;\ni__27180_27996 \x3d G__28015;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn (notify_fn.cljs$core$IFn$_invoke$arity$1 ? notify_fn.cljs$core$IFn$_invoke$arity$1(current_obj) : notify_fn.call(null, current_obj));\n});\nshadow.object.notify_tree_BANG_ \x3d (function shadow$object$notify_tree_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28017 \x3d arguments.length;\nvar i__5727__auto___28018 \x3d (0);\nwhile(true){\nif((i__5727__auto___28018 \x3c len__5726__auto___28017)){\nargs__5732__auto__.push((arguments[i__5727__auto___28018]));\n\nvar G__28019 \x3d (i__5727__auto___28018 + (1));\ni__5727__auto___28018 \x3d G__28019;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn shadow.object.notify_tree_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(shadow.object.notify_tree_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (oref,ev,args){\nvar notify_fn \x3d (function (obj){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$4(shadow.object.notify_BANG_,obj,ev,args);\n});\nreturn shadow.object.do_notify_tree(oref,ev,notify_fn);\n}));\n\n(shadow.object.notify_tree_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(shadow.object.notify_tree_BANG_.cljs$lang$applyTo \x3d (function (seq27193){\nvar G__27194 \x3d cljs.core.first(seq27193);\nvar seq27193__$1 \x3d cljs.core.next(seq27193);\nvar G__27195 \x3d cljs.core.first(seq27193__$1);\nvar seq27193__$2 \x3d cljs.core.next(seq27193__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__27194,G__27195,seq27193__$2);\n}));\n\nshadow.object.notify_down_BANG_ \x3d shadow.object.notify_tree_BANG_;\nshadow.object.notify_up_BANG_ \x3d (function shadow$object$notify_up_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28022 \x3d arguments.length;\nvar i__5727__auto___28023 \x3d (0);\nwhile(true){\nif((i__5727__auto___28023 \x3c len__5726__auto___28022)){\nargs__5732__auto__.push((arguments[i__5727__auto___28023]));\n\nvar G__28025 \x3d (i__5727__auto___28023 + (1));\ni__5727__auto___28023 \x3d G__28025;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn shadow.object.notify_up_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(shadow.object.notify_up_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (oref,ev,args){\nvar current \x3d shadow.object.get_parent(oref);\nwhile(true){\nif(cljs.core.truth_(current)){\ncljs.core.apply.cljs$core$IFn$_invoke$arity$4(shadow.object.notify_BANG_,current,ev,args);\n\nvar G__28026 \x3d shadow.object.get_parent(current);\ncurrent \x3d G__28026;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(shadow.object.notify_up_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(shadow.object.notify_up_BANG_.cljs$lang$applyTo \x3d (function (seq27221){\nvar G__27223 \x3d cljs.core.first(seq27221);\nvar seq27221__$1 \x3d cljs.core.next(seq27221);\nvar G__27224 \x3d cljs.core.first(seq27221__$1);\nvar seq27221__$2 \x3d cljs.core.next(seq27221__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__27223,G__27224,seq27221__$2);\n}));\n\nshadow.object.update_BANG_ \x3d (function shadow$object$update_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28029 \x3d arguments.length;\nvar i__5727__auto___28030 \x3d (0);\nwhile(true){\nif((i__5727__auto___28030 \x3c len__5726__auto___28029)){\nargs__5732__auto__.push((arguments[i__5727__auto___28030]));\n\nvar G__28031 \x3d (i__5727__auto___28030 + (1));\ni__5727__auto___28030 \x3d G__28031;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn shadow.object.update_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(shadow.object.update_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (oref,update_fn,args){\nif(cljs.core.fn_QMARK_(update_fn)){\n} else {\nthrow [\x22update! expects a fn as second arg, not \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([update_fn], 0))].join(\x27\x27);\n}\n\nvar id \x3d shadow.object._id(oref);\nvar data \x3d shadow.object._data(oref);\nvar work_fn \x3d (function (data__$1){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3(update_fn,data__$1,args);\n});\nreturn shadow.object._update(oref,work_fn);\n}));\n\n(shadow.object.update_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(shadow.object.update_BANG_.cljs$lang$applyTo \x3d (function (seq27240){\nvar G__27241 \x3d cljs.core.first(seq27240);\nvar seq27240__$1 \x3d cljs.core.next(seq27240);\nvar G__27242 \x3d cljs.core.first(seq27240__$1);\nvar seq27240__$2 \x3d cljs.core.next(seq27240__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__27241,G__27242,seq27240__$2);\n}));\n\nshadow.object.return_value \x3d (function shadow$object$return_value(oref,return_value){\nreturn shadow.object.update_BANG_.cljs$core$IFn$_invoke$arity$variadic(oref,cljs.core.assoc,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.object\x22,\x22return-value\x22,\x22shadow.object/return-value\x22,1397593360),return_value], 0));\n});\nshadow.object.set_parent_BANG_ \x3d (function shadow$object$set_parent_BANG_(child,parent){\nvar child_id \x3d shadow.object._id(child);\nvar parent_id \x3d shadow.object._id(parent);\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(shadow.object.instance_parent,cljs.core.assoc,child_id,parent_id);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(shadow.object.instance_children,(function (x){\nvar current \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(x,parent_id,cljs.core.PersistentHashSet.EMPTY);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(x,parent_id,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(current,child_id));\n}));\n\nreturn true;\n});\nshadow.object.dom_destroy \x3d (function shadow$object$dom_destroy(this$,cause){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cause,new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779))){\nreturn shadow.dom.remove(new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311).cljs$core$IFn$_invoke$arity$1(this$));\n} else {\nvar temp__5802__auto__ \x3d shadow.object.get_type_attr.cljs$core$IFn$_invoke$arity$2(this$,new cljs.core.Keyword(\x22dom\x22,\x22remove\x22,\x22dom/remove\x22,-131527420));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar custom_remove \x3d temp__5802__auto__;\nvar G__27274 \x3d this$;\nvar G__27275 \x3d new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311).cljs$core$IFn$_invoke$arity$1(this$);\nreturn (custom_remove.cljs$core$IFn$_invoke$arity$2 ? custom_remove.cljs$core$IFn$_invoke$arity$2(G__27274,G__27275) : custom_remove.call(null, G__27274,G__27275));\n} else {\nreturn shadow.dom.remove(new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311).cljs$core$IFn$_invoke$arity$1(this$));\n}\n}\n});\nshadow.object.destroy_BANG_ \x3d (function shadow$object$destroy_BANG_(var_args){\nvar G__27286 \x3d arguments.length;\nswitch (G__27286) {\ncase 1:\nreturn shadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$1 \x3d (function (oref){\nreturn shadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$2(oref,new cljs.core.Keyword(null,\x22direct\x22,\x22direct\x22,-1775717856));\n}));\n\n(shadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (oref,cause){\nreturn shadow.object._destroy_BANG_(oref,cause);\n}));\n\n(shadow.object.destroy_BANG_.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.object.bind_dom_events \x3d (function shadow$object$bind_dom_events(oref,dom,dom_events){\nif((cljs.core.rem(cljs.core.count(dom_events),(2)) \x3d\x3d\x3d (0))){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22object defined invalid event\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22object-type\x22,\x22object-type\x22,-1889869015),shadow.object._type(oref),new cljs.core.Keyword(\x22dom\x22,\x22events\x22,\x22dom/events\x22,1793437527),dom_events], null));\n}\n\nvar seq__27304 \x3d cljs.core.seq(cljs.core.partition.cljs$core$IFn$_invoke$arity$2((2),dom_events));\nvar chunk__27305 \x3d null;\nvar count__27306 \x3d (0);\nvar i__27307 \x3d (0);\nwhile(true){\nif((i__27307 \x3c count__27306)){\nvar vec__27333 \x3d chunk__27305.cljs$core$IIndexed$_nth$arity$2(null, i__27307);\nvar ev \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27333,(0),null);\nvar handler \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27333,(1),null);\nvar ev_def \x3d vec__27333;\nif((handler \x3d\x3d null)){\nthrow [\x22ev with nil handler \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([ev], 0))].join(\x27\x27);\n} else {\n}\n\nvar handler_28036__$1 \x3d (((handler instanceof cljs.core.Keyword))?((function (seq__27304,chunk__27305,count__27306,i__27307,vec__27333,ev,handler,ev_def){\nreturn (function (this$,e,el){\nreturn shadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic(this$,handler,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,el], 0));\n});})(seq__27304,chunk__27305,count__27306,i__27307,vec__27333,ev,handler,ev_def))\n:handler);\nshadow.dom.on.cljs$core$IFn$_invoke$arity$3(dom,ev,((function (seq__27304,chunk__27305,count__27306,i__27307,handler_28036__$1,vec__27333,ev,handler,ev_def){\nreturn (function shadow$object$bind_dom_events_$_dom_event_handler(e,el){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22A\x22,el.tagName)){\nshadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$1(e);\n} else {\n}\n\nreturn (handler_28036__$1.cljs$core$IFn$_invoke$arity$3 ? handler_28036__$1.cljs$core$IFn$_invoke$arity$3(oref,e,el) : handler_28036__$1.call(null, oref,e,el));\n});})(seq__27304,chunk__27305,count__27306,i__27307,handler_28036__$1,vec__27333,ev,handler,ev_def))\n);\n\n\nvar G__28037 \x3d seq__27304;\nvar G__28038 \x3d chunk__27305;\nvar G__28039 \x3d count__27306;\nvar G__28040 \x3d (i__27307 + (1));\nseq__27304 \x3d G__28037;\nchunk__27305 \x3d G__28038;\ncount__27306 \x3d G__28039;\ni__27307 \x3d G__28040;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__27304);\nif(temp__5804__auto__){\nvar seq__27304__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__27304__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__27304__$1);\nvar G__28041 \x3d cljs.core.chunk_rest(seq__27304__$1);\nvar G__28042 \x3d c__5525__auto__;\nvar G__28043 \x3d cljs.core.count(c__5525__auto__);\nvar G__28044 \x3d (0);\nseq__27304 \x3d G__28041;\nchunk__27305 \x3d G__28042;\ncount__27306 \x3d G__28043;\ni__27307 \x3d G__28044;\ncontinue;\n} else {\nvar vec__27357 \x3d cljs.core.first(seq__27304__$1);\nvar ev \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27357,(0),null);\nvar handler \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27357,(1),null);\nvar ev_def \x3d vec__27357;\nif((handler \x3d\x3d null)){\nthrow [\x22ev with nil handler \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([ev], 0))].join(\x27\x27);\n} else {\n}\n\nvar handler_28045__$1 \x3d (((handler instanceof cljs.core.Keyword))?((function (seq__27304,chunk__27305,count__27306,i__27307,vec__27357,ev,handler,ev_def,seq__27304__$1,temp__5804__auto__){\nreturn (function (this$,e,el){\nreturn shadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic(this$,handler,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,el], 0));\n});})(seq__27304,chunk__27305,count__27306,i__27307,vec__27357,ev,handler,ev_def,seq__27304__$1,temp__5804__auto__))\n:handler);\nshadow.dom.on.cljs$core$IFn$_invoke$arity$3(dom,ev,((function (seq__27304,chunk__27305,count__27306,i__27307,handler_28045__$1,vec__27357,ev,handler,ev_def,seq__27304__$1,temp__5804__auto__){\nreturn (function shadow$object$bind_dom_events_$_dom_event_handler(e,el){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22A\x22,el.tagName)){\nshadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$1(e);\n} else {\n}\n\nreturn (handler_28045__$1.cljs$core$IFn$_invoke$arity$3 ? handler_28045__$1.cljs$core$IFn$_invoke$arity$3(oref,e,el) : handler_28045__$1.call(null, oref,e,el));\n});})(seq__27304,chunk__27305,count__27306,i__27307,handler_28045__$1,vec__27357,ev,handler,ev_def,seq__27304__$1,temp__5804__auto__))\n);\n\n\nvar G__28046 \x3d cljs.core.next(seq__27304__$1);\nvar G__28047 \x3d null;\nvar G__28048 \x3d (0);\nvar G__28049 \x3d (0);\nseq__27304 \x3d G__28046;\nchunk__27305 \x3d G__28047;\ncount__27306 \x3d G__28048;\ni__27307 \x3d G__28049;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.object.reaction_merge \x3d (function shadow$object$reaction_merge(result,p__27373){\nvar vec__27375 \x3d p__27373;\nvar event \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27375,(0),null);\nvar handler \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27375,(1),null);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d event;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn handler;\n} else {\nreturn and__5000__auto__;\n}\n})())){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid reaction\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22event\x22,\x22event\x22,301435442),event,new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612),handler], null));\n}\n\nvar current \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(result,event,cljs.core.List.EMPTY);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(result,event,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(current,handler));\n});\nshadow.object.merge_reactions \x3d (function shadow$object$merge_reactions(result,behavior){\nif(cljs.core.sequential_QMARK_(behavior)){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22behaviors must be vectors\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22behavior\x22,\x22behavior\x22,1202392908),behavior], null));\n}\n\nif(cljs.core.even_QMARK_(cljs.core.count(behavior))){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid behavior\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22behavior\x22,\x22behavior\x22,1202392908),behavior], null));\n}\n\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(shadow.object.reaction_merge,result,cljs.core.reverse(cljs.core.partition.cljs$core$IFn$_invoke$arity$2((2),behavior)));\n});\nshadow.object.merge_behaviors \x3d (function shadow$object$merge_behaviors(result,behavior){\nif(cljs.core.sequential_QMARK_(behavior)){\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$4(result,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22shadow.object\x22,\x22reactions\x22,\x22shadow.object/reactions\x22,1966199633)], null),shadow.object.merge_reactions,behavior);\n} else {\nif(cljs.core.map_QMARK_(behavior)){\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$3(cljs.core.update_in.cljs$core$IFn$_invoke$arity$3(cljs.core.update_in.cljs$core$IFn$_invoke$arity$4(result,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22shadow.object\x22,\x22reactions\x22,\x22shadow.object/reactions\x22,1966199633)], null),shadow.object.merge_reactions,new cljs.core.Keyword(null,\x22on\x22,\x22on\x22,173873944).cljs$core$IFn$_invoke$arity$2(behavior,cljs.core.PersistentVector.EMPTY)),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22watch\x22,\x22watch\x22,380988277)], null),(function (watches){\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$2(watches,new cljs.core.Keyword(null,\x22watch\x22,\x22watch\x22,380988277).cljs$core$IFn$_invoke$arity$2(behavior,cljs.core.PersistentVector.EMPTY));\n})),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22dom\x22,\x22events\x22,\x22dom/events\x22,1793437527)], null),(function (default$){\nreturn cljs.core.vec(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(default$,new cljs.core.Keyword(\x22dom\x22,\x22events\x22,\x22dom/events\x22,1793437527).cljs$core$IFn$_invoke$arity$2(behavior,cljs.core.PersistentVector.EMPTY)));\n}));\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22behavior not understood\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22behavior\x22,\x22behavior\x22,1202392908),behavior], null));\n\n}\n}\n});\nshadow.object.define \x3d (function shadow$object$define(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28053 \x3d arguments.length;\nvar i__5727__auto___28054 \x3d (0);\nwhile(true){\nif((i__5727__auto___28054 \x3c len__5726__auto___28053)){\nargs__5732__auto__.push((arguments[i__5727__auto___28054]));\n\nvar G__28055 \x3d (i__5727__auto___28054 + (1));\ni__5727__auto___28054 \x3d G__28055;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn shadow.object.define.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(shadow.object.define.cljs$core$IFn$_invoke$arity$variadic \x3d (function (id,args){\nif((id instanceof cljs.core.Keyword)){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22object id needs to be a keyword\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),id,new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),args], null));\n}\n\nif(cljs.core.even_QMARK_(cljs.core.count(args))){\n} else {\nthrow [\x22invalid object definition \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(id),\x22 args: \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([args], 0))].join(\x27\x27);\n}\n\nif(cljs.core.contains_QMARK_(cljs.core.deref(shadow.object.object_defs),id)){\nconsole.warn([\x22object already defined \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(id)].join(\x27\x27));\n} else {\n}\n\ntry{var odef \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,args);\nvar reactions \x3d shadow.object.merge_reactions(cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22on\x22,\x22on\x22,173873944).cljs$core$IFn$_invoke$arity$2(odef,cljs.core.PersistentVector.EMPTY));\nvar odef__$1 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(odef,new cljs.core.Keyword(\x22shadow.object\x22,\x22id\x22,\x22shadow.object/id\x22,-647954841),id,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.object\x22,\x22reactions\x22,\x22shadow.object/reactions\x22,1966199633),reactions], 0));\nvar odef__$2 \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(shadow.object.merge_behaviors,odef__$1,cljs.core.reverse(new cljs.core.Keyword(null,\x22behaviors\x22,\x22behaviors\x22,120724909).cljs$core$IFn$_invoke$arity$2(odef__$1,cljs.core.PersistentVector.EMPTY)));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(shadow.object.object_defs,cljs.core.assoc,id,odef__$2);\n\nreturn odef__$2;\n}catch (e27429){if((e27429 instanceof Object)){\nvar e \x3d e27429;\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22failed to define object\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),id,new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),args], null));\n} else {\nthrow e27429;\n\n}\n}}));\n\n(shadow.object.define.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(shadow.object.define.cljs$lang$applyTo \x3d (function (seq27411){\nvar G__27412 \x3d cljs.core.first(seq27411);\nvar seq27411__$1 \x3d cljs.core.next(seq27411);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__27412,seq27411__$1);\n}));\n\nshadow.object.merge_defaults \x3d (function shadow$object$merge_defaults(data,type){\nvar defaults \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.object.object_defs),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [type,new cljs.core.Keyword(null,\x22defaults\x22,\x22defaults\x22,976027214)], null));\nif((defaults \x3d\x3d null)){\nreturn data;\n} else {\nif(cljs.core.map_QMARK_(defaults)){\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([defaults,data], 0));\n} else {\nif(cljs.core.fn_QMARK_(defaults)){\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(defaults.cljs$core$IFn$_invoke$arity$0 ? defaults.cljs$core$IFn$_invoke$arity$0() : defaults.call(null, )),data], 0));\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid object defaults\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22defaults\x22,\x22defaults\x22,976027214),defaults,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),type], null));\n\n}\n}\n}\n});\nshadow.object.make_dom \x3d (function shadow$object$make_dom(var_args){\nvar G__27446 \x3d arguments.length;\nswitch (G__27446) {\ncase 3:\nreturn shadow.object.make_dom.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.object.make_dom.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.make_dom.cljs$core$IFn$_invoke$arity$3 \x3d (function (oref,dom_key,events_key){\nreturn shadow.object.make_dom.cljs$core$IFn$_invoke$arity$4(oref,dom_key,events_key,null);\n}));\n\n(shadow.object.make_dom.cljs$core$IFn$_invoke$arity$4 \x3d (function (oref,dom_key,events_key,value){\nvar dom_fn \x3d (((dom_key instanceof cljs.core.Keyword))?shadow.object.get_type_attr.cljs$core$IFn$_invoke$arity$2(oref,dom_key):dom_key);\nvar events \x3d (((events_key instanceof cljs.core.Keyword))?shadow.object.get_type_attr.cljs$core$IFn$_invoke$arity$3(oref,events_key,cljs.core.PersistentVector.EMPTY):events_key);\nvar dom \x3d (function (){var G__27452 \x3d (dom_fn.cljs$core$IFn$_invoke$arity$2 ? dom_fn.cljs$core$IFn$_invoke$arity$2(oref,value) : dom_fn.call(null, oref,value));\nreturn (shadow.dom.build.cljs$core$IFn$_invoke$arity$1 ? shadow.dom.build.cljs$core$IFn$_invoke$arity$1(G__27452) : shadow.dom.build.call(null, G__27452));\n})();\nshadow.object.bind_dom_events(oref,dom,events);\n\nreturn dom;\n}));\n\n(shadow.object.make_dom.cljs$lang$maxFixedArity \x3d 4);\n\nshadow.object.alive_QMARK_ \x3d (function shadow$object$alive_QMARK_(obj){\nreturn cljs.core.contains_QMARK_(cljs.core.deref(shadow.object.instances),shadow.object._id(obj));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\nshadow.object.Watch \x3d (function (key,handler,__meta,__extmap,__hash){\nthis.key \x3d key;\nthis.handler \x3d handler;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(shadow.object.Watch.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(shadow.object.Watch.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k27454,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__27464 \x3d k27454;\nvar G__27464__$1 \x3d (((G__27464 instanceof cljs.core.Keyword))?G__27464.fqn:null);\nswitch (G__27464__$1) {\ncase \x22key\x22:\nreturn self__.key;\n\nbreak;\ncase \x22handler\x22:\nreturn self__.handler;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k27454,else__5303__auto__);\n\n}\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__27473){\nvar vec__27475 \x3d p__27473;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27475,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27475,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#shadow.object.Watch{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),self__.key],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612),self__.handler],null))], null),self__.__extmap));\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__27453){\nvar self__ \x3d this;\nvar G__27453__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__27453__$1,2,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(shadow.object.Watch.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new shadow.object.Watch(self__.key,self__.handler,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(shadow.object.Watch.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (2 + cljs.core.count(self__.__extmap));\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (-17677043 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this27455,other27456){\nvar self__ \x3d this;\nvar this27455__$1 \x3d this;\nreturn (((!((other27456 \x3d\x3d null)))) \x26\x26 ((((this27455__$1.constructor \x3d\x3d\x3d other27456.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this27455__$1.key,other27456.key)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this27455__$1.handler,other27456.handler)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this27455__$1.__extmap,other27456.__extmap)))))))));\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),null,new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new shadow.object.Watch(self__.key,self__.handler,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k27454){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__27512 \x3d k27454;\nvar G__27512__$1 \x3d (((G__27512 instanceof cljs.core.Keyword))?G__27512.fqn:null);\nswitch (G__27512__$1) {\ncase \x22key\x22:\ncase \x22handler\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k27454);\n\n}\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__27453){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__27519 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__27520 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__27519.cljs$core$IFn$_invoke$arity$2 ? pred__27519.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),expr__27520) : pred__27519.call(null, new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),expr__27520)))){\nreturn (new shadow.object.Watch(G__27453,self__.handler,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__27519.cljs$core$IFn$_invoke$arity$2 ? pred__27519.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612),expr__27520) : pred__27519.call(null, new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612),expr__27520)))){\nreturn (new shadow.object.Watch(self__.key,G__27453,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new shadow.object.Watch(self__.key,self__.handler,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__27453),null));\n}\n}\n}));\n\n(shadow.object.Watch.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),self__.key,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612),self__.handler,null))], null),self__.__extmap));\n}));\n\n(shadow.object.Watch.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__27453){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new shadow.object.Watch(self__.key,self__.handler,G__27453,self__.__extmap,self__.__hash));\n}));\n\n(shadow.object.Watch.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(shadow.object.Watch.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22key\x22,\x22key\x22,124488940,null),new cljs.core.Symbol(null,\x22handler\x22,\x22handler\x22,1444934915,null)], null);\n}));\n\n(shadow.object.Watch.cljs$lang$type \x3d true);\n\n(shadow.object.Watch.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22shadow.object/Watch\x22,null,(1),null));\n}));\n\n(shadow.object.Watch.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22shadow.object/Watch\x22);\n}));\n\n/**\n * Positional factory function for shadow.object/Watch.\n */\nshadow.object.__GT_Watch \x3d (function shadow$object$__GT_Watch(key,handler){\nreturn (new shadow.object.Watch(key,handler,null,null,null));\n});\n\n/**\n * Factory function for shadow.object/Watch, taking a map of keywords to field values.\n */\nshadow.object.map__GT_Watch \x3d (function shadow$object$map__GT_Watch(G__27458){\nvar extmap__5342__auto__ \x3d (function (){var G__27547 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__27458,new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612)], 0));\nif(cljs.core.record_QMARK_(G__27458)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__27547);\n} else {\nreturn G__27547;\n}\n})();\nreturn (new shadow.object.Watch(new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587).cljs$core$IFn$_invoke$arity$1(G__27458),new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612).cljs$core$IFn$_invoke$arity$1(G__27458),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IWatchable}\n * @implements {cljs.core.IEquiv}\n * @implements {shadow.object.IObject}\n * @implements {cljs.core.async.impl.protocols.ReadPort}\n * @implements {cljs.core.IDeref}\n * @implements {shadow.dom.IElement}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {shadow.dom.SVGElement}\n * @implements {cljs.core.ILookup}\n*/\nshadow.object.ObjectRef \x3d (function (id,type,data,watches,result_chan){\nthis.id \x3d id;\nthis.type \x3d type;\nthis.data \x3d data;\nthis.watches \x3d watches;\nthis.result_chan \x3d result_chan;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2149613824;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 2;\n});\n(shadow.object.ObjectRef.prototype.cljs$core$async$impl$protocols$ReadPort$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.object.ObjectRef.prototype.cljs$core$async$impl$protocols$ReadPort$take_BANG_$arity$2 \x3d (function (this$,handler){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core.async.impl.protocols.take_BANG_(self__.result_chan,handler);\n}));\n\n(shadow.object.ObjectRef.prototype.toString \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([this$], 0));\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this$,k){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),k)){\nreturn shadow.object.get_parent(this$__$1);\n} else {\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(self__.data,k);\n}\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this$,k,d){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),k)){\nreturn shadow.object.get_parent(this$__$1);\n} else {\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.data,k,d);\n}\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this$,writer,opts){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core._write(writer,[\x22#\x3cObjectRef {:id \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.id),\x22, :type \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.type),\x22}\x3e\x22].join(\x27\x27));\n}));\n\n(shadow.object.ObjectRef.prototype.shadow$dom$SVGElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.object.ObjectRef.prototype.shadow$dom$SVGElement$_to_svg$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311).cljs$core$IFn$_invoke$arity$1(self__.data);\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this$,other){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (((other instanceof shadow.object.ObjectRef)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this$__$1.shadow$object$IObject$_id$arity$1(null, ),shadow.object._id(other))));\n}));\n\n(shadow.object.ObjectRef.prototype.shadow$dom$IElement$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.object.ObjectRef.prototype.shadow$dom$IElement$_to_dom$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311).cljs$core$IFn$_invoke$arity$1(self__.data);\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$IWatchable$_notify_watches$arity$3 \x3d (function (this$,oldval,newval){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nthrow (new Error(\x22who be calling?\x22));\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$IWatchable$_add_watch$arity$3 \x3d (function (this$,key,f){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (self__.watches \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(self__.watches,(new shadow.object.Watch(key,f,null,null,null))));\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$IWatchable$_remove_watch$arity$2 \x3d (function (this$,key){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn (self__.watches \x3d cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p1__27552_SHARP_){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(key,new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587).cljs$core$IFn$_invoke$arity$1(p1__27552_SHARP_));\n}),self__.watches));\n}));\n\n(shadow.object.ObjectRef.prototype.shadow$object$IObject$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.object.ObjectRef.prototype.shadow$object$IObject$_id$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.id;\n}));\n\n(shadow.object.ObjectRef.prototype.shadow$object$IObject$_type$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.type;\n}));\n\n(shadow.object.ObjectRef.prototype.shadow$object$IObject$_data$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.data;\n}));\n\n(shadow.object.ObjectRef.prototype.shadow$object$IObject$_update$arity$2 \x3d (function (this$,update_fn){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar old \x3d self__.data;\nvar new$ \x3d (update_fn.cljs$core$IFn$_invoke$arity$1 ? update_fn.cljs$core$IFn$_invoke$arity$1(self__.data) : update_fn.call(null, self__.data));\n(self__.data \x3d new$);\n\nvar seq__27610 \x3d cljs.core.seq(self__.watches);\nvar chunk__27611 \x3d null;\nvar count__27612 \x3d (0);\nvar i__27613 \x3d (0);\nwhile(true){\nif((i__27613 \x3c count__27612)){\nvar map__27630 \x3d chunk__27611.cljs$core$IIndexed$_nth$arity$2(null, i__27613);\nvar map__27630__$1 \x3d cljs.core.__destructure_map(map__27630);\nvar watch \x3d map__27630__$1;\nvar key \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27630__$1,new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587));\nvar handler \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27630__$1,new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612));\nif(shadow.object.alive_QMARK_(this$__$1)){\n(handler.cljs$core$IFn$_invoke$arity$4 ? handler.cljs$core$IFn$_invoke$arity$4(key,this$__$1,old,new$) : handler.call(null, key,this$__$1,old,new$));\n} else {\n}\n\n\nvar G__28083 \x3d seq__27610;\nvar G__28084 \x3d chunk__27611;\nvar G__28085 \x3d count__27612;\nvar G__28086 \x3d (i__27613 + (1));\nseq__27610 \x3d G__28083;\nchunk__27611 \x3d G__28084;\ncount__27612 \x3d G__28085;\ni__27613 \x3d G__28086;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__27610);\nif(temp__5804__auto__){\nvar seq__27610__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__27610__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__27610__$1);\nvar G__28087 \x3d cljs.core.chunk_rest(seq__27610__$1);\nvar G__28088 \x3d c__5525__auto__;\nvar G__28089 \x3d cljs.core.count(c__5525__auto__);\nvar G__28090 \x3d (0);\nseq__27610 \x3d G__28087;\nchunk__27611 \x3d G__28088;\ncount__27612 \x3d G__28089;\ni__27613 \x3d G__28090;\ncontinue;\n} else {\nvar map__27637 \x3d cljs.core.first(seq__27610__$1);\nvar map__27637__$1 \x3d cljs.core.__destructure_map(map__27637);\nvar watch \x3d map__27637__$1;\nvar key \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27637__$1,new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587));\nvar handler \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27637__$1,new cljs.core.Keyword(null,\x22handler\x22,\x22handler\x22,-195596612));\nif(shadow.object.alive_QMARK_(this$__$1)){\n(handler.cljs$core$IFn$_invoke$arity$4 ? handler.cljs$core$IFn$_invoke$arity$4(key,this$__$1,old,new$) : handler.call(null, key,this$__$1,old,new$));\n} else {\n}\n\n\nvar G__28093 \x3d cljs.core.next(seq__27610__$1);\nvar G__28094 \x3d null;\nvar G__28095 \x3d (0);\nvar G__28096 \x3d (0);\nseq__27610 \x3d G__28093;\nchunk__27611 \x3d G__28094;\ncount__27612 \x3d G__28095;\ni__27613 \x3d G__28096;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(shadow.object.ObjectRef.prototype.shadow$object$IObject$_destroy_BANG_$arity$2 \x3d (function (this$,cause){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar parent_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.object.instance_parent),self__.id);\nvar seq__27641_28098 \x3d cljs.core.seq(shadow.object.get_children(this$__$1));\nvar chunk__27642_28099 \x3d null;\nvar count__27643_28100 \x3d (0);\nvar i__27644_28101 \x3d (0);\nwhile(true){\nif((i__27644_28101 \x3c count__27643_28100)){\nvar child_28102 \x3d chunk__27642_28099.cljs$core$IIndexed$_nth$arity$2(null, i__27644_28101);\nshadow.object._destroy_BANG_(child_28102,new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779));\n\n\nvar G__28103 \x3d seq__27641_28098;\nvar G__28104 \x3d chunk__27642_28099;\nvar G__28105 \x3d count__27643_28100;\nvar G__28106 \x3d (i__27644_28101 + (1));\nseq__27641_28098 \x3d G__28103;\nchunk__27642_28099 \x3d G__28104;\ncount__27643_28100 \x3d G__28105;\ni__27644_28101 \x3d G__28106;\ncontinue;\n} else {\nvar temp__5804__auto___28107 \x3d cljs.core.seq(seq__27641_28098);\nif(temp__5804__auto___28107){\nvar seq__27641_28108__$1 \x3d temp__5804__auto___28107;\nif(cljs.core.chunked_seq_QMARK_(seq__27641_28108__$1)){\nvar c__5525__auto___28109 \x3d cljs.core.chunk_first(seq__27641_28108__$1);\nvar G__28110 \x3d cljs.core.chunk_rest(seq__27641_28108__$1);\nvar G__28111 \x3d c__5525__auto___28109;\nvar G__28112 \x3d cljs.core.count(c__5525__auto___28109);\nvar G__28113 \x3d (0);\nseq__27641_28098 \x3d G__28110;\nchunk__27642_28099 \x3d G__28111;\ncount__27643_28100 \x3d G__28112;\ni__27644_28101 \x3d G__28113;\ncontinue;\n} else {\nvar child_28114 \x3d cljs.core.first(seq__27641_28108__$1);\nshadow.object._destroy_BANG_(child_28114,new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779));\n\n\nvar G__28115 \x3d cljs.core.next(seq__27641_28108__$1);\nvar G__28116 \x3d null;\nvar G__28117 \x3d (0);\nvar G__28118 \x3d (0);\nseq__27641_28098 \x3d G__28115;\nchunk__27642_28099 \x3d G__28116;\ncount__27643_28100 \x3d G__28117;\ni__27644_28101 \x3d G__28118;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nshadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic(this$__$1,new cljs.core.Keyword(null,\x22destroy\x22,\x22destroy\x22,-843660405),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cause], 0));\n\nshadow.object.dom_destroy(this$__$1,cause);\n\nvar return_value_28119 \x3d new cljs.core.Keyword(\x22shadow.object\x22,\x22return-value\x22,\x22shadow.object/return-value\x22,1397593360).cljs$core$IFn$_invoke$arity$1(this$__$1);\nif((return_value_28119 \x3d\x3d null)){\n} else {\ncljs.core.async.put_BANG_.cljs$core$IFn$_invoke$arity$2(self__.result_chan,return_value_28119);\n}\n\ncljs.core.async.close_BANG_(self__.result_chan);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(shadow.object.instances,cljs.core.dissoc,self__.id);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(shadow.object.instance_parent,cljs.core.dissoc,self__.id);\n\nif(cljs.core.truth_(parent_id)){\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(shadow.object.instance_children,cljs.core.update_in,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [parent_id], null),cljs.core.disj,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.id], 0));\n} else {\nreturn null;\n}\n}));\n\n(shadow.object.ObjectRef.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn self__.data;\n}));\n\n(shadow.object.ObjectRef.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22id\x22,\x22id\x22,252129435,null),new cljs.core.Symbol(null,\x22type\x22,\x22type\x22,-1480165421,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22data\x22,\x22data\x22,1407862150,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22watches\x22,\x22watches\x22,1367433992,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null)),new cljs.core.Symbol(null,\x22result-chan\x22,\x22result-chan\x22,3070926,null)], null);\n}));\n\n(shadow.object.ObjectRef.cljs$lang$type \x3d true);\n\n(shadow.object.ObjectRef.cljs$lang$ctorStr \x3d \x22shadow.object/ObjectRef\x22);\n\n(shadow.object.ObjectRef.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.object/ObjectRef\x22);\n}));\n\n/**\n * Positional factory function for shadow.object/ObjectRef.\n */\nshadow.object.__GT_ObjectRef \x3d (function shadow$object$__GT_ObjectRef(id,type,data,watches,result_chan){\nreturn (new shadow.object.ObjectRef(id,type,data,watches,result_chan));\n});\n\nshadow.object.add_reaction_BANG_ \x3d (function shadow$object$add_reaction_BANG_(var_args){\nvar G__27667 \x3d arguments.length;\nswitch (G__27667) {\ncase 3:\nreturn shadow.object.add_reaction_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 2:\nreturn shadow.object.add_reaction_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.add_reaction_BANG_.cljs$core$IFn$_invoke$arity$3 \x3d (function (oref,ev,handler_fn){\nreturn shadow.object.add_reaction_BANG_.cljs$core$IFn$_invoke$arity$2(oref,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [ev,handler_fn], null));\n}));\n\n(shadow.object.add_reaction_BANG_.cljs$core$IFn$_invoke$arity$2 \x3d (function (oref,list){\nreturn shadow.object.update_BANG_.cljs$core$IFn$_invoke$arity$variadic(oref,cljs.core.update_in,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22shadow.object\x22,\x22reactions\x22,\x22shadow.object/reactions\x22,1966199633)], null),shadow.object.merge_reactions,list], 0));\n}));\n\n(shadow.object.add_reaction_BANG_.cljs$lang$maxFixedArity \x3d 3);\n\nshadow.object.bind_change \x3d (function shadow$object$bind_change(var_args){\nvar G__27676 \x3d arguments.length;\nswitch (G__27676) {\ncase 3:\nreturn shadow.object.bind_change.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.object.bind_change.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.bind_change.cljs$core$IFn$_invoke$arity$3 \x3d (function (oref,attr,callback){\nreturn shadow.object.bind_change.cljs$core$IFn$_invoke$arity$4(oref,attr,callback,cljs.core.gensym.cljs$core$IFn$_invoke$arity$1(\x22bind-change\x22));\n}));\n\n(shadow.object.bind_change.cljs$core$IFn$_invoke$arity$4 \x3d (function (oref,attr,callback,watch_key){\nif((((!((oref \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d oref.shadow$object$IObject$))))?true:(((!oref.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(shadow.object.IObject,oref):false)):cljs.core.native_satisfies_QMARK_(shadow.object.IObject,oref))){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22binding currently only supports shadow objects, other atoms might leak, may add later\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22oref\x22,\x22oref\x22,-1547494840),oref,new cljs.core.Keyword(null,\x22attr\x22,\x22attr\x22,-604132353),attr], null));\n}\n\nvar attr__$1 \x3d ((cljs.core.sequential_QMARK_(attr))?attr:new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [attr], null));\nreturn cljs.core.add_watch(oref,watch_key,(function shadow$object$bind_change_watch(_,___$1,old,new$){\nvar ov \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(old,attr__$1);\nvar nv \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(new$,attr__$1);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ov,nv)){\nreturn null;\n} else {\nreturn (callback.cljs$core$IFn$_invoke$arity$2 ? callback.cljs$core$IFn$_invoke$arity$2(ov,nv) : callback.call(null, ov,nv));\n}\n}));\n}));\n\n(shadow.object.bind_change.cljs$lang$maxFixedArity \x3d 4);\n\nshadow.object.dom_enter \x3d (function shadow$object$dom_enter(parent,child){\nshadow.dom.append.cljs$core$IFn$_invoke$arity$2(parent,child);\n\nif(cljs.core.truth_(shadow.dom.contains_QMARK_.cljs$core$IFn$_invoke$arity$1(parent))){\nreturn shadow.object.notify_tree_BANG_(child,new cljs.core.Keyword(\x22dom\x22,\x22entered\x22,\x22dom/entered\x22,506699596));\n} else {\nreturn null;\n}\n});\nshadow.object.create \x3d (function shadow$object$create(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28131 \x3d arguments.length;\nvar i__5727__auto___28132 \x3d (0);\nwhile(true){\nif((i__5727__auto___28132 \x3c len__5726__auto___28131)){\nargs__5732__auto__.push((arguments[i__5727__auto___28132]));\n\nvar G__28133 \x3d (i__5727__auto___28132 + (1));\ni__5727__auto___28132 \x3d G__28133;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn shadow.object.create.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(shadow.object.create.cljs$core$IFn$_invoke$arity$variadic \x3d (function (type,args,node_children){\nif(cljs.core.contains_QMARK_(cljs.core.deref(shadow.object.object_defs),type)){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2([\x22cannot create unknown child type: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(type)].join(\x27\x27),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),type,new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),args], null));\n}\n\nif(cljs.core.map_QMARK_(args)){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22so/create second arg must be a map\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),args], null));\n}\n\nvar oid \x3d shadow.object.next_id();\nvar parent \x3d new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(args);\nvar result_chan \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\nvar odef \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.object.object_defs),type);\nvar obj \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(shadow.object.merge_defaults(cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(args,new cljs.core.Keyword(\x22shadow.object\x22,\x22object-id\x22,\x22shadow.object/object-id\x22,-685993804),oid,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.object\x22,\x22reactions\x22,\x22shadow.object/reactions\x22,1966199633),cljs.core.get.cljs$core$IFn$_invoke$arity$3(odef,new cljs.core.Keyword(\x22shadow.object\x22,\x22reactions\x22,\x22shadow.object/reactions\x22,1966199633),cljs.core.PersistentArrayMap.EMPTY)], 0)),type),new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22dom\x22,\x22dom\x22,-1236537922)], 0));\nvar oref \x3d (new shadow.object.ObjectRef(oid,type,obj,cljs.core.PersistentVector.EMPTY,result_chan));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(shadow.object.instances,cljs.core.assoc,oid,oref);\n\nif(cljs.core.truth_(parent)){\nshadow.object.set_parent_BANG_(oref,parent);\n} else {\n}\n\nshadow.object.notify_BANG_(oref,new cljs.core.Keyword(null,\x22init\x22,\x22init\x22,-1875481434));\n\nvar dom_events_28136 \x3d new cljs.core.Keyword(\x22dom\x22,\x22events\x22,\x22dom/events\x22,1793437527).cljs$core$IFn$_invoke$arity$2(odef,cljs.core.PersistentVector.EMPTY);\nvar temp__5802__auto___28137 \x3d new cljs.core.Keyword(null,\x22dom\x22,\x22dom\x22,-1236537922).cljs$core$IFn$_invoke$arity$1(args);\nif(cljs.core.truth_(temp__5802__auto___28137)){\nvar dom_28138 \x3d temp__5802__auto___28137;\nshadow.dom.set_data(dom_28138,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid);\n\nshadow.object.bind_dom_events(oref,dom_28138,dom_events_28136);\n\nshadow.object.update_BANG_.cljs$core$IFn$_invoke$arity$variadic(oref,cljs.core.assoc,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311),dom_28138], 0));\n\nshadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic(oref,new cljs.core.Keyword(\x22dom\x22,\x22init\x22,\x22dom/init\x22,-1875647652),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([dom_28138], 0));\n} else {\nvar temp__5804__auto___28139 \x3d new cljs.core.Keyword(null,\x22dom\x22,\x22dom\x22,-1236537922).cljs$core$IFn$_invoke$arity$1(odef);\nif(cljs.core.truth_(temp__5804__auto___28139)){\nvar dom_fn_28140 \x3d temp__5804__auto___28139;\nvar dom_28141 \x3d (function (){var G__27697 \x3d (dom_fn_28140.cljs$core$IFn$_invoke$arity$2 ? dom_fn_28140.cljs$core$IFn$_invoke$arity$2(oref,node_children) : dom_fn_28140.call(null, oref,node_children));\nreturn (shadow.dom.build.cljs$core$IFn$_invoke$arity$1 ? shadow.dom.build.cljs$core$IFn$_invoke$arity$1(G__27697) : shadow.dom.build.call(null, G__27697));\n})();\nshadow.dom.set_data(dom_28141,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid);\n\nshadow.object.update_BANG_.cljs$core$IFn$_invoke$arity$variadic(oref,cljs.core.assoc,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.object\x22,\x22dom\x22,\x22shadow.object/dom\x22,-1238263311),dom_28141], 0));\n\nshadow.object.bind_dom_events(oref,dom_28141,dom_events_28136);\n\nshadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic(oref,new cljs.core.Keyword(\x22dom\x22,\x22init\x22,\x22dom/init\x22,-1875647652),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([dom_28141], 0));\n} else {\n}\n}\n\nvar temp__5804__auto___28142 \x3d new cljs.core.Keyword(null,\x22watch\x22,\x22watch\x22,380988277).cljs$core$IFn$_invoke$arity$1(odef);\nif(cljs.core.truth_(temp__5804__auto___28142)){\nvar watches_28143 \x3d temp__5804__auto___28142;\nvar seq__27701_28144 \x3d cljs.core.seq(cljs.core.partition.cljs$core$IFn$_invoke$arity$2((2),watches_28143));\nvar chunk__27702_28145 \x3d null;\nvar count__27703_28146 \x3d (0);\nvar i__27704_28147 \x3d (0);\nwhile(true){\nif((i__27704_28147 \x3c count__27703_28146)){\nvar vec__27723_28148 \x3d chunk__27702_28145.cljs$core$IIndexed$_nth$arity$2(null, i__27704_28147);\nvar attr_28149 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27723_28148,(0),null);\nvar handler_28150 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27723_28148,(1),null);\nshadow.object.bind_change.cljs$core$IFn$_invoke$arity$3(oref,attr_28149,((function (seq__27701_28144,chunk__27702_28145,count__27703_28146,i__27704_28147,vec__27723_28148,attr_28149,handler_28150,watches_28143,temp__5804__auto___28142,oid,parent,result_chan,odef,obj,oref){\nreturn (function (old,new$){\nreturn (handler_28150.cljs$core$IFn$_invoke$arity$3 ? handler_28150.cljs$core$IFn$_invoke$arity$3(oref,old,new$) : handler_28150.call(null, oref,old,new$));\n});})(seq__27701_28144,chunk__27702_28145,count__27703_28146,i__27704_28147,vec__27723_28148,attr_28149,handler_28150,watches_28143,temp__5804__auto___28142,oid,parent,result_chan,odef,obj,oref))\n);\n\n\nvar G__28152 \x3d seq__27701_28144;\nvar G__28153 \x3d chunk__27702_28145;\nvar G__28154 \x3d count__27703_28146;\nvar G__28155 \x3d (i__27704_28147 + (1));\nseq__27701_28144 \x3d G__28152;\nchunk__27702_28145 \x3d G__28153;\ncount__27703_28146 \x3d G__28154;\ni__27704_28147 \x3d G__28155;\ncontinue;\n} else {\nvar temp__5804__auto___28156__$1 \x3d cljs.core.seq(seq__27701_28144);\nif(temp__5804__auto___28156__$1){\nvar seq__27701_28158__$1 \x3d temp__5804__auto___28156__$1;\nif(cljs.core.chunked_seq_QMARK_(seq__27701_28158__$1)){\nvar c__5525__auto___28159 \x3d cljs.core.chunk_first(seq__27701_28158__$1);\nvar G__28161 \x3d cljs.core.chunk_rest(seq__27701_28158__$1);\nvar G__28162 \x3d c__5525__auto___28159;\nvar G__28163 \x3d cljs.core.count(c__5525__auto___28159);\nvar G__28164 \x3d (0);\nseq__27701_28144 \x3d G__28161;\nchunk__27702_28145 \x3d G__28162;\ncount__27703_28146 \x3d G__28163;\ni__27704_28147 \x3d G__28164;\ncontinue;\n} else {\nvar vec__27732_28165 \x3d cljs.core.first(seq__27701_28158__$1);\nvar attr_28166 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27732_28165,(0),null);\nvar handler_28167 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27732_28165,(1),null);\nshadow.object.bind_change.cljs$core$IFn$_invoke$arity$3(oref,attr_28166,((function (seq__27701_28144,chunk__27702_28145,count__27703_28146,i__27704_28147,vec__27732_28165,attr_28166,handler_28167,seq__27701_28158__$1,temp__5804__auto___28156__$1,watches_28143,temp__5804__auto___28142,oid,parent,result_chan,odef,obj,oref){\nreturn (function (old,new$){\nreturn (handler_28167.cljs$core$IFn$_invoke$arity$3 ? handler_28167.cljs$core$IFn$_invoke$arity$3(oref,old,new$) : handler_28167.call(null, oref,old,new$));\n});})(seq__27701_28144,chunk__27702_28145,count__27703_28146,i__27704_28147,vec__27732_28165,attr_28166,handler_28167,seq__27701_28158__$1,temp__5804__auto___28156__$1,watches_28143,temp__5804__auto___28142,oid,parent,result_chan,odef,obj,oref))\n);\n\n\nvar G__28169 \x3d cljs.core.next(seq__27701_28158__$1);\nvar G__28170 \x3d null;\nvar G__28171 \x3d (0);\nvar G__28173 \x3d (0);\nseq__27701_28144 \x3d G__28169;\nchunk__27702_28145 \x3d G__28170;\ncount__27703_28146 \x3d G__28171;\ni__27704_28147 \x3d G__28173;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n} else {\n}\n\nreturn oref;\n}));\n\n(shadow.object.create.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(shadow.object.create.cljs$lang$applyTo \x3d (function (seq27687){\nvar G__27688 \x3d cljs.core.first(seq27687);\nvar seq27687__$1 \x3d cljs.core.next(seq27687);\nvar G__27689 \x3d cljs.core.first(seq27687__$1);\nvar seq27687__$2 \x3d cljs.core.next(seq27687__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__27688,G__27689,seq27687__$2);\n}));\n\n/**\n * [oref attr node-gen] produces a node via (node-gen new-value)\n * watches obj for changes and replaces the generated node on change (node-gen defaults to str)\n * \n *   only use if the node has no attached behavior like clicks, use bind with an extra object for those\n */\nshadow.object.bind_simple \x3d (function shadow$object$bind_simple(var_args){\nvar G__27748 \x3d arguments.length;\nswitch (G__27748) {\ncase 2:\nreturn shadow.object.bind_simple.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn shadow.object.bind_simple.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.bind_simple.cljs$core$IFn$_invoke$arity$2 \x3d (function (oref,attr){\nreturn shadow.object.bind_simple.cljs$core$IFn$_invoke$arity$3(oref,attr,cljs.core.str);\n}));\n\n(shadow.object.bind_simple.cljs$core$IFn$_invoke$arity$3 \x3d (function (oref,attr,node_gen){\nvar attr__$1 \x3d ((cljs.core.sequential_QMARK_(attr))?attr:new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [attr], null));\nvar node_get \x3d (function (p1__27739_SHARP_){\nvar G__27758 \x3d (node_gen.cljs$core$IFn$_invoke$arity$1 ? node_gen.cljs$core$IFn$_invoke$arity$1(p1__27739_SHARP_) : node_gen.call(null, p1__27739_SHARP_));\nreturn (shadow.dom.build.cljs$core$IFn$_invoke$arity$1 ? shadow.dom.build.cljs$core$IFn$_invoke$arity$1(G__27758) : shadow.dom.build.call(null, G__27758));\n});\nvar node \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(node_get(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(oref,attr__$1)));\nvar bind_key \x3d cljs.core.gensym.cljs$core$IFn$_invoke$arity$1(\x22bind\x22);\nshadow.object.bind_change.cljs$core$IFn$_invoke$arity$3(oref,attr__$1,(function (old,new$){\nvar new_node \x3d node_get(new$);\nvar current_node \x3d cljs.core.deref(node);\nshadow.dom.replace_node(current_node,new_node);\n\nreturn cljs.core.reset_BANG_(node,new_node);\n}));\n\nreturn cljs.core.deref(node);\n}));\n\n(shadow.object.bind_simple.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * bind the given attribute a child item\n *   the item will be recreated whenever the value changes (old one will be destroyed)\n */\nshadow.object.bind \x3d (function shadow$object$bind(oref,attr,item_type,item_key,item_attrs){\nvar attr__$1 \x3d ((cljs.core.sequential_QMARK_(attr))?attr:new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [attr], null));\nvar curval \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(oref,attr__$1);\nvar make_child_fn \x3d (function (value){\nreturn shadow.object.create(item_type,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([item_attrs,cljs.core.PersistentArrayMap.createAsIfByAssoc([new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),oref,item_key,value])], 0)));\n});\nvar child \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(make_child_fn(curval));\nshadow.object.bind_change.cljs$core$IFn$_invoke$arity$3(oref,attr__$1,(function (old,new$){\nvar new_child \x3d make_child_fn(new$);\nvar current_node \x3d cljs.core.deref(child);\nshadow.dom.replace_node(current_node,new_child);\n\nshadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$1(cljs.core.deref(child));\n\ncljs.core.reset_BANG_(child,new_child);\n\nreturn (shadow.object.notify_down_BANG_.cljs$core$IFn$_invoke$arity$2 ? shadow.object.notify_down_BANG_.cljs$core$IFn$_invoke$arity$2(new_child,new cljs.core.Keyword(\x22dom\x22,\x22entered\x22,\x22dom/entered\x22,506699596)) : shadow.object.notify_down_BANG_.call(null, new_child,new cljs.core.Keyword(\x22dom\x22,\x22entered\x22,\x22dom/entered\x22,506699596)));\n}));\n\nreturn cljs.core.deref(child);\n});\nshadow.object.coll_destroy_children \x3d (function shadow$object$coll_destroy_children(children,c,diff){\nvar seq__27775_28196 \x3d cljs.core.seq(cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(children,(c + diff),c));\nvar chunk__27776_28197 \x3d null;\nvar count__27777_28198 \x3d (0);\nvar i__27778_28199 \x3d (0);\nwhile(true){\nif((i__27778_28199 \x3c count__27777_28198)){\nvar obj_28202 \x3d chunk__27776_28197.cljs$core$IIndexed$_nth$arity$2(null, i__27778_28199);\nvar obj_28204__$1 \x3d shadow.object.get_from_dom(obj_28202);\nshadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$1(obj_28204__$1);\n\n\nvar G__28205 \x3d seq__27775_28196;\nvar G__28206 \x3d chunk__27776_28197;\nvar G__28207 \x3d count__27777_28198;\nvar G__28208 \x3d (i__27778_28199 + (1));\nseq__27775_28196 \x3d G__28205;\nchunk__27776_28197 \x3d G__28206;\ncount__27777_28198 \x3d G__28207;\ni__27778_28199 \x3d G__28208;\ncontinue;\n} else {\nvar temp__5804__auto___28209 \x3d cljs.core.seq(seq__27775_28196);\nif(temp__5804__auto___28209){\nvar seq__27775_28212__$1 \x3d temp__5804__auto___28209;\nif(cljs.core.chunked_seq_QMARK_(seq__27775_28212__$1)){\nvar c__5525__auto___28214 \x3d cljs.core.chunk_first(seq__27775_28212__$1);\nvar G__28215 \x3d cljs.core.chunk_rest(seq__27775_28212__$1);\nvar G__28216 \x3d c__5525__auto___28214;\nvar G__28217 \x3d cljs.core.count(c__5525__auto___28214);\nvar G__28218 \x3d (0);\nseq__27775_28196 \x3d G__28215;\nchunk__27776_28197 \x3d G__28216;\ncount__27777_28198 \x3d G__28217;\ni__27778_28199 \x3d G__28218;\ncontinue;\n} else {\nvar obj_28219 \x3d cljs.core.first(seq__27775_28212__$1);\nvar obj_28220__$1 \x3d shadow.object.get_from_dom(obj_28219);\nshadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$1(obj_28220__$1);\n\n\nvar G__28225 \x3d cljs.core.next(seq__27775_28212__$1);\nvar G__28226 \x3d null;\nvar G__28227 \x3d (0);\nvar G__28228 \x3d (0);\nseq__27775_28196 \x3d G__28225;\nchunk__27776_28197 \x3d G__28226;\ncount__27777_28198 \x3d G__28227;\ni__27778_28199 \x3d G__28228;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(children,(0),(c + diff));\n});\nshadow.object.bind_children \x3d (function shadow$object$bind_children(var_args){\nvar G__27807 \x3d arguments.length;\nswitch (G__27807) {\ncase 5:\nreturn shadow.object.bind_children.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ncase 6:\nreturn shadow.object.bind_children.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.object.bind_children.cljs$core$IFn$_invoke$arity$5 \x3d (function (node,parent,attr,item_type,item_key){\nreturn shadow.object.bind_children.cljs$core$IFn$_invoke$arity$6(node,parent,attr,item_type,item_key,(function (p1__27797_SHARP_){\nreturn cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2(cljs.core.vector,p1__27797_SHARP_);\n}));\n}));\n\n(shadow.object.bind_children.cljs$core$IFn$_invoke$arity$6 \x3d (function (node,parent,attr,item_type,item_key,coll_transform){\nvar attr__$1 \x3d ((cljs.core.sequential_QMARK_(attr))?attr:new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [attr], null));\nvar update_children \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(true);\nvar coll_dom \x3d (shadow.dom.build.cljs$core$IFn$_invoke$arity$1 ? shadow.dom.build.cljs$core$IFn$_invoke$arity$1(node) : shadow.dom.build.call(null, node));\nvar make_item_fn \x3d (function (p__27823){\nvar vec__27824 \x3d p__27823;\nvar key \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27824,(0),null);\nvar val \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27824,(1),null);\nvar obj \x3d shadow.object.create(item_type,cljs.core.PersistentArrayMap.createAsIfByAssoc([new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),parent,new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-path\x22,\x22shadow.object/coll-path\x22,1583850048),attr__$1,new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-key\x22,\x22shadow.object/coll-key\x22,827543616),key,new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-item-key\x22,\x22shadow.object/coll-item-key\x22,1888444366),item_key,item_key,val]));\nshadow.object.bind_change.cljs$core$IFn$_invoke$arity$3(obj,item_key,(function (old,new$){\nvar parent_key \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(attr__$1,new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-key\x22,\x22shadow.object/coll-key\x22,827543616).cljs$core$IFn$_invoke$arity$1(obj));\n(shadow.object.log.cljs$core$IFn$_invoke$arity$6 ? shadow.object.log.cljs$core$IFn$_invoke$arity$6(\x22direct child update\x22,parent,obj,key,parent_key,new$) : shadow.object.log.call(null, \x22direct child update\x22,parent,obj,key,parent_key,new$));\n\ncljs.core.reset_BANG_(update_children,false);\n\nshadow.object.update_BANG_.cljs$core$IFn$_invoke$arity$variadic(parent,cljs.core.assoc_in,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([parent_key,new$], 0));\n\nreturn cljs.core.reset_BANG_(update_children,true);\n}));\n\nreturn obj;\n});\nvar seq__27832_28247 \x3d cljs.core.seq((function (){var G__27843 \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(parent,attr__$1);\nreturn (coll_transform.cljs$core$IFn$_invoke$arity$1 ? coll_transform.cljs$core$IFn$_invoke$arity$1(G__27843) : coll_transform.call(null, G__27843));\n})());\nvar chunk__27833_28248 \x3d null;\nvar count__27834_28249 \x3d (0);\nvar i__27835_28250 \x3d (0);\nwhile(true){\nif((i__27835_28250 \x3c count__27834_28249)){\nvar item_28253 \x3d chunk__27833_28248.cljs$core$IIndexed$_nth$arity$2(null, i__27835_28250);\nshadow.object.dom_enter(coll_dom,make_item_fn(item_28253));\n\n\nvar G__28254 \x3d seq__27832_28247;\nvar G__28255 \x3d chunk__27833_28248;\nvar G__28256 \x3d count__27834_28249;\nvar G__28257 \x3d (i__27835_28250 + (1));\nseq__27832_28247 \x3d G__28254;\nchunk__27833_28248 \x3d G__28255;\ncount__27834_28249 \x3d G__28256;\ni__27835_28250 \x3d G__28257;\ncontinue;\n} else {\nvar temp__5804__auto___28258 \x3d cljs.core.seq(seq__27832_28247);\nif(temp__5804__auto___28258){\nvar seq__27832_28259__$1 \x3d temp__5804__auto___28258;\nif(cljs.core.chunked_seq_QMARK_(seq__27832_28259__$1)){\nvar c__5525__auto___28261 \x3d cljs.core.chunk_first(seq__27832_28259__$1);\nvar G__28262 \x3d cljs.core.chunk_rest(seq__27832_28259__$1);\nvar G__28263 \x3d c__5525__auto___28261;\nvar G__28264 \x3d cljs.core.count(c__5525__auto___28261);\nvar G__28265 \x3d (0);\nseq__27832_28247 \x3d G__28262;\nchunk__27833_28248 \x3d G__28263;\ncount__27834_28249 \x3d G__28264;\ni__27835_28250 \x3d G__28265;\ncontinue;\n} else {\nvar item_28266 \x3d cljs.core.first(seq__27832_28259__$1);\nshadow.object.dom_enter(coll_dom,make_item_fn(item_28266));\n\n\nvar G__28267 \x3d cljs.core.next(seq__27832_28259__$1);\nvar G__28268 \x3d null;\nvar G__28269 \x3d (0);\nvar G__28270 \x3d (0);\nseq__27832_28247 \x3d G__28267;\nchunk__27833_28248 \x3d G__28268;\ncount__27834_28249 \x3d G__28269;\ni__27835_28250 \x3d G__28270;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nshadow.object.bind_change.cljs$core$IFn$_invoke$arity$3(parent,attr__$1,(function shadow$object$bind_children_watch(old,new$){\nif(cljs.core.truth_(cljs.core.deref(update_children))){\nvar children \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,shadow.dom.children(coll_dom));\nvar new_coll \x3d cljs.core.vec((coll_transform.cljs$core$IFn$_invoke$arity$1 ? coll_transform.cljs$core$IFn$_invoke$arity$1(new$) : coll_transform.call(null, new$)));\nvar count_children \x3d cljs.core.count(children);\nvar count_new \x3d cljs.core.count(new$);\nvar diff \x3d (count_new - count_children);\nvar children__$1 \x3d (((diff \x3c (0)))?shadow.object.coll_destroy_children(children,count_children,diff):children);\nvar count_children__$1 \x3d (function (){var x__5090__auto__ \x3d count_new;\nvar y__5091__auto__ \x3d count_children;\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})();\nvar n__5593__auto___28271 \x3d count_children__$1;\nvar idx_28272 \x3d (0);\nwhile(true){\nif((idx_28272 \x3c n__5593__auto___28271)){\nvar cn_28273 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(children__$1,idx_28272);\nvar cc_28274 \x3d shadow.object.get_from_dom(cn_28273);\nvar ckey_28275 \x3d new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-key\x22,\x22shadow.object/coll-key\x22,827543616).cljs$core$IFn$_invoke$arity$1(cc_28274);\nvar cval_28276 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cc_28274,item_key);\nvar vec__27857_28277 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(new_coll,idx_28272);\nvar nkey_28278 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27857_28277,(0),null);\nvar nval_28279 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27857_28277,(1),null);\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ckey_28275,nkey_28278)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cval_28276,nval_28279)))){\n} else {\nvar new_obj_28282 \x3d make_item_fn(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nkey_28278,nval_28279], null));\nshadow.dom.replace_node(cn_28273,new_obj_28282);\n\nshadow.object.destroy_BANG_.cljs$core$IFn$_invoke$arity$1(cc_28274);\n\nshadow.object.notify_tree_BANG_(new_obj_28282,new cljs.core.Keyword(\x22dom\x22,\x22entered\x22,\x22dom/entered\x22,506699596));\n}\n\nvar G__28283 \x3d (idx_28272 + (1));\nidx_28272 \x3d G__28283;\ncontinue;\n} else {\n}\nbreak;\n}\n\nif((diff \x3e (0))){\nvar seq__27866_28284 \x3d cljs.core.seq(cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(new_coll,count_children__$1,count_new));\nvar chunk__27867_28285 \x3d null;\nvar count__27868_28286 \x3d (0);\nvar i__27869_28287 \x3d (0);\nwhile(true){\nif((i__27869_28287 \x3c count__27868_28286)){\nvar item_28289 \x3d chunk__27867_28285.cljs$core$IIndexed$_nth$arity$2(null, i__27869_28287);\nshadow.object.dom_enter(coll_dom,make_item_fn(item_28289));\n\n\nvar G__28290 \x3d seq__27866_28284;\nvar G__28291 \x3d chunk__27867_28285;\nvar G__28292 \x3d count__27868_28286;\nvar G__28293 \x3d (i__27869_28287 + (1));\nseq__27866_28284 \x3d G__28290;\nchunk__27867_28285 \x3d G__28291;\ncount__27868_28286 \x3d G__28292;\ni__27869_28287 \x3d G__28293;\ncontinue;\n} else {\nvar temp__5804__auto___28294 \x3d cljs.core.seq(seq__27866_28284);\nif(temp__5804__auto___28294){\nvar seq__27866_28295__$1 \x3d temp__5804__auto___28294;\nif(cljs.core.chunked_seq_QMARK_(seq__27866_28295__$1)){\nvar c__5525__auto___28296 \x3d cljs.core.chunk_first(seq__27866_28295__$1);\nvar G__28298 \x3d cljs.core.chunk_rest(seq__27866_28295__$1);\nvar G__28299 \x3d c__5525__auto___28296;\nvar G__28300 \x3d cljs.core.count(c__5525__auto___28296);\nvar G__28301 \x3d (0);\nseq__27866_28284 \x3d G__28298;\nchunk__27867_28285 \x3d G__28299;\ncount__27868_28286 \x3d G__28300;\ni__27869_28287 \x3d G__28301;\ncontinue;\n} else {\nvar item_28302 \x3d cljs.core.first(seq__27866_28295__$1);\nshadow.object.dom_enter(coll_dom,make_item_fn(item_28302));\n\n\nvar G__28303 \x3d cljs.core.next(seq__27866_28295__$1);\nvar G__28304 \x3d null;\nvar G__28305 \x3d (0);\nvar G__28306 \x3d (0);\nseq__27866_28284 \x3d G__28303;\nchunk__27867_28285 \x3d G__28304;\ncount__27868_28286 \x3d G__28305;\ni__27869_28287 \x3d G__28306;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n} else {\n}\n\nreturn shadow.object.notify_BANG_(parent,new cljs.core.Keyword(null,\x22bind-children-update\x22,\x22bind-children-update\x22,-1610690160));\n} else {\nreturn null;\n}\n}));\n\nreturn coll_dom;\n}));\n\n(shadow.object.bind_children.cljs$lang$maxFixedArity \x3d 6);\n\nshadow.object.remove_in_parent_BANG_ \x3d (function shadow$object$remove_in_parent_BANG_(oref){\nvar parent \x3d shadow.object.get_parent(oref);\nvar key \x3d new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-key\x22,\x22shadow.object/coll-key\x22,827543616).cljs$core$IFn$_invoke$arity$1(oref);\nvar value \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(oref,new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-item-key\x22,\x22shadow.object/coll-item-key\x22,1888444366).cljs$core$IFn$_invoke$arity$1(oref));\nvar path \x3d new cljs.core.Keyword(\x22shadow.object\x22,\x22coll-path\x22,\x22shadow.object/coll-path\x22,1583850048).cljs$core$IFn$_invoke$arity$1(oref);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d key;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn path;\n} else {\nreturn and__5000__auto__;\n}\n})())){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22remove-in-parent! should only be called from items created via so/bind-children\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22oref\x22,\x22oref\x22,-1547494840),oref], null));\n}\n\nvar coll \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(parent,path);\nvar new_coll \x3d shadow.util.remove_item_from_coll(coll,key,value);\nreturn shadow.object.notify_BANG_.cljs$core$IFn$_invoke$arity$variadic(parent,new cljs.core.Keyword(\x22bind\x22,\x22update\x22,\x22bind/update\x22,1048601733),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([path,new_coll], 0));\n});\nshadow.object.inspect_BANG_ \x3d (function shadow$object$inspect_BANG_(oref){\nvar G__27880 \x3d \x22inspect!\x22;\nvar G__27881 \x3d shadow.object._id(oref);\nvar G__27882 \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(shadow.object._type(oref));\nvar G__27883 \x3d cljs.core.clj__GT_js(cljs.core.deref(shadow.object._data(oref)));\nreturn (shadow.object.info.cljs$core$IFn$_invoke$arity$4 ? shadow.object.info.cljs$core$IFn$_invoke$arity$4(G__27880,G__27881,G__27882,G__27883) : shadow.object.info.call(null, G__27880,G__27881,G__27882,G__27883));\n});\nshadow.object.dump_BANG_ \x3d (function shadow$object$dump_BANG_(){\n(shadow.object.info.cljs$core$IFn$_invoke$arity$1 ? shadow.object.info.cljs$core$IFn$_invoke$arity$1(\x22--------------- LIVE OBJECTS ------------\x22) : shadow.object.info.call(null, \x22--------------- LIVE OBJECTS ------------\x22));\n\nvar seq__27884_28312 \x3d cljs.core.seq(cljs.core.seq(cljs.core.deref(shadow.object.instances)));\nvar chunk__27885_28313 \x3d null;\nvar count__27886_28314 \x3d (0);\nvar i__27887_28315 \x3d (0);\nwhile(true){\nif((i__27887_28315 \x3c count__27886_28314)){\nvar vec__27907_28317 \x3d chunk__27885_28313.cljs$core$IIndexed$_nth$arity$2(null, i__27887_28315);\nvar id_28318 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27907_28317,(0),null);\nvar oref_28319 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27907_28317,(1),null);\nvar G__27910_28320 \x3d \x22dump\x22;\nvar G__27911_28321 \x3d id_28318;\nvar G__27912_28322 \x3d cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([shadow.object._type(oref_28319)], 0));\nvar G__27913_28323 \x3d cljs.core.deref(shadow.object._data(oref_28319));\n(shadow.object.info.cljs$core$IFn$_invoke$arity$4 ? shadow.object.info.cljs$core$IFn$_invoke$arity$4(G__27910_28320,G__27911_28321,G__27912_28322,G__27913_28323) : shadow.object.info.call(null, G__27910_28320,G__27911_28321,G__27912_28322,G__27913_28323));\n\n\nvar G__28324 \x3d seq__27884_28312;\nvar G__28325 \x3d chunk__27885_28313;\nvar G__28326 \x3d count__27886_28314;\nvar G__28327 \x3d (i__27887_28315 + (1));\nseq__27884_28312 \x3d G__28324;\nchunk__27885_28313 \x3d G__28325;\ncount__27886_28314 \x3d G__28326;\ni__27887_28315 \x3d G__28327;\ncontinue;\n} else {\nvar temp__5804__auto___28329 \x3d cljs.core.seq(seq__27884_28312);\nif(temp__5804__auto___28329){\nvar seq__27884_28332__$1 \x3d temp__5804__auto___28329;\nif(cljs.core.chunked_seq_QMARK_(seq__27884_28332__$1)){\nvar c__5525__auto___28333 \x3d cljs.core.chunk_first(seq__27884_28332__$1);\nvar G__28334 \x3d cljs.core.chunk_rest(seq__27884_28332__$1);\nvar G__28335 \x3d c__5525__auto___28333;\nvar G__28336 \x3d cljs.core.count(c__5525__auto___28333);\nvar G__28337 \x3d (0);\nseq__27884_28312 \x3d G__28334;\nchunk__27885_28313 \x3d G__28335;\ncount__27886_28314 \x3d G__28336;\ni__27887_28315 \x3d G__28337;\ncontinue;\n} else {\nvar vec__27914_28338 \x3d cljs.core.first(seq__27884_28332__$1);\nvar id_28339 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27914_28338,(0),null);\nvar oref_28340 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27914_28338,(1),null);\nvar G__27917_28341 \x3d \x22dump\x22;\nvar G__27918_28342 \x3d id_28339;\nvar G__27919_28343 \x3d cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([shadow.object._type(oref_28340)], 0));\nvar G__27920_28344 \x3d cljs.core.deref(shadow.object._data(oref_28340));\n(shadow.object.info.cljs$core$IFn$_invoke$arity$4 ? shadow.object.info.cljs$core$IFn$_invoke$arity$4(G__27917_28341,G__27918_28342,G__27919_28343,G__27920_28344) : shadow.object.info.call(null, G__27917_28341,G__27918_28342,G__27919_28343,G__27920_28344));\n\n\nvar G__28345 \x3d cljs.core.next(seq__27884_28332__$1);\nvar G__28346 \x3d null;\nvar G__28347 \x3d (0);\nvar G__28348 \x3d (0);\nseq__27884_28312 \x3d G__28345;\nchunk__27885_28313 \x3d G__28346;\ncount__27886_28314 \x3d G__28347;\ni__27887_28315 \x3d G__28348;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn (shadow.object.info.cljs$core$IFn$_invoke$arity$1 ? shadow.object.info.cljs$core$IFn$_invoke$arity$1(\x22--------------- //LIVE OBJECTS ------------\x22) : shadow.object.info.call(null, \x22--------------- //LIVE OBJECTS ------------\x22));\n});\ngoog.exportSymbol(\x27shadow.object.dump_BANG_\x27, shadow.object.dump_BANG_);\n");
SHADOW_ENV.evalLoad("shadow.animate.js", true, "goog.provide(\x27shadow.animate\x27);\n\n/**\n * @interface\n */\nshadow.animate.Animation \x3d function(){};\n\nvar shadow$animate$Animation$_animate_from$dyn_28693 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.animate._animate_from[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate._animate_from[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22Animation.-animate-from\x22,this$);\n}\n}\n});\n/**\n * return a map of {attr initial-value}\n */\nshadow.animate._animate_from \x3d (function shadow$animate$_animate_from(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$animate$Animation$_animate_from$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$animate$Animation$_animate_from$arity$1(this$);\n} else {\nreturn shadow$animate$Animation$_animate_from$dyn_28693(this$);\n}\n});\n\nvar shadow$animate$Animation$_animate_to$dyn_28694 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.animate._animate_to[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate._animate_to[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22Animation.-animate-to\x22,this$);\n}\n}\n});\n/**\n * return a map of {attr target-value}\n */\nshadow.animate._animate_to \x3d (function shadow$animate$_animate_to(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$animate$Animation$_animate_to$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$animate$Animation$_animate_to$arity$1(this$);\n} else {\nreturn shadow$animate$Animation$_animate_to$dyn_28694(this$);\n}\n});\n\nvar shadow$animate$Animation$_animate_toggles$dyn_28695 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.animate._animate_toggles[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate._animate_toggles[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22Animation.-animate-toggles\x22,this$);\n}\n}\n});\n/**\n * return a map of {attr target-value}\n */\nshadow.animate._animate_toggles \x3d (function shadow$animate$_animate_toggles(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$animate$Animation$_animate_toggles$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$animate$Animation$_animate_toggles$arity$1(this$);\n} else {\nreturn shadow$animate$Animation$_animate_toggles$dyn_28695(this$);\n}\n});\n\nvar shadow$animate$Animation$_animate_timings$dyn_28696 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.animate._animate_timings[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate._animate_timings[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22Animation.-animate-timings\x22,this$);\n}\n}\n});\n/**\n * return a map of {attr timing-function}\n */\nshadow.animate._animate_timings \x3d (function shadow$animate$_animate_timings(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$animate$Animation$_animate_timings$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$animate$Animation$_animate_timings$arity$1(this$);\n} else {\nreturn shadow$animate$Animation$_animate_timings$dyn_28696(this$);\n}\n});\n\nvar shadow$animate$Animation$_animate_delays$dyn_28698 \x3d (function (this$){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.animate._animate_delays[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5351__auto__.call(null, this$));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate._animate_delays[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__5349__auto__.call(null, this$));\n} else {\nthrow cljs.core.missing_protocol(\x22Animation.-animate-delays\x22,this$);\n}\n}\n});\n/**\n * return a map of {attr transition-delay}\n */\nshadow.animate._animate_delays \x3d (function shadow$animate$_animate_delays(this$){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$animate$Animation$_animate_delays$arity$1 \x3d\x3d null)))))){\nreturn this$.shadow$animate$Animation$_animate_delays$arity$1(this$);\n} else {\nreturn shadow$animate$Animation$_animate_delays$dyn_28698(this$);\n}\n});\n\nshadow.animate.transition_string \x3d (function shadow$animate$transition_string(duration,adef){\nvar timings \x3d shadow.animate._animate_timings(adef);\nvar delays \x3d shadow.animate._animate_delays(adef);\nreturn clojure.string.join.cljs$core$IFn$_invoke$arity$2(\x22, \x22,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p__28076){\nvar vec__28078 \x3d p__28076;\nvar attr \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28078,(0),null);\nvar timing \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28078,(1),null);\nreturn [cljs.core.name(attr),\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(duration),\x22ms\x22,\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(timing),(function (){var delay \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(delays,attr);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d delay;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (delay \x3e (0));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn [\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(delay),\x22ms\x22].join(\x27\x27);\n} else {\nreturn null;\n}\n})()].join(\x27\x27);\n}),timings));\n});\n\n/**\n * @interface\n */\nshadow.animate.IAnimator \x3d function(){};\n\nvar shadow$animate$IAnimator$get_duration$dyn_28699 \x3d (function (animator){\nvar x__5350__auto__ \x3d (((animator \x3d\x3d null))?null:animator);\nvar m__5351__auto__ \x3d (shadow.animate.get_duration[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5351__auto__.call(null, animator));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate.get_duration[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5349__auto__.call(null, animator));\n} else {\nthrow cljs.core.missing_protocol(\x22IAnimator.get-duration\x22,animator);\n}\n}\n});\nshadow.animate.get_duration \x3d (function shadow$animate$get_duration(animator){\nif((((!((animator \x3d\x3d null)))) \x26\x26 ((!((animator.shadow$animate$IAnimator$get_duration$arity$1 \x3d\x3d null)))))){\nreturn animator.shadow$animate$IAnimator$get_duration$arity$1(animator);\n} else {\nreturn shadow$animate$IAnimator$get_duration$dyn_28699(animator);\n}\n});\n\nvar shadow$animate$IAnimator$init_BANG_$dyn_28701 \x3d (function (animator){\nvar x__5350__auto__ \x3d (((animator \x3d\x3d null))?null:animator);\nvar m__5351__auto__ \x3d (shadow.animate.init_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5351__auto__.call(null, animator));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate.init_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5349__auto__.call(null, animator));\n} else {\nthrow cljs.core.missing_protocol(\x22IAnimator.init!\x22,animator);\n}\n}\n});\n/**\n * apply the initial values\n */\nshadow.animate.init_BANG_ \x3d (function shadow$animate$init_BANG_(animator){\nif((((!((animator \x3d\x3d null)))) \x26\x26 ((!((animator.shadow$animate$IAnimator$init_BANG_$arity$1 \x3d\x3d null)))))){\nreturn animator.shadow$animate$IAnimator$init_BANG_$arity$1(animator);\n} else {\nreturn shadow$animate$IAnimator$init_BANG_$dyn_28701(animator);\n}\n});\n\nvar shadow$animate$IAnimator$start_BANG_$dyn_28704 \x3d (function (animator){\nvar x__5350__auto__ \x3d (((animator \x3d\x3d null))?null:animator);\nvar m__5351__auto__ \x3d (shadow.animate.start_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5351__auto__.call(null, animator));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate.start_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5349__auto__.call(null, animator));\n} else {\nthrow cljs.core.missing_protocol(\x22IAnimator.start!\x22,animator);\n}\n}\n});\n/**\n * start the animation, must return a channel that closes once the animation is done\n */\nshadow.animate.start_BANG_ \x3d (function shadow$animate$start_BANG_(animator){\nif((((!((animator \x3d\x3d null)))) \x26\x26 ((!((animator.shadow$animate$IAnimator$start_BANG_$arity$1 \x3d\x3d null)))))){\nreturn animator.shadow$animate$IAnimator$start_BANG_$arity$1(animator);\n} else {\nreturn shadow$animate$IAnimator$start_BANG_$dyn_28704(animator);\n}\n});\n\nvar shadow$animate$IAnimator$finish_BANG_$dyn_28711 \x3d (function (animator){\nvar x__5350__auto__ \x3d (((animator \x3d\x3d null))?null:animator);\nvar m__5351__auto__ \x3d (shadow.animate.finish_BANG_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5351__auto__.call(null, animator));\n} else {\nvar m__5349__auto__ \x3d (shadow.animate.finish_BANG_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(animator) : m__5349__auto__.call(null, animator));\n} else {\nthrow cljs.core.missing_protocol(\x22IAnimator.finish!\x22,animator);\n}\n}\n});\n/**\n * cleanup\n */\nshadow.animate.finish_BANG_ \x3d (function shadow$animate$finish_BANG_(animator){\nif((((!((animator \x3d\x3d null)))) \x26\x26 ((!((animator.shadow$animate$IAnimator$finish_BANG_$arity$1 \x3d\x3d null)))))){\nreturn animator.shadow$animate$IAnimator$finish_BANG_$arity$1(animator);\n} else {\nreturn shadow$animate$IAnimator$finish_BANG_$dyn_28711(animator);\n}\n});\n\n\n/**\n* @constructor\n * @implements {shadow.animate.IAnimator}\n*/\nshadow.animate.Animator \x3d (function (duration,items){\nthis.duration \x3d duration;\nthis.items \x3d items;\n});\n(shadow.animate.Animator.prototype.shadow$animate$IAnimator$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.Animator.prototype.shadow$animate$IAnimator$get_duration$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.duration;\n}));\n\n(shadow.animate.Animator.prototype.shadow$animate$IAnimator$init_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar n__5593__auto__ \x3d self__.items.length;\nvar i__19764__auto__ \x3d (0);\nwhile(true){\nif((i__19764__auto__ \x3c n__5593__auto__)){\nvar map__28151_28718 \x3d (self__.items[i__19764__auto__]);\nvar map__28151_28719__$1 \x3d cljs.core.__destructure_map(map__28151_28718);\nvar el_28720 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28151_28719__$1,new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118));\nvar from_28721 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28151_28719__$1,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044));\ngoog.style.setStyle(el_28720,from_28721);\n\nvar G__28722 \x3d (i__19764__auto__ + (1));\ni__19764__auto__ \x3d G__28722;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(shadow.animate.Animator.prototype.shadow$animate$IAnimator$start_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar n__5593__auto__ \x3d self__.items.length;\nvar i__19764__auto__ \x3d (0);\nwhile(true){\nif((i__19764__auto__ \x3c n__5593__auto__)){\nvar map__28191_28723 \x3d (self__.items[i__19764__auto__]);\nvar map__28191_28724__$1 \x3d cljs.core.__destructure_map(map__28191_28723);\nvar el_28725 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28191_28724__$1,new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118));\nvar to_28726 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28191_28724__$1,new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007));\nvar transition_28727 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28191_28724__$1,new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007));\n(to_28726[\x22transition\x22] \x3d transition_28727);\n\ngoog.style.setStyle(el_28725,to_28726);\n\nvar G__28728 \x3d (i__19764__auto__ + (1));\ni__19764__auto__ \x3d G__28728;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(shadow.animate.Animator.prototype.shadow$animate$IAnimator$finish_BANG_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar n__5593__auto__ \x3d self__.items.length;\nvar i__19764__auto__ \x3d (0);\nwhile(true){\nif((i__19764__auto__ \x3c n__5593__auto__)){\nvar map__28201_28729 \x3d (self__.items[i__19764__auto__]);\nvar map__28201_28730__$1 \x3d cljs.core.__destructure_map(map__28201_28729);\nvar el_28731 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28201_28730__$1,new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118));\nvar toggles_28732 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28201_28730__$1,new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479));\n(toggles_28732[\x22transition\x22] \x3d null);\n\ngoog.style.setStyle(el_28731,toggles_28732);\n\nvar G__28733 \x3d (i__19764__auto__ + (1));\ni__19764__auto__ \x3d G__28733;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n}));\n\n(shadow.animate.Animator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22duration\x22,\x22duration\x22,-1210334701,null),new cljs.core.Symbol(null,\x22items\x22,\x22items\x22,-1622480831,null)], null);\n}));\n\n(shadow.animate.Animator.cljs$lang$type \x3d true);\n\n(shadow.animate.Animator.cljs$lang$ctorStr \x3d \x22shadow.animate/Animator\x22);\n\n(shadow.animate.Animator.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/Animator\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/Animator.\n */\nshadow.animate.__GT_Animator \x3d (function shadow$animate$__GT_Animator(duration,items){\nreturn (new shadow.animate.Animator(duration,items));\n});\n\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\nshadow.animate.AnimationStep \x3d (function (el,from,to,toggles,transition,__meta,__extmap,__hash){\nthis.el \x3d el;\nthis.from \x3d from;\nthis.to \x3d to;\nthis.toggles \x3d toggles;\nthis.transition \x3d transition;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(shadow.animate.AnimationStep.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k28244,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__28288 \x3d k28244;\nvar G__28288__$1 \x3d (((G__28288 instanceof cljs.core.Keyword))?G__28288.fqn:null);\nswitch (G__28288__$1) {\ncase \x22el\x22:\nreturn self__.el;\n\nbreak;\ncase \x22from\x22:\nreturn self__.from;\n\nbreak;\ncase \x22to\x22:\nreturn self__.to;\n\nbreak;\ncase \x22toggles\x22:\nreturn self__.toggles;\n\nbreak;\ncase \x22transition\x22:\nreturn self__.transition;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k28244,else__5303__auto__);\n\n}\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__28308){\nvar vec__28309 \x3d p__28308;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28309,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28309,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#shadow.animate.AnimationStep{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),self__.el],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),self__.from],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),self__.to],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479),self__.toggles],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007),self__.transition],null))], null),self__.__extmap));\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__28243){\nvar self__ \x3d this;\nvar G__28243__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__28243__$1,5,new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479),new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new shadow.animate.AnimationStep(self__.el,self__.from,self__.to,self__.toggles,self__.transition,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (5 + cljs.core.count(self__.__extmap));\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (630436239 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this28245,other28246){\nvar self__ \x3d this;\nvar this28245__$1 \x3d this;\nreturn (((!((other28246 \x3d\x3d null)))) \x26\x26 ((((this28245__$1.constructor \x3d\x3d\x3d other28246.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28245__$1.el,other28246.el)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28245__$1.from,other28246.from)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28245__$1.to,other28246.to)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28245__$1.toggles,other28246.toggles)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28245__$1.transition,other28246.transition)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28245__$1.__extmap,other28246.__extmap)))))))))))))));\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),null,new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007),null,new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479),null,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),null,new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new shadow.animate.AnimationStep(self__.el,self__.from,self__.to,self__.toggles,self__.transition,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k28244){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__28380 \x3d k28244;\nvar G__28380__$1 \x3d (((G__28380 instanceof cljs.core.Keyword))?G__28380.fqn:null);\nswitch (G__28380__$1) {\ncase \x22el\x22:\ncase \x22from\x22:\ncase \x22to\x22:\ncase \x22toggles\x22:\ncase \x22transition\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k28244);\n\n}\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__28243){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__28382 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__28383 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__28382.cljs$core$IFn$_invoke$arity$2 ? pred__28382.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),expr__28383) : pred__28382.call(null, new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),expr__28383)))){\nreturn (new shadow.animate.AnimationStep(G__28243,self__.from,self__.to,self__.toggles,self__.transition,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__28382.cljs$core$IFn$_invoke$arity$2 ? pred__28382.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),expr__28383) : pred__28382.call(null, new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),expr__28383)))){\nreturn (new shadow.animate.AnimationStep(self__.el,G__28243,self__.to,self__.toggles,self__.transition,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__28382.cljs$core$IFn$_invoke$arity$2 ? pred__28382.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),expr__28383) : pred__28382.call(null, new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),expr__28383)))){\nreturn (new shadow.animate.AnimationStep(self__.el,self__.from,G__28243,self__.toggles,self__.transition,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__28382.cljs$core$IFn$_invoke$arity$2 ? pred__28382.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479),expr__28383) : pred__28382.call(null, new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479),expr__28383)))){\nreturn (new shadow.animate.AnimationStep(self__.el,self__.from,self__.to,G__28243,self__.transition,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__28382.cljs$core$IFn$_invoke$arity$2 ? pred__28382.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007),expr__28383) : pred__28382.call(null, new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007),expr__28383)))){\nreturn (new shadow.animate.AnimationStep(self__.el,self__.from,self__.to,self__.toggles,G__28243,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new shadow.animate.AnimationStep(self__.el,self__.from,self__.to,self__.toggles,self__.transition,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__28243),null));\n}\n}\n}\n}\n}\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),self__.el,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),self__.from,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),self__.to,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479),self__.toggles,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007),self__.transition,null))], null),self__.__extmap));\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__28243){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new shadow.animate.AnimationStep(self__.el,self__.from,self__.to,self__.toggles,self__.transition,G__28243,self__.__extmap,self__.__hash));\n}));\n\n(shadow.animate.AnimationStep.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(shadow.animate.AnimationStep.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22el\x22,\x22el\x22,22330409,null),new cljs.core.Symbol(null,\x22from\x22,\x22from\x22,-839142725,null),new cljs.core.Symbol(null,\x22to\x22,\x22to\x22,1832630534,null),new cljs.core.Symbol(null,\x22toggles\x22,\x22toggles\x22,-1576526290,null),new cljs.core.Symbol(null,\x22transition\x22,\x22transition\x22,-1888743762,null)], null);\n}));\n\n(shadow.animate.AnimationStep.cljs$lang$type \x3d true);\n\n(shadow.animate.AnimationStep.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22shadow.animate/AnimationStep\x22,null,(1),null));\n}));\n\n(shadow.animate.AnimationStep.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22shadow.animate/AnimationStep\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/AnimationStep.\n */\nshadow.animate.__GT_AnimationStep \x3d (function shadow$animate$__GT_AnimationStep(el,from,to,toggles,transition){\nreturn (new shadow.animate.AnimationStep(el,from,to,toggles,transition,null,null,null));\n});\n\n/**\n * Factory function for shadow.animate/AnimationStep, taking a map of keywords to field values.\n */\nshadow.animate.map__GT_AnimationStep \x3d (function shadow$animate$map__GT_AnimationStep(G__28260){\nvar extmap__5342__auto__ \x3d (function (){var G__28393 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__28260,new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479),new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007)], 0));\nif(cljs.core.record_QMARK_(G__28260)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__28393);\n} else {\nreturn G__28393;\n}\n})();\nreturn (new shadow.animate.AnimationStep(new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118).cljs$core$IFn$_invoke$arity$1(G__28260),new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044).cljs$core$IFn$_invoke$arity$1(G__28260),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007).cljs$core$IFn$_invoke$arity$1(G__28260),new cljs.core.Keyword(null,\x22toggles\x22,\x22toggles\x22,1077909479).cljs$core$IFn$_invoke$arity$1(G__28260),new cljs.core.Keyword(null,\x22transition\x22,\x22transition\x22,765692007).cljs$core$IFn$_invoke$arity$1(G__28260),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\nshadow.animate.setup \x3d (function shadow$animate$setup(duration,elements){\nvar items \x3d cljs.core.into_array.cljs$core$IFn$_invoke$arity$1((function (){var iter__5480__auto__ \x3d (function shadow$animate$setup_$_iter__28401(s__28402){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__28402__$1 \x3d s__28402;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__28402__$1);\nif(temp__5804__auto__){\nvar s__28402__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__28402__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__28402__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__28404 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__28403 \x3d (0);\nwhile(true){\nif((i__28403 \x3c size__5479__auto__)){\nvar vec__28406 \x3d cljs.core._nth(c__5478__auto__,i__28403);\nvar el \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28406,(0),null);\nvar adef \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28406,(1),null);\ncljs.core.chunk_append(b__28404,(function (){\nif((((!((adef \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d adef.shadow$animate$Animation$))))?true:(((!adef.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(shadow.animate.Animation,adef):false)):cljs.core.native_satisfies_QMARK_(shadow.animate.Animation,adef))){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid animation\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),el,new cljs.core.Keyword(null,\x22animation\x22,\x22animation\x22,-1248293244),adef], null));\n}\n\nvar from \x3d shadow.animate._animate_from(adef);\nvar to \x3d shadow.animate._animate_to(adef);\nvar toggles \x3d shadow.animate._animate_toggles(adef);\nreturn (new shadow.animate.AnimationStep(shadow.dom.dom_node(el),cljs.core.clj__GT_js(from),cljs.core.clj__GT_js(to),cljs.core.clj__GT_js(toggles),shadow.animate.transition_string(duration,adef),null,null,null));\n})()\n);\n\nvar G__28742 \x3d (i__28403 + (1));\ni__28403 \x3d G__28742;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__28404),shadow$animate$setup_$_iter__28401(cljs.core.chunk_rest(s__28402__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__28404),null);\n}\n} else {\nvar vec__28412 \x3d cljs.core.first(s__28402__$2);\nvar el \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28412,(0),null);\nvar adef \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28412,(1),null);\nreturn cljs.core.cons((function (){\nif((((!((adef \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d adef.shadow$animate$Animation$))))?true:(((!adef.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(shadow.animate.Animation,adef):false)):cljs.core.native_satisfies_QMARK_(shadow.animate.Animation,adef))){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid animation\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22el\x22,\x22el\x22,-1618201118),el,new cljs.core.Keyword(null,\x22animation\x22,\x22animation\x22,-1248293244),adef], null));\n}\n\nvar from \x3d shadow.animate._animate_from(adef);\nvar to \x3d shadow.animate._animate_to(adef);\nvar toggles \x3d shadow.animate._animate_toggles(adef);\nreturn (new shadow.animate.AnimationStep(shadow.dom.dom_node(el),cljs.core.clj__GT_js(from),cljs.core.clj__GT_js(to),cljs.core.clj__GT_js(toggles),shadow.animate.transition_string(duration,adef),null,null,null));\n})()\n,shadow$animate$setup_$_iter__28401(cljs.core.rest(s__28402__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(elements);\n})());\nreturn (new shadow.animate.Animator(duration,items));\n});\nshadow.animate.continue_BANG_ \x3d (function shadow$animate$continue_BANG_(animator){\nshadow.animate.start_BANG_(animator);\n\nvar c__22634__auto__ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_28442){\nvar state_val_28443 \x3d (state_28442[(1)]);\nif((state_val_28443 \x3d\x3d\x3d (1))){\nvar inst_28435 \x3d shadow.animate.get_duration(animator);\nvar inst_28436 \x3d cljs.core.async.timeout(inst_28435);\nvar state_28442__$1 \x3d state_28442;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_28442__$1,(2),inst_28436);\n} else {\nif((state_val_28443 \x3d\x3d\x3d (2))){\nvar inst_28438 \x3d (state_28442[(2)]);\nvar inst_28439 \x3d shadow.animate.finish_BANG_(animator);\nvar state_28442__$1 \x3d (function (){var statearr_28451 \x3d state_28442;\n(statearr_28451[(7)] \x3d inst_28439);\n\n(statearr_28451[(8)] \x3d inst_28438);\n\nreturn statearr_28451;\n})();\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_28442__$1,new cljs.core.Keyword(null,\x22done\x22,\x22done\x22,-889844188));\n} else {\nreturn null;\n}\n}\n});\nreturn (function() {\nvar shadow$animate$continue_BANG__$_state_machine__21555__auto__ \x3d null;\nvar shadow$animate$continue_BANG__$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_28454 \x3d [null,null,null,null,null,null,null,null,null];\n(statearr_28454[(0)] \x3d shadow$animate$continue_BANG__$_state_machine__21555__auto__);\n\n(statearr_28454[(1)] \x3d (1));\n\nreturn statearr_28454;\n});\nvar shadow$animate$continue_BANG__$_state_machine__21555__auto____1 \x3d (function (state_28442){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_28442);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e28456){var ex__21558__auto__ \x3d e28456;\nvar statearr_28461_28744 \x3d state_28442;\n(statearr_28461_28744[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_28442[(4)]))){\nvar statearr_28462_28745 \x3d state_28442;\n(statearr_28462_28745[(1)] \x3d cljs.core.first((state_28442[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__28746 \x3d state_28442;\nstate_28442 \x3d G__28746;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\nshadow$animate$continue_BANG__$_state_machine__21555__auto__ \x3d function(state_28442){\nswitch(arguments.length){\ncase 0:\nreturn shadow$animate$continue_BANG__$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn shadow$animate$continue_BANG__$_state_machine__21555__auto____1.call(this,state_28442);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nshadow$animate$continue_BANG__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d shadow$animate$continue_BANG__$_state_machine__21555__auto____0;\nshadow$animate$continue_BANG__$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d shadow$animate$continue_BANG__$_state_machine__21555__auto____1;\nreturn shadow$animate$continue_BANG__$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_28468 \x3d f__22635__auto__();\n(statearr_28468[(6)] \x3d c__22634__auto__);\n\nreturn statearr_28468;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\nreturn c__22634__auto__;\n});\nshadow.animate.start \x3d (function shadow$animate$start(duration,elements){\nvar animator \x3d shadow.animate.setup(duration,elements);\nanimator.shadow$animate$IAnimator$init_BANG_$arity$1(null, );\n\nreturn shadow.animate.continue_BANG_(animator);\n});\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28493 \x3d (function (attr,from,to,timing,delay,meta28494){\nthis.attr \x3d attr;\nthis.from \x3d from;\nthis.to \x3d to;\nthis.timing \x3d timing;\nthis.delay \x3d delay;\nthis.meta28494 \x3d meta28494;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28493.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28495,meta28494__$1){\nvar self__ \x3d this;\nvar _28495__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28493(self__.attr,self__.from,self__.to,self__.timing,self__.delay,meta28494__$1));\n}));\n\n(shadow.animate.t_shadow$animate28493.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28495){\nvar self__ \x3d this;\nvar _28495__$1 \x3d this;\nreturn self__.meta28494;\n}));\n\n(shadow.animate.t_shadow$animate28493.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28493.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([self__.attr,self__.from]);\n}));\n\n(shadow.animate.t_shadow$animate28493.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([self__.attr,self__.to]);\n}));\n\n(shadow.animate.t_shadow$animate28493.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28493.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([self__.attr,self__.timing]);\n}));\n\n(shadow.animate.t_shadow$animate28493.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([self__.attr,self__.delay]);\n}));\n\n(shadow.animate.t_shadow$animate28493.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22attr\x22,\x22attr\x22,1036399174,null),new cljs.core.Symbol(null,\x22from\x22,\x22from\x22,-839142725,null),new cljs.core.Symbol(null,\x22to\x22,\x22to\x22,1832630534,null),new cljs.core.Symbol(null,\x22timing\x22,\x22timing\x22,-208693668,null),new cljs.core.Symbol(null,\x22delay\x22,\x22delay\x22,1066306308,null),new cljs.core.Symbol(null,\x22meta28494\x22,\x22meta28494\x22,1428486055,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28493.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28493.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28493\x22);\n\n(shadow.animate.t_shadow$animate28493.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28493\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28493.\n */\nshadow.animate.__GT_t_shadow$animate28493 \x3d (function shadow$animate$__GT_t_shadow$animate28493(attr,from,to,timing,delay,meta28494){\nreturn (new shadow.animate.t_shadow$animate28493(attr,from,to,timing,delay,meta28494));\n});\n\n\n/**\n * transition the given attr from -\x3e to using timing function and delay\n * timing defaults to ease, delay to 0\n */\nshadow.animate.transition \x3d (function shadow$animate$transition(var_args){\nvar G__28484 \x3d arguments.length;\nswitch (G__28484) {\ncase 3:\nreturn shadow.animate.transition.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.animate.transition.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn shadow.animate.transition.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.animate.transition.cljs$core$IFn$_invoke$arity$3 \x3d (function (attr,from,to){\nreturn shadow.animate.transition.cljs$core$IFn$_invoke$arity$5(attr,from,to,\x22ease\x22,(0));\n}));\n\n(shadow.animate.transition.cljs$core$IFn$_invoke$arity$4 \x3d (function (attr,from,to,timing){\nreturn shadow.animate.transition.cljs$core$IFn$_invoke$arity$5(attr,from,to,timing,(0));\n}));\n\n(shadow.animate.transition.cljs$core$IFn$_invoke$arity$5 \x3d (function (attr,from,to,timing,delay){\nreturn (new shadow.animate.t_shadow$animate28493(attr,from,to,timing,delay,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(shadow.animate.transition.cljs$lang$maxFixedArity \x3d 5);\n\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28500 \x3d (function (attr,from,to,meta28501){\nthis.attr \x3d attr;\nthis.from \x3d from;\nthis.to \x3d to;\nthis.meta28501 \x3d meta28501;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28500.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28502,meta28501__$1){\nvar self__ \x3d this;\nvar _28502__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28500(self__.attr,self__.from,self__.to,meta28501__$1));\n}));\n\n(shadow.animate.t_shadow$animate28500.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28502){\nvar self__ \x3d this;\nvar _28502__$1 \x3d this;\nreturn self__.meta28501;\n}));\n\n(shadow.animate.t_shadow$animate28500.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28500.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28500.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([self__.attr,self__.from]);\n}));\n\n(shadow.animate.t_shadow$animate28500.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([self__.attr,self__.to]);\n}));\n\n(shadow.animate.t_shadow$animate28500.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28500.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28500.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22attr\x22,\x22attr\x22,1036399174,null),new cljs.core.Symbol(null,\x22from\x22,\x22from\x22,-839142725,null),new cljs.core.Symbol(null,\x22to\x22,\x22to\x22,1832630534,null),new cljs.core.Symbol(null,\x22meta28501\x22,\x22meta28501\x22,-423020263,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28500.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28500.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28500\x22);\n\n(shadow.animate.t_shadow$animate28500.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28500\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28500.\n */\nshadow.animate.__GT_t_shadow$animate28500 \x3d (function shadow$animate$__GT_t_shadow$animate28500(attr,from,to,meta28501){\nreturn (new shadow.animate.t_shadow$animate28500(attr,from,to,meta28501));\n});\n\n\nshadow.animate.toggle \x3d (function shadow$animate$toggle(attr,from,to){\nreturn (new shadow.animate.t_shadow$animate28500(attr,from,to,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28524 \x3d (function (attrs,meta28525){\nthis.attrs \x3d attrs;\nthis.meta28525 \x3d meta28525;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28524.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28526,meta28525__$1){\nvar self__ \x3d this;\nvar _28526__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28524(self__.attrs,meta28525__$1));\n}));\n\n(shadow.animate.t_shadow$animate28524.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28526){\nvar self__ \x3d this;\nvar _28526__$1 \x3d this;\nreturn self__.meta28525;\n}));\n\n(shadow.animate.t_shadow$animate28524.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28524.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28524.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.attrs;\n}));\n\n(shadow.animate.t_shadow$animate28524.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28524.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28524.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28524.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22attrs\x22,\x22attrs\x22,-450137186,null),new cljs.core.Symbol(null,\x22meta28525\x22,\x22meta28525\x22,-252481293,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28524.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28524.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28524\x22);\n\n(shadow.animate.t_shadow$animate28524.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28524\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28524.\n */\nshadow.animate.__GT_t_shadow$animate28524 \x3d (function shadow$animate$__GT_t_shadow$animate28524(attrs,meta28525){\nreturn (new shadow.animate.t_shadow$animate28524(attrs,meta28525));\n});\n\n\n/**\n * set attr to value when the animation starts\n */\nshadow.animate.set_attr \x3d (function shadow$animate$set_attr(var_args){\nvar G__28522 \x3d arguments.length;\nswitch (G__28522) {\ncase 1:\nreturn shadow.animate.set_attr.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.animate.set_attr.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.animate.set_attr.cljs$core$IFn$_invoke$arity$1 \x3d (function (attrs){\nreturn (new shadow.animate.t_shadow$animate28524(attrs,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(shadow.animate.set_attr.cljs$core$IFn$_invoke$arity$2 \x3d (function (attr,value){\nreturn shadow.animate.set_attr.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.createAsIfByAssoc([attr,value]));\n}));\n\n(shadow.animate.set_attr.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28546 \x3d (function (attr,meta28547){\nthis.attr \x3d attr;\nthis.meta28547 \x3d meta28547;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28546.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28548,meta28547__$1){\nvar self__ \x3d this;\nvar _28548__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28546(self__.attr,meta28547__$1));\n}));\n\n(shadow.animate.t_shadow$animate28546.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28548){\nvar self__ \x3d this;\nvar _28548__$1 \x3d this;\nreturn self__.meta28547;\n}));\n\n(shadow.animate.t_shadow$animate28546.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28546.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28546.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28546.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([self__.attr,null]);\n}));\n\n(shadow.animate.t_shadow$animate28546.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28546.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28546.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22attr\x22,\x22attr\x22,1036399174,null),new cljs.core.Symbol(null,\x22meta28547\x22,\x22meta28547\x22,342077377,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28546.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28546.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28546\x22);\n\n(shadow.animate.t_shadow$animate28546.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28546\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28546.\n */\nshadow.animate.__GT_t_shadow$animate28546 \x3d (function shadow$animate$__GT_t_shadow$animate28546(attr,meta28547){\nreturn (new shadow.animate.t_shadow$animate28546(attr,meta28547));\n});\n\n\n/**\n * use to remove a given attribute style when the animation is finished\n * usually only needed to remove attributes we no longer need since they are probably\n * inherited and we only used for previous transitions\n */\nshadow.animate.delete_attr \x3d (function shadow$animate$delete_attr(attr){\nreturn (new shadow.animate.t_shadow$animate28546(attr,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28557 \x3d (function (transitions,to,from,toggles,timings,delays,temp__5802__auto__,meta28558){\nthis.transitions \x3d transitions;\nthis.to \x3d to;\nthis.from \x3d from;\nthis.toggles \x3d toggles;\nthis.timings \x3d timings;\nthis.delays \x3d delays;\nthis.temp__5802__auto__ \x3d temp__5802__auto__;\nthis.meta28558 \x3d meta28558;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28557.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28559,meta28558__$1){\nvar self__ \x3d this;\nvar _28559__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28557(self__.transitions,self__.to,self__.from,self__.toggles,self__.timings,self__.delays,self__.temp__5802__auto__,meta28558__$1));\n}));\n\n(shadow.animate.t_shadow$animate28557.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28559){\nvar self__ \x3d this;\nvar _28559__$1 \x3d this;\nreturn self__.meta28558;\n}));\n\n(shadow.animate.t_shadow$animate28557.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28557.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.from;\n}));\n\n(shadow.animate.t_shadow$animate28557.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.to;\n}));\n\n(shadow.animate.t_shadow$animate28557.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.toggles;\n}));\n\n(shadow.animate.t_shadow$animate28557.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.timings;\n}));\n\n(shadow.animate.t_shadow$animate28557.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.delays;\n}));\n\n(shadow.animate.t_shadow$animate28557.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 8, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22transitions\x22,\x22transitions\x22,-405684594,null),new cljs.core.Symbol(null,\x22to\x22,\x22to\x22,1832630534,null),new cljs.core.Symbol(null,\x22from\x22,\x22from\x22,-839142725,null),new cljs.core.Symbol(null,\x22toggles\x22,\x22toggles\x22,-1576526290,null),new cljs.core.Symbol(null,\x22timings\x22,\x22timings\x22,-569636600,null),new cljs.core.Symbol(null,\x22delays\x22,\x22delays\x22,-873843187,null),new cljs.core.Symbol(null,\x22temp__5802__auto__\x22,\x22temp__5802__auto__\x22,-1659442335,null),new cljs.core.Symbol(null,\x22meta28558\x22,\x22meta28558\x22,1660909267,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28557.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28557.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28557\x22);\n\n(shadow.animate.t_shadow$animate28557.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28557\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28557.\n */\nshadow.animate.__GT_t_shadow$animate28557 \x3d (function shadow$animate$__GT_t_shadow$animate28557(transitions,to,from,toggles,timings,delays,temp__5802__auto__,meta28558){\nreturn (new shadow.animate.t_shadow$animate28557(transitions,to,from,toggles,timings,delays,temp__5802__auto__,meta28558));\n});\n\n\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28604 \x3d (function (transitions,to,from,toggles,timings,delays,temp__5802__auto__,meta28605){\nthis.transitions \x3d transitions;\nthis.to \x3d to;\nthis.from \x3d from;\nthis.toggles \x3d toggles;\nthis.timings \x3d timings;\nthis.delays \x3d delays;\nthis.temp__5802__auto__ \x3d temp__5802__auto__;\nthis.meta28605 \x3d meta28605;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28604.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28606,meta28605__$1){\nvar self__ \x3d this;\nvar _28606__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28604(self__.transitions,self__.to,self__.from,self__.toggles,self__.timings,self__.delays,self__.temp__5802__auto__,meta28605__$1));\n}));\n\n(shadow.animate.t_shadow$animate28604.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28606){\nvar self__ \x3d this;\nvar _28606__$1 \x3d this;\nreturn self__.meta28605;\n}));\n\n(shadow.animate.t_shadow$animate28604.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28604.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.from;\n}));\n\n(shadow.animate.t_shadow$animate28604.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.to;\n}));\n\n(shadow.animate.t_shadow$animate28604.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.toggles;\n}));\n\n(shadow.animate.t_shadow$animate28604.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.timings;\n}));\n\n(shadow.animate.t_shadow$animate28604.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.delays;\n}));\n\n(shadow.animate.t_shadow$animate28604.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 8, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22transitions\x22,\x22transitions\x22,-405684594,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22to\x22,\x22to\x22,1832630534,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22any\x22,\x22any\x22,-948528346,null)], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22from\x22,\x22from\x22,-839142725,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22any\x22,\x22any\x22,-948528346,null)], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22toggles\x22,\x22toggles\x22,-1576526290,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22any\x22,\x22any\x22,-948528346,null)], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22timings\x22,\x22timings\x22,-569636600,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22any\x22,\x22any\x22,-948528346,null)], null)),cljs.core.with_meta(new cljs.core.Symbol(null,\x22delays\x22,\x22delays\x22,-873843187,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22any\x22,\x22any\x22,-948528346,null)], null)),new cljs.core.Symbol(null,\x22temp__5802__auto__\x22,\x22temp__5802__auto__\x22,-1659442335,null),new cljs.core.Symbol(null,\x22meta28605\x22,\x22meta28605\x22,-234209597,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28604.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28604.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28604\x22);\n\n(shadow.animate.t_shadow$animate28604.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28604\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28604.\n */\nshadow.animate.__GT_t_shadow$animate28604 \x3d (function shadow$animate$__GT_t_shadow$animate28604(transitions,to,from,toggles,timings,delays,temp__5802__auto__,meta28605){\nreturn (new shadow.animate.t_shadow$animate28604(transitions,to,from,toggles,timings,delays,temp__5802__auto__,meta28605));\n});\n\n\nshadow.animate.combine \x3d (function shadow$animate$combine(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28759 \x3d arguments.length;\nvar i__5727__auto___28760 \x3d (0);\nwhile(true){\nif((i__5727__auto___28760 \x3c len__5726__auto___28759)){\nargs__5732__auto__.push((arguments[i__5727__auto___28760]));\n\nvar G__28761 \x3d (i__5727__auto___28760 + (1));\ni__5727__auto___28760 \x3d G__28761;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn shadow.animate.combine.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(shadow.animate.combine.cljs$core$IFn$_invoke$arity$variadic \x3d (function (transitions){\nvar to \x3d cljs.core.PersistentArrayMap.EMPTY;\nvar from \x3d cljs.core.PersistentArrayMap.EMPTY;\nvar toggles \x3d cljs.core.PersistentArrayMap.EMPTY;\nvar timings \x3d cljs.core.PersistentArrayMap.EMPTY;\nvar delays \x3d cljs.core.PersistentArrayMap.EMPTY;\nvar transitions__$1 \x3d transitions;\nwhile(true){\nvar temp__5802__auto__ \x3d cljs.core.first(transitions__$1);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar adef \x3d temp__5802__auto__;\nvar G__28762 \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([to,shadow.animate._animate_to(adef)], 0));\nvar G__28763 \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([from,shadow.animate._animate_from(adef)], 0));\nvar G__28764 \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([toggles,shadow.animate._animate_toggles(adef)], 0));\nvar G__28765 \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([timings,shadow.animate._animate_timings(adef)], 0));\nvar G__28766 \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([delays,shadow.animate._animate_delays(adef)], 0));\nvar G__28767 \x3d cljs.core.rest(transitions__$1);\nto \x3d G__28762;\nfrom \x3d G__28763;\ntoggles \x3d G__28764;\ntimings \x3d G__28765;\ndelays \x3d G__28766;\ntransitions__$1 \x3d G__28767;\ncontinue;\n} else {\nreturn (new shadow.animate.t_shadow$animate28604(transitions__$1,to,from,toggles,timings,delays,temp__5802__auto__,cljs.core.PersistentArrayMap.EMPTY));\n}\nbreak;\n}\n}));\n\n(shadow.animate.combine.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(shadow.animate.combine.cljs$lang$applyTo \x3d (function (seq28556){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq28556));\n}));\n\nshadow.animate.fade_in \x3d (function shadow$animate$fade_in(var_args){\nvar G__28617 \x3d arguments.length;\nswitch (G__28617) {\ncase 0:\nreturn shadow.animate.fade_in.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn shadow.animate.fade_in.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.animate.fade_in.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn shadow.animate.fade_in.cljs$core$IFn$_invoke$arity$1(\x22ease-in\x22);\n}));\n\n(shadow.animate.fade_in.cljs$core$IFn$_invoke$arity$1 \x3d (function (timing_function){\nreturn shadow.animate.transition.cljs$core$IFn$_invoke$arity$4(new cljs.core.Keyword(null,\x22opacity\x22,\x22opacity\x22,397153780),\x220\x22,\x221\x22,timing_function);\n}));\n\n(shadow.animate.fade_in.cljs$lang$maxFixedArity \x3d 1);\n\nshadow.animate.fade_out \x3d (function shadow$animate$fade_out(var_args){\nvar G__28626 \x3d arguments.length;\nswitch (G__28626) {\ncase 0:\nreturn shadow.animate.fade_out.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 1:\nreturn shadow.animate.fade_out.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.animate.fade_out.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn shadow.animate.fade_in.cljs$core$IFn$_invoke$arity$1(\x22ease-out\x22);\n}));\n\n(shadow.animate.fade_out.cljs$core$IFn$_invoke$arity$1 \x3d (function (timing_function){\nreturn shadow.animate.transition.cljs$core$IFn$_invoke$arity$4(new cljs.core.Keyword(null,\x22opacity\x22,\x22opacity\x22,397153780),\x221\x22,\x220\x22,timing_function);\n}));\n\n(shadow.animate.fade_out.cljs$lang$maxFixedArity \x3d 1);\n\nshadow.animate.vendor_prefix \x3d goog.dom.vendor.getVendorPrefix();\nshadow.animate.vendor_transform \x3d cljs.core.keyword.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1(shadow.animate.vendor_prefix),\x22-transform\x22].join(\x27\x27));\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28641 \x3d (function (from,to,timing,delay,meta28642){\nthis.from \x3d from;\nthis.to \x3d to;\nthis.timing \x3d timing;\nthis.delay \x3d delay;\nthis.meta28642 \x3d meta28642;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28641.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28643,meta28642__$1){\nvar self__ \x3d this;\nvar _28643__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28641(self__.from,self__.to,self__.timing,self__.delay,meta28642__$1));\n}));\n\n(shadow.animate.t_shadow$animate28641.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28643){\nvar self__ \x3d this;\nvar _28643__$1 \x3d this;\nreturn self__.meta28642;\n}));\n\n(shadow.animate.t_shadow$animate28641.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28641.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22transform\x22,\x22transform\x22,1381301764),[\x22translateY(\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.from),\x22)\x22].join(\x27\x27)], null);\n}));\n\n(shadow.animate.t_shadow$animate28641.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22transform\x22,\x22transform\x22,1381301764),[\x22translateY(\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.to),\x22)\x22].join(\x27\x27)], null);\n}));\n\n(shadow.animate.t_shadow$animate28641.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([shadow.animate.vendor_transform,self__.timing]);\n}));\n\n(shadow.animate.t_shadow$animate28641.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28641.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([shadow.animate.vendor_transform,self__.delay]);\n}));\n\n(shadow.animate.t_shadow$animate28641.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22from\x22,\x22from\x22,-839142725,null),new cljs.core.Symbol(null,\x22to\x22,\x22to\x22,1832630534,null),new cljs.core.Symbol(null,\x22timing\x22,\x22timing\x22,-208693668,null),new cljs.core.Symbol(null,\x22delay\x22,\x22delay\x22,1066306308,null),new cljs.core.Symbol(null,\x22meta28642\x22,\x22meta28642\x22,-2094002261,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28641.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28641.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28641\x22);\n\n(shadow.animate.t_shadow$animate28641.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28641\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28641.\n */\nshadow.animate.__GT_t_shadow$animate28641 \x3d (function shadow$animate$__GT_t_shadow$animate28641(from,to,timing,delay,meta28642){\nreturn (new shadow.animate.t_shadow$animate28641(from,to,timing,delay,meta28642));\n});\n\n\nshadow.animate.translate_y \x3d (function shadow$animate$translate_y(var_args){\nvar G__28636 \x3d arguments.length;\nswitch (G__28636) {\ncase 3:\nreturn shadow.animate.translate_y.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.animate.translate_y.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.animate.translate_y.cljs$core$IFn$_invoke$arity$3 \x3d (function (from,to,timing){\nreturn shadow.animate.translate_y.cljs$core$IFn$_invoke$arity$4(from,to,timing,(0));\n}));\n\n(shadow.animate.translate_y.cljs$core$IFn$_invoke$arity$4 \x3d (function (from,to,timing,delay){\nreturn (new shadow.animate.t_shadow$animate28641(from,to,timing,delay,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(shadow.animate.translate_y.cljs$lang$maxFixedArity \x3d 4);\n\n\n/**\n* @constructor\n * @implements {shadow.animate.Animation}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\nshadow.animate.t_shadow$animate28663 \x3d (function (from,to,timing,delay,meta28664){\nthis.from \x3d from;\nthis.to \x3d to;\nthis.timing \x3d timing;\nthis.delay \x3d delay;\nthis.meta28664 \x3d meta28664;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.animate.t_shadow$animate28663.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_28665,meta28664__$1){\nvar self__ \x3d this;\nvar _28665__$1 \x3d this;\nreturn (new shadow.animate.t_shadow$animate28663(self__.from,self__.to,self__.timing,self__.delay,meta28664__$1));\n}));\n\n(shadow.animate.t_shadow$animate28663.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_28665){\nvar self__ \x3d this;\nvar _28665__$1 \x3d this;\nreturn self__.meta28664;\n}));\n\n(shadow.animate.t_shadow$animate28663.prototype.shadow$animate$Animation$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.animate.t_shadow$animate28663.prototype.shadow$animate$Animation$_animate_from$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22transform\x22,\x22transform\x22,1381301764),[\x22translateX(\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.from),\x22)\x22].join(\x27\x27)], null);\n}));\n\n(shadow.animate.t_shadow$animate28663.prototype.shadow$animate$Animation$_animate_to$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22transform\x22,\x22transform\x22,1381301764),[\x22translateX(\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.to),\x22)\x22].join(\x27\x27)], null);\n}));\n\n(shadow.animate.t_shadow$animate28663.prototype.shadow$animate$Animation$_animate_timings$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([shadow.animate.vendor_transform,self__.timing]);\n}));\n\n(shadow.animate.t_shadow$animate28663.prototype.shadow$animate$Animation$_animate_toggles$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.EMPTY;\n}));\n\n(shadow.animate.t_shadow$animate28663.prototype.shadow$animate$Animation$_animate_delays$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.PersistentArrayMap.createAsIfByAssoc([shadow.animate.vendor_transform,self__.delay]);\n}));\n\n(shadow.animate.t_shadow$animate28663.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22from\x22,\x22from\x22,-839142725,null),new cljs.core.Symbol(null,\x22to\x22,\x22to\x22,1832630534,null),new cljs.core.Symbol(null,\x22timing\x22,\x22timing\x22,-208693668,null),new cljs.core.Symbol(null,\x22delay\x22,\x22delay\x22,1066306308,null),new cljs.core.Symbol(null,\x22meta28664\x22,\x22meta28664\x22,-1249213531,null)], null);\n}));\n\n(shadow.animate.t_shadow$animate28663.cljs$lang$type \x3d true);\n\n(shadow.animate.t_shadow$animate28663.cljs$lang$ctorStr \x3d \x22shadow.animate/t_shadow$animate28663\x22);\n\n(shadow.animate.t_shadow$animate28663.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.animate/t_shadow$animate28663\x22);\n}));\n\n/**\n * Positional factory function for shadow.animate/t_shadow$animate28663.\n */\nshadow.animate.__GT_t_shadow$animate28663 \x3d (function shadow$animate$__GT_t_shadow$animate28663(from,to,timing,delay,meta28664){\nreturn (new shadow.animate.t_shadow$animate28663(from,to,timing,delay,meta28664));\n});\n\n\nshadow.animate.translate_x \x3d (function shadow$animate$translate_x(var_args){\nvar G__28659 \x3d arguments.length;\nswitch (G__28659) {\ncase 3:\nreturn shadow.animate.translate_x.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.animate.translate_x.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.animate.translate_x.cljs$core$IFn$_invoke$arity$3 \x3d (function (from,to,timing){\nreturn shadow.animate.translate_x.cljs$core$IFn$_invoke$arity$4(from,to,timing,(0));\n}));\n\n(shadow.animate.translate_x.cljs$core$IFn$_invoke$arity$4 \x3d (function (from,to,timing,delay){\nreturn (new shadow.animate.t_shadow$animate28663(from,to,timing,delay,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(shadow.animate.translate_x.cljs$lang$maxFixedArity \x3d 4);\n\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.util.js", true, "goog.provide(\x22com.cognitect.transit.util\x22);\ngoog.require(\x22goog.object\x22);\ngoog.scope(function() {\n  var util \x3d com.cognitect.transit.util;\n  var gobject \x3d goog.object;\n  if (typeof Object.keys !\x3d \x22undefined\x22) {\n    util.objectKeys \x3d function(obj) {\n      return Object.keys(obj);\n    };\n  } else {\n    util.objectKeys \x3d function(obj) {\n      return gobject.getKeys(obj);\n    };\n  }\n  if (typeof Array.isArray !\x3d \x22undefined\x22) {\n    util.isArray \x3d function(obj) {\n      return Array.isArray(obj);\n    };\n  } else {\n    util.isArray \x3d function(obj) {\n      return goog.typeOf(obj) \x3d\x3d\x3d \x22array\x22;\n    };\n  }\n  util.chars \x3d \x22ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\\x3d\x22;\n  util.randInt \x3d function(ub) {\n    return Math.round(Math.random() * ub);\n  };\n  util.randHex \x3d function() {\n    return util.randInt(15).toString(16);\n  };\n  util.randomUUID \x3d function() {\n    var rhex \x3d (8 | 3 \x26 util.randInt(14)).toString(16);\n    var ret \x3d util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + \x22-\x22 + util.randHex() + util.randHex() + util.randHex() + util.randHex() + \x22-\x22 + \x224\x22 + util.randHex() + util.randHex() + util.randHex() + \x22-\x22 + rhex + util.randHex() + util.randHex() + util.randHex() + \x22-\x22 + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + util.randHex() + \n    util.randHex() + util.randHex() + util.randHex();\n    return ret;\n  };\n  util.btoa \x3d function(input) {\n    if (typeof btoa !\x3d \x22undefined\x22) {\n      return btoa(input);\n    } else {\n      var str \x3d String(input);\n      var block;\n      var charCode;\n      var idx \x3d 0;\n      var map \x3d util.chars;\n      var output \x3d \x22\x22;\n      for (; str.charAt(idx | 0) || (map \x3d \x22\\x3d\x22, idx % 1); output \x3d output + map.charAt(63 \x26 block \x3e\x3e 8 - idx % 1 * 8)) {\n        charCode \x3d str.charCodeAt(idx \x3d idx + 3 / 4);\n        if (charCode \x3e 255) {\n          throw new Error(\x22\x27btoa\x27 failed: The string to be encoded contains characters outside of the Latin1 range.\x22);\n        }\n        block \x3d block \x3c\x3c 8 | charCode;\n      }\n      return output;\n    }\n  };\n  util.atob \x3d function(input) {\n    if (typeof atob !\x3d \x22undefined\x22) {\n      return atob(input);\n    } else {\n      var str \x3d String(input).replace(/\x3d+$/, \x22\x22);\n      if (str.length % 4 \x3d\x3d 1) {\n        throw new Error(\x22\x27atob\x27 failed: The string to be decoded is not correctly encoded.\x22);\n      }\n      var bc \x3d 0;\n      var bs;\n      var buffer;\n      var idx \x3d 0;\n      var output \x3d \x22\x22;\n      for (; buffer \x3d str.charAt(idx++); ~buffer \x26\x26 (bs \x3d bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output \x3d output + String.fromCharCode(255 \x26 bs \x3e\x3e (-2 * bc \x26 6)) : 0) {\n        buffer \x3d util.chars.indexOf(buffer);\n      }\n      return output;\n    }\n  };\n  util.Uint8ToBase64 \x3d function(u8Arr) {\n    var CHUNK_SIZE \x3d 32768;\n    var index \x3d 0;\n    var length \x3d u8Arr.length;\n    var result \x3d \x22\x22;\n    var slice \x3d null;\n    for (; index \x3c length;) {\n      slice \x3d u8Arr.subarray(index, Math.min(index + CHUNK_SIZE, length));\n      result \x3d result + String.fromCharCode.apply(null, slice);\n      index \x3d index + CHUNK_SIZE;\n    }\n    return util.btoa(result);\n  };\n  util.Base64ToUint8 \x3d function(base64) {\n    var binary_string \x3d util.atob(base64);\n    var len \x3d binary_string.length;\n    var bytes \x3d new Uint8Array(len);\n    var i \x3d 0;\n    for (; i \x3c len; i++) {\n      var ascii \x3d binary_string.charCodeAt(i);\n      bytes[i] \x3d ascii;\n    }\n    return bytes;\n  };\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.delimiters.js", true, "goog.provide(\x22com.cognitect.transit.delimiters\x22);\ngoog.scope(function() {\n  var delimiters \x3d com.cognitect.transit.delimiters;\n  delimiters.ESC \x3d \x22~\x22;\n  delimiters.TAG \x3d \x22#\x22;\n  delimiters.SUB \x3d \x22^\x22;\n  delimiters.RES \x3d \x22`\x22;\n  delimiters.ESC_TAG \x3d \x22~#\x22;\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.caching.js", true, "goog.provide(\x22com.cognitect.transit.caching\x22);\ngoog.require(\x22com.cognitect.transit.delimiters\x22);\ngoog.scope(function() {\n  var caching \x3d com.cognitect.transit.caching;\n  var d \x3d com.cognitect.transit.delimiters;\n  caching.MIN_SIZE_CACHEABLE \x3d 3;\n  caching.BASE_CHAR_IDX \x3d 48;\n  caching.CACHE_CODE_DIGITS \x3d 44;\n  caching.MAX_CACHE_ENTRIES \x3d caching.CACHE_CODE_DIGITS * caching.CACHE_CODE_DIGITS;\n  caching.MAX_CACHE_SIZE \x3d 4096;\n  caching.isCacheable \x3d function(string, asMapKey) {\n    if (string.length \x3e caching.MIN_SIZE_CACHEABLE) {\n      if (asMapKey) {\n        return true;\n      } else {\n        var c0 \x3d string.charAt(0);\n        var c1 \x3d string.charAt(1);\n        if (c0 \x3d\x3d\x3d d.ESC) {\n          return c1 \x3d\x3d\x3d \x22:\x22 || c1 \x3d\x3d\x3d \x22$\x22 || c1 \x3d\x3d\x3d \x22#\x22;\n        } else {\n          return false;\n        }\n      }\n    } else {\n      return false;\n    }\n  };\n  caching.idxToCode \x3d function(idx) {\n    var hi \x3d Math.floor(idx / caching.CACHE_CODE_DIGITS);\n    var lo \x3d idx % caching.CACHE_CODE_DIGITS;\n    var loc \x3d String.fromCharCode(lo + caching.BASE_CHAR_IDX);\n    if (hi \x3d\x3d\x3d 0) {\n      return d.SUB + loc;\n    } else {\n      return d.SUB + String.fromCharCode(hi + caching.BASE_CHAR_IDX) + loc;\n    }\n  };\n  caching.WriteCache \x3d function() {\n    this.idx \x3d 0;\n    this.gen \x3d 0;\n    this.cacheSize \x3d 0;\n    this.cache \x3d {};\n  };\n  caching.WriteCache.prototype.write \x3d function(string, asMapKey) {\n    if (caching.isCacheable(string, asMapKey)) {\n      if (this.cacheSize \x3d\x3d\x3d caching.MAX_CACHE_SIZE) {\n        this.clear();\n        this.gen \x3d 0;\n        this.cache \x3d {};\n      } else if (this.idx \x3d\x3d\x3d caching.MAX_CACHE_ENTRIES) {\n        this.clear();\n      }\n      var entry \x3d this.cache[string];\n      if (entry \x3d\x3d null) {\n        this.cache[string] \x3d [caching.idxToCode(this.idx), this.gen];\n        this.idx++;\n        return string;\n      } else if (entry[1] !\x3d this.gen) {\n        entry[1] \x3d this.gen;\n        entry[0] \x3d caching.idxToCode(this.idx);\n        this.idx++;\n        return string;\n      } else {\n        return entry[0];\n      }\n    } else {\n      return string;\n    }\n  };\n  caching.WriteCache.prototype.clear \x3d function Transit$WriteCache() {\n    this.idx \x3d 0;\n    this.gen++;\n  };\n  caching.writeCache \x3d function() {\n    return new caching.WriteCache();\n  };\n  caching.isCacheCode \x3d function(string) {\n    return string.charAt(0) \x3d\x3d\x3d d.SUB \x26\x26 string.charAt(1) !\x3d\x3d \x22 \x22;\n  };\n  caching.codeToIdx \x3d function(code) {\n    if (code.length \x3d\x3d\x3d 2) {\n      return code.charCodeAt(1) - caching.BASE_CHAR_IDX;\n    } else {\n      var hi \x3d (code.charCodeAt(1) - caching.BASE_CHAR_IDX) * caching.CACHE_CODE_DIGITS;\n      var lo \x3d code.charCodeAt(2) - caching.BASE_CHAR_IDX;\n      return hi + lo;\n    }\n  };\n  caching.ReadCache \x3d function Transit$ReadCache() {\n    this.idx \x3d 0;\n    this.cache \x3d [];\n  };\n  caching.ReadCache.prototype.write \x3d function(obj, asMapKey) {\n    if (this.idx \x3d\x3d caching.MAX_CACHE_ENTRIES) {\n      this.idx \x3d 0;\n    }\n    this.cache[this.idx] \x3d obj;\n    this.idx++;\n    return obj;\n  };\n  caching.ReadCache.prototype.read \x3d function(string, asMapKey) {\n    return this.cache[caching.codeToIdx(string)];\n  };\n  caching.ReadCache.prototype.clear \x3d function() {\n    this.idx \x3d 0;\n  };\n  caching.readCache \x3d function() {\n    return new caching.ReadCache();\n  };\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.eq.js", true, "goog.provide(\x22com.cognitect.transit.eq\x22);\ngoog.require(\x22com.cognitect.transit.util\x22);\ngoog.scope(function() {\n  var eq \x3d com.cognitect.transit.eq;\n  var util \x3d com.cognitect.transit.util;\n  eq.hashCodeProperty \x3d \x22transit$hashCode$\x22;\n  eq.hashCodeCounter \x3d 1;\n  eq.equals \x3d function(x, y) {\n    if (x \x3d\x3d null) {\n      return y \x3d\x3d null;\n    } else if (x \x3d\x3d\x3d y) {\n      return true;\n    } else if (typeof x \x3d\x3d\x3d \x22object\x22) {\n      if (util.isArray(x)) {\n        if (util.isArray(y)) {\n          if (x.length \x3d\x3d\x3d y.length) {\n            var i \x3d 0;\n            for (; i \x3c x.length; i++) {\n              if (!eq.equals(x[i], y[i])) {\n                return false;\n              }\n            }\n            return true;\n          } else {\n            return false;\n          }\n        } else {\n          return false;\n        }\n      } else if (x.com$cognitect$transit$equals) {\n        return x.com$cognitect$transit$equals(y);\n      } else if (y !\x3d null \x26\x26 typeof y \x3d\x3d\x3d \x22object\x22) {\n        if (y.com$cognitect$transit$equals) {\n          return y.com$cognitect$transit$equals(x);\n        } else {\n          var xklen \x3d 0;\n          var yklen \x3d util.objectKeys(y).length;\n          var p;\n          for (p in x) {\n            if (!x.hasOwnProperty(p)) {\n              continue;\n            }\n            xklen++;\n            if (!y.hasOwnProperty(p)) {\n              return false;\n            } else {\n              if (!eq.equals(x[p], y[p])) {\n                return false;\n              }\n            }\n          }\n          return xklen \x3d\x3d\x3d yklen;\n        }\n      } else {\n        return false;\n      }\n    } else {\n      return false;\n    }\n  };\n  eq.hashCombine \x3d function(seed, hash) {\n    return seed ^ hash + 2654435769 + (seed \x3c\x3c 6) + (seed \x3e\x3e 2);\n  };\n  eq.stringCodeCache \x3d {};\n  eq.stringCodeCacheSize \x3d 0;\n  eq.STR_CACHE_MAX \x3d 256;\n  eq.hashString \x3d function(str) {\n    var cached \x3d eq.stringCodeCache[str];\n    if (cached !\x3d null) {\n      return cached;\n    }\n    var code \x3d 0;\n    var i \x3d 0;\n    for (; i \x3c str.length; ++i) {\n      code \x3d 31 * code + str.charCodeAt(i);\n      code \x3d code % 4294967296;\n    }\n    eq.stringCodeCacheSize++;\n    if (eq.stringCodeCacheSize \x3e\x3d eq.STR_CACHE_MAX) {\n      eq.stringCodeCache \x3d {};\n      eq.stringCodeCacheSize \x3d 1;\n    }\n    eq.stringCodeCache[str] \x3d code;\n    return code;\n  };\n  eq.hashMapLike \x3d function(m) {\n    var code \x3d 0;\n    if (m.forEach !\x3d null) {\n      m.forEach(function(val, key, m) {\n        code \x3d (code + (eq.hashCode(key) ^ eq.hashCode(val))) % 4503599627370496;\n      });\n    } else {\n      var keys \x3d util.objectKeys(m);\n      var i \x3d 0;\n      for (; i \x3c keys.length; i++) {\n        var key \x3d keys[i];\n        var val \x3d m[key];\n        code \x3d (code + (eq.hashCode(key) ^ eq.hashCode(val))) % 4503599627370496;\n      }\n    }\n    return code;\n  };\n  eq.hashArrayLike \x3d function(arr) {\n    var code \x3d 0;\n    if (util.isArray(arr)) {\n      var i \x3d 0;\n      for (; i \x3c arr.length; i++) {\n        code \x3d eq.hashCombine(code, eq.hashCode(arr[i]));\n      }\n    } else if (arr.forEach) {\n      arr.forEach(function(x, i) {\n        code \x3d eq.hashCombine(code, eq.hashCode(x));\n      });\n    }\n    return code;\n  };\n  eq.hashCode \x3d function(x) {\n    if (x \x3d\x3d null) {\n      return 0;\n    } else {\n      switch(typeof x) {\n        case \x22number\x22:\n          return x;\n          break;\n        case \x22boolean\x22:\n          return x \x3d\x3d\x3d true ? 1 : 0;\n          break;\n        case \x22string\x22:\n          return eq.hashString(x);\n          break;\n        case \x22function\x22:\n          var code \x3d x[eq.hashCodeProperty];\n          if (code) {\n            return code;\n          } else {\n            code \x3d eq.hashCodeCounter;\n            if (typeof Object.defineProperty !\x3d \x22undefined\x22) {\n              Object.defineProperty(x, eq.hashCodeProperty, {value:code, enumerable:false});\n            } else {\n              x[eq.hashCodeProperty] \x3d code;\n            }\n            eq.hashCodeCounter++;\n            return code;\n          }\n          break;\n        default:\n          if (x instanceof Date) {\n            return x.valueOf();\n          } else if (util.isArray(x)) {\n            return eq.hashArrayLike(x);\n          }\n          if (x.com$cognitect$transit$hashCode) {\n            return x.com$cognitect$transit$hashCode();\n          } else {\n            return eq.hashMapLike(x);\n          }\n          break;\n      }\n    }\n  };\n  eq.extendToEQ \x3d function(obj, opts) {\n    obj.com$cognitect$transit$hashCode \x3d opts[\x22hashCode\x22];\n    obj.com$cognitect$transit$equals \x3d opts[\x22equals\x22];\n    return obj;\n  };\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.types.js", true, "goog.provide(\x22com.cognitect.transit.types\x22);\ngoog.require(\x22com.cognitect.transit.util\x22);\ngoog.require(\x22com.cognitect.transit.eq\x22);\ngoog.require(\x22goog.math.Long\x22);\ngoog.scope(function() {\n  var types \x3d com.cognitect.transit.types;\n  var util \x3d com.cognitect.transit.util;\n  var eq \x3d com.cognitect.transit.eq;\n  var Long \x3d goog.math.Long;\n  if (typeof Symbol !\x3d \x22undefined\x22) {\n    types.ITERATOR \x3d Symbol.iterator;\n  } else {\n    types.ITERATOR \x3d \x22@@iterator\x22;\n  }\n  types.TaggedValue \x3d function Transit$TaggedValue(tag, rep) {\n    this.tag \x3d tag;\n    this.rep \x3d rep;\n    this.hashCode \x3d -1;\n  };\n  types.TaggedValue.prototype.toString \x3d function() {\n    return \x22[TaggedValue: \x22 + this.tag + \x22, \x22 + this.rep + \x22]\x22;\n  };\n  types.TaggedValue.prototype.equiv \x3d function(other) {\n    return eq.equals(this, other);\n  };\n  types.TaggedValue.prototype[\x22equiv\x22] \x3d types.TaggedValue.prototype.equiv;\n  types.TaggedValue.prototype.com$cognitect$transit$equals \x3d function(other) {\n    if (other instanceof types.TaggedValue) {\n      return this.tag \x3d\x3d\x3d other.tag \x26\x26 eq.equals(this.rep, other.rep);\n    } else {\n      return false;\n    }\n  };\n  types.TaggedValue.prototype.com$cognitect$transit$hashCode \x3d function() {\n    if (this.hashCode \x3d\x3d\x3d -1) {\n      this.hashCode \x3d eq.hashCombine(eq.hashCode(this.tag), eq.hashCode(this.rep));\n    }\n    return this.hashCode;\n  };\n  types.taggedValue \x3d function(tag, rep) {\n    return new types.TaggedValue(tag, rep);\n  };\n  types.isTaggedValue \x3d function(x) {\n    return x instanceof types.TaggedValue;\n  };\n  types.nullValue \x3d function() {\n    return null;\n  };\n  types.boolValue \x3d function(s) {\n    return s \x3d\x3d\x3d \x22t\x22;\n  };\n  types.MAX_INT \x3d Long.fromString(\x229007199254740991\x22);\n  types.MIN_INT \x3d Long.fromString(\x22-9007199254740991\x22);\n  types.intValue \x3d function(s) {\n    if (typeof s \x3d\x3d\x3d \x22number\x22) {\n      return s;\n    } else if (s instanceof Long) {\n      return s;\n    } else {\n      var n \x3d Long.fromString(s, 10);\n      if (n.greaterThan(types.MAX_INT) || n.lessThan(types.MIN_INT)) {\n        return n;\n      } else {\n        return n.toNumber();\n      }\n    }\n  };\n  Long.prototype.equiv \x3d function(other) {\n    return eq.equals(this, other);\n  };\n  Long.prototype[\x22equiv\x22] \x3d Long.prototype.equiv;\n  Long.prototype.com$cognitect$transit$equals \x3d function(other) {\n    return other instanceof Long \x26\x26 this.equals(other);\n  };\n  Long.prototype.com$cognitect$transit$hashCode \x3d function() {\n    return this.toInt();\n  };\n  types.isInteger \x3d function(x) {\n    if (x instanceof Long) {\n      return true;\n    } else {\n      return typeof x \x3d\x3d\x3d \x22number\x22 \x26\x26 !isNaN(x) \x26\x26 !(x \x3d\x3d\x3d Infinity) \x26\x26 parseFloat(x) \x3d\x3d\x3d parseInt(x, 10);\n    }\n  };\n  types.floatValue \x3d function(s) {\n    return parseFloat(s);\n  };\n  types.bigInteger \x3d function(s) {\n    return types.taggedValue(\x22n\x22, s);\n  };\n  types.isBigInteger \x3d function(x) {\n    return x instanceof types.TaggedValue \x26\x26 x.tag \x3d\x3d\x3d \x22n\x22;\n  };\n  types.bigDecimalValue \x3d function(s) {\n    return types.taggedValue(\x22f\x22, s);\n  };\n  types.isBigDecimal \x3d function(x) {\n    return x instanceof types.TaggedValue \x26\x26 x.tag \x3d\x3d\x3d \x22f\x22;\n  };\n  types.charValue \x3d function(s) {\n    return s;\n  };\n  types.Keyword \x3d function Transit$Keyword(name) {\n    this._name \x3d name;\n    this.hashCode \x3d -1;\n  };\n  types.Keyword.prototype.toString \x3d function() {\n    return \x22:\x22 + this._name;\n  };\n  types.Keyword.prototype[\x22namespace\x22] \x3d function() {\n    var idx \x3d this._name.indexOf(\x22/\x22);\n    if (idx !\x3d -1) {\n      return this._name.substring(0, idx);\n    } else {\n      return null;\n    }\n  };\n  types.Keyword.prototype[\x22name\x22] \x3d function() {\n    var idx \x3d this._name.indexOf(\x22/\x22);\n    if (idx !\x3d -1) {\n      return this._name.substring(idx + 1, this._name.length);\n    } else {\n      return this._name;\n    }\n  };\n  types.Keyword.prototype.equiv \x3d function(other) {\n    return eq.equals(this, other);\n  };\n  types.Keyword.prototype[\x22equiv\x22] \x3d types.Keyword.prototype.equiv;\n  types.Keyword.prototype.com$cognitect$transit$equals \x3d function(other) {\n    return other instanceof types.Keyword \x26\x26 this._name \x3d\x3d other._name;\n  };\n  types.Keyword.prototype.com$cognitect$transit$hashCode \x3d function() {\n    if (this.hashCode \x3d\x3d\x3d -1) {\n      this.hashCode \x3d eq.hashCode(this._name);\n    }\n    return this.hashCode;\n  };\n  types.keyword \x3d function(s) {\n    return new types.Keyword(s);\n  };\n  types.isKeyword \x3d function(x) {\n    return x instanceof types.Keyword;\n  };\n  types.Symbol \x3d function Transit$Symbol(name) {\n    this._name \x3d name;\n    this.hashCode \x3d -1;\n  };\n  types.Symbol.prototype[\x22namespace\x22] \x3d function() {\n    var idx \x3d this._name.indexOf(\x22/\x22);\n    if (idx !\x3d -1) {\n      return this._name.substring(0, idx);\n    } else {\n      return null;\n    }\n  };\n  types.Symbol.prototype[\x22name\x22] \x3d function() {\n    var idx \x3d this._name.indexOf(\x22/\x22);\n    if (idx !\x3d -1) {\n      return this._name.substring(idx + 1, this._name.length);\n    } else {\n      return this._name;\n    }\n  };\n  types.Symbol.prototype.toString \x3d function() {\n    return this._name;\n  };\n  types.Symbol.prototype.equiv \x3d function(other) {\n    return eq.equals(this, other);\n  };\n  types.Symbol.prototype[\x22equiv\x22] \x3d types.Symbol.prototype.equiv;\n  types.Symbol.prototype.com$cognitect$transit$equals \x3d function(other) {\n    return other instanceof types.Symbol \x26\x26 this._name \x3d\x3d other._name;\n  };\n  types.Symbol.prototype.com$cognitect$transit$hashCode \x3d function() {\n    if (this.hashCode \x3d\x3d\x3d -1) {\n      this.hashCode \x3d eq.hashCode(this._name);\n    }\n    return this.hashCode;\n  };\n  types.symbol \x3d function(s) {\n    return new types.Symbol(s);\n  };\n  types.isSymbol \x3d function(x) {\n    return x instanceof types.Symbol;\n  };\n  types.hexFor \x3d function(aLong, sidx, eidx) {\n    var ret \x3d \x22\x22;\n    eidx \x3d eidx || sidx + 1;\n    var i \x3d sidx;\n    var shift \x3d (7 - i) * 8;\n    var mask \x3d Long.fromInt(255).shiftLeft(shift);\n    for (; i \x3c eidx; i++, shift \x3d shift - 8, mask \x3d mask.shiftRightUnsigned(8)) {\n      var s \x3d aLong.and(mask).shiftRightUnsigned(shift).toString(16);\n      if (s.length \x3d\x3d 1) {\n        s \x3d \x220\x22 + s;\n      }\n      ret \x3d ret + s;\n    }\n    return ret;\n  };\n  types.UUID \x3d function Transit$UUID(high, low) {\n    this.high \x3d high;\n    this.low \x3d low;\n    this.hashCode \x3d -1;\n  };\n  types.UUID.prototype.getLeastSignificantBits \x3d function() {\n    return this.low;\n  };\n  types.UUID.prototype.getMostSignificantBits \x3d function() {\n    return this.high;\n  };\n  types.UUID.prototype.toString \x3d function() {\n    var s \x3d \x22\x22;\n    var hi64 \x3d this.high;\n    var lo64 \x3d this.low;\n    s \x3d s + (types.hexFor(hi64, 0, 4) + \x22-\x22);\n    s \x3d s + (types.hexFor(hi64, 4, 6) + \x22-\x22);\n    s \x3d s + (types.hexFor(hi64, 6, 8) + \x22-\x22);\n    s \x3d s + (types.hexFor(lo64, 0, 2) + \x22-\x22);\n    s \x3d s + types.hexFor(lo64, 2, 8);\n    return s;\n  };\n  types.UUID.prototype.equiv \x3d function(other) {\n    return eq.equals(this, other);\n  };\n  types.UUID.prototype[\x22equiv\x22] \x3d types.UUID.prototype.equiv;\n  types.UUID.prototype.com$cognitect$transit$equals \x3d function(other) {\n    return other instanceof types.UUID \x26\x26 this.high.equals(other.high) \x26\x26 this.low.equals(other.low);\n  };\n  types.UUID.prototype.com$cognitect$transit$hashCode \x3d function() {\n    if (this.hashCode \x3d\x3d\x3d -1) {\n      this.hashCode \x3d eq.hashCode(this.toString());\n    }\n    return this.hashCode;\n  };\n  types.UUIDfromString \x3d function uuidFromString(s) {\n    s \x3d s.replace(/-/g, \x22\x22);\n    var hi64 \x3d null;\n    var lo64 \x3d null;\n    var hi32 \x3d 0;\n    var lo32 \x3d 0;\n    var off \x3d 24;\n    var i \x3d 0;\n    hi32 \x3d 0, i \x3d 0, off \x3d 24;\n    for (; i \x3c 8; i \x3d i + 2, off \x3d off - 8) {\n      hi32 \x3d hi32 | parseInt(s.substring(i, i + 2), 16) \x3c\x3c off;\n    }\n    lo32 \x3d 0, i \x3d 8, off \x3d 24;\n    for (; i \x3c 16; i \x3d i + 2, off \x3d off - 8) {\n      lo32 \x3d lo32 | parseInt(s.substring(i, i + 2), 16) \x3c\x3c off;\n    }\n    hi64 \x3d Long.fromBits(lo32, hi32);\n    hi32 \x3d 0, i \x3d 16, off \x3d 24;\n    for (; i \x3c 24; i \x3d i + 2, off \x3d off - 8) {\n      hi32 \x3d hi32 | parseInt(s.substring(i, i + 2), 16) \x3c\x3c off;\n    }\n    lo32 \x3d 0, i \x3d 24, off \x3d 24;\n    for (; i \x3c 32; i \x3d i + 2, off \x3d off - 8) {\n      lo32 \x3d lo32 | parseInt(s.substring(i, i + 2), 16) \x3c\x3c off;\n    }\n    lo64 \x3d Long.fromBits(lo32, hi32);\n    return new types.UUID(hi64, lo64);\n  };\n  types.uuid \x3d function(s) {\n    return types.UUIDfromString(s);\n  };\n  types.isUUID \x3d function(x) {\n    return x instanceof types.UUID;\n  };\n  types.date \x3d function(s) {\n    s \x3d typeof s \x3d\x3d\x3d \x22number\x22 ? s : parseInt(s, 10);\n    return new Date(s);\n  };\n  types.verboseDate \x3d function(s) {\n    return new Date(s);\n  };\n  Date.prototype.com$cognitect$transit$equals \x3d function(other) {\n    if (other instanceof Date) {\n      return this.valueOf() \x3d\x3d\x3d other.valueOf();\n    } else {\n      return false;\n    }\n  };\n  Date.prototype.com$cognitect$transit$hashCode \x3d function() {\n    return this.valueOf();\n  };\n  types.binary \x3d function(str, decoder) {\n    if ((!decoder || decoder.preferBuffers !\x3d\x3d false) \x26\x26 typeof goog.global.Buffer !\x3d \x22undefined\x22) {\n      return new goog.global.Buffer(str, \x22base64\x22);\n    } else if (typeof Uint8Array !\x3d \x22undefined\x22) {\n      return util.Base64ToUint8(str);\n    } else {\n      return types.taggedValue(\x22b\x22, str);\n    }\n  };\n  types.isBinary \x3d function(x) {\n    if (typeof goog.global.Buffer !\x3d \x22undefined\x22 \x26\x26 x instanceof goog.global.Buffer) {\n      return true;\n    } else if (typeof Uint8Array !\x3d \x22undefined\x22 \x26\x26 x instanceof Uint8Array) {\n      return true;\n    } else {\n      return x instanceof types.TaggedValue \x26\x26 x.tag \x3d\x3d\x3d \x22b\x22;\n    }\n  };\n  types.uri \x3d function(s) {\n    return types.taggedValue(\x22r\x22, s);\n  };\n  types.isURI \x3d function(x) {\n    return x instanceof types.TaggedValue \x26\x26 x.tag \x3d\x3d\x3d \x22r\x22;\n  };\n  types.KEYS \x3d 0;\n  types.VALUES \x3d 1;\n  types.ENTRIES \x3d 2;\n  types.TransitArrayMapIterator \x3d function Transit$ArrayMapIterator(entries, type) {\n    this.entries \x3d entries;\n    this.type \x3d type || types.KEYS;\n    this.idx \x3d 0;\n  };\n  types.TransitArrayMapIterator.prototype.next \x3d function() {\n    if (this.idx \x3c this.entries.length) {\n      var value \x3d null;\n      if (this.type \x3d\x3d\x3d types.KEYS) {\n        value \x3d this.entries[this.idx];\n      } else if (this.type \x3d\x3d\x3d types.VALUES) {\n        value \x3d this.entries[this.idx + 1];\n      } else {\n        value \x3d [this.entries[this.idx], this.entries[this.idx + 1]];\n      }\n      var ret \x3d {\x22value\x22:value, \x22done\x22:false};\n      this.idx +\x3d 2;\n      return ret;\n    } else {\n      return {\x22value\x22:null, \x22done\x22:true};\n    }\n  };\n  types.TransitArrayMapIterator.prototype[\x22next\x22] \x3d types.TransitArrayMapIterator.prototype.next;\n  types.TransitArrayMapIterator.prototype[types.ITERATOR] \x3d function() {\n    return this;\n  };\n  types.TransitMapIterator \x3d function Transit$MapIterator(map, type) {\n    this.map \x3d map;\n    this.type \x3d type || types.KEYS;\n    this.keys \x3d this.map.getKeys();\n    this.idx \x3d 0;\n    this.bucket \x3d null;\n    this.bucketIdx \x3d 0;\n  };\n  types.TransitMapIterator.prototype.next \x3d function() {\n    if (this.idx \x3c this.map.size) {\n      if (this.bucket \x3d\x3d null || !(this.bucketIdx \x3c this.bucket.length)) {\n        this.bucket \x3d this.map.map[this.keys[this.idx]];\n        this.bucketIdx \x3d 0;\n      }\n      var value \x3d null;\n      if (this.type \x3d\x3d\x3d types.KEYS) {\n        value \x3d this.bucket[this.bucketIdx];\n      } else if (this.type \x3d\x3d\x3d types.VALUES) {\n        value \x3d this.bucket[this.bucketIdx + 1];\n      } else {\n        value \x3d [this.bucket[this.bucketIdx], this.bucket[this.bucketIdx + 1]];\n      }\n      var ret \x3d {\x22value\x22:value, \x22done\x22:false};\n      this.idx++;\n      this.bucketIdx +\x3d 2;\n      return ret;\n    } else {\n      return {\x22value\x22:null, \x22done\x22:true};\n    }\n  };\n  types.TransitMapIterator.prototype[\x22next\x22] \x3d types.TransitMapIterator.prototype.next;\n  types.TransitMapIterator.prototype[types.ITERATOR] \x3d function() {\n    return this;\n  };\n  types.mapEquals \x3d function(me, you) {\n    if (me instanceof types.TransitMap \x26\x26 types.isMap(you)) {\n      if (me.size !\x3d\x3d you.size) {\n        return false;\n      }\n      var code;\n      for (code in me.map) {\n        var bucket \x3d me.map[code];\n        var j \x3d 0;\n        for (; j \x3c bucket.length; j \x3d j + 2) {\n          if (!eq.equals(bucket[j + 1], you.get(bucket[j]))) {\n            return false;\n          }\n        }\n      }\n      return true;\n    } else if (me instanceof types.TransitArrayMap \x26\x26 types.isMap(you)) {\n      if (me.size !\x3d\x3d you.size) {\n        return false;\n      }\n      var entries \x3d me._entries;\n      j \x3d 0;\n      for (; j \x3c entries.length; j \x3d j + 2) {\n        if (!eq.equals(entries[j + 1], you.get(entries[j]))) {\n          return false;\n        }\n      }\n      return true;\n    } else if (you !\x3d null \x26\x26 typeof you \x3d\x3d\x3d \x22object\x22) {\n      var ks \x3d util.objectKeys(you);\n      var kslen \x3d ks.length;\n      if (me.size \x3d\x3d\x3d kslen) {\n        var i \x3d 0;\n        for (; i \x3c kslen; i++) {\n          var k \x3d ks[i];\n          if (!me.has(k) || !eq.equals(you[k], me.get(k))) {\n            return false;\n          }\n        }\n        return true;\n      } else {\n        return false;\n      }\n    } else {\n      return false;\n    }\n  };\n  types.SMALL_ARRAY_MAP_THRESHOLD \x3d 8;\n  types.ARRAY_MAP_THRESHOLD \x3d 32;\n  types.ARRAY_MAP_ACCESS_THRESHOLD \x3d 32;\n  types.print \x3d function(x) {\n    if (x \x3d\x3d null) {\n      return \x22null\x22;\n    }\n    if (goog.typeOf(x) \x3d\x3d\x3d \x22array\x22) {\n      return \x22[\x22 + x.toString() + \x22]\x22;\n    } else if (goog.typeOf(x) \x3d\x3d\x3d \x22string\x22) {\n      return \x27\x22\x27 + x + \x27\x22\x27;\n    } else {\n      return x.toString();\n    }\n  };\n  types.printMap \x3d function(map) {\n    var idx \x3d 0;\n    var str \x3d \x22TransitMap {\x22;\n    map.forEach(function(v, k) {\n      str \x3d str + (types.print(k) + \x22 \\x3d\\x3e \x22 + types.print(v));\n      if (idx \x3c map.size - 1) {\n        str \x3d str + \x22, \x22;\n      }\n      idx++;\n    });\n    return str + \x22}\x22;\n  };\n  types.printSet \x3d function(set) {\n    var idx \x3d 0;\n    var str \x3d \x22TransitSet {\x22;\n    set.forEach(function(v) {\n      str \x3d str + types.print(v);\n      if (idx \x3c set.size - 1) {\n        str \x3d str + \x22, \x22;\n      }\n      idx++;\n    });\n    return str + \x22}\x22;\n  };\n  types.TransitArrayMap \x3d function Transit$ArrayMap(entries) {\n    this._entries \x3d entries;\n    this.backingMap \x3d null;\n    this.hashCode \x3d -1;\n    this.size \x3d entries.length / 2;\n    this.accesses \x3d 0;\n  };\n  types.TransitArrayMap.prototype.toString \x3d function() {\n    return types.printMap(this);\n  };\n  types.TransitArrayMap.prototype[\x22inspect\x22] \x3d function() {\n    return this.toString();\n  };\n  types.TransitArrayMap.prototype.convert \x3d function() {\n    if (this.backingMap) {\n      throw Error(\x22Invalid operation, already converted\x22);\n    }\n    if (this.size \x3c types.SMALL_ARRAY_MAP_THRESHOLD) {\n      return false;\n    }\n    this.accesses++;\n    if (this.accesses \x3e types.ARRAY_MAP_ACCESS_THRESHOLD) {\n      this.backingMap \x3d types.map(this._entries, false, true);\n      this._entries \x3d [];\n      return true;\n    } else {\n      return false;\n    }\n  };\n  types.TransitArrayMap.prototype.clear \x3d function() {\n    this.hashCode \x3d -1;\n    if (this.backingMap) {\n      this.backingMap.clear();\n      this.size \x3d 0;\n    } else {\n      this._entries \x3d [];\n      this.size \x3d 0;\n    }\n  };\n  types.TransitArrayMap.prototype[\x22clear\x22] \x3d types.TransitArrayMap.prototype.clear;\n  types.TransitArrayMap.prototype.keys \x3d function() {\n    if (this.backingMap) {\n      return this.backingMap.keys();\n    } else {\n      return new types.TransitArrayMapIterator(this._entries, types.KEYS);\n    }\n  };\n  types.TransitArrayMap.prototype[\x22keys\x22] \x3d types.TransitArrayMap.prototype.keys;\n  types.TransitArrayMap.prototype.keySet \x3d function() {\n    if (this.backingMap) {\n      return this.backingMap.keySet();\n    } else {\n      var ret \x3d [];\n      var i \x3d 0;\n      var j \x3d 0;\n      for (; j \x3c this._entries.length; i++, j \x3d j + 2) {\n        ret[i] \x3d this._entries[j];\n      }\n      return ret;\n    }\n  };\n  types.TransitArrayMap.prototype[\x22keySet\x22] \x3d types.TransitArrayMap.prototype.keySet;\n  types.TransitArrayMap.prototype.entries \x3d function() {\n    if (this.backingMap) {\n      return this.backingMap.entries();\n    } else {\n      return new types.TransitArrayMapIterator(this._entries, types.ENTRIES);\n    }\n  };\n  types.TransitArrayMap.prototype[\x22entries\x22] \x3d types.TransitArrayMap.prototype.entries;\n  types.TransitArrayMap.prototype.values \x3d function() {\n    if (this.backingMap) {\n      return this.backingMap.values();\n    } else {\n      return new types.TransitArrayMapIterator(this._entries, types.VALUES);\n    }\n  };\n  types.TransitArrayMap.prototype[\x22values\x22] \x3d types.TransitArrayMap.prototype.values;\n  types.TransitArrayMap.prototype.forEach \x3d function(f) {\n    if (this.backingMap) {\n      this.backingMap.forEach(f);\n    } else {\n      var i \x3d 0;\n      for (; i \x3c this._entries.length; i \x3d i + 2) {\n        f(this._entries[i + 1], this._entries[i]);\n      }\n    }\n  };\n  types.TransitArrayMap.prototype[\x22forEach\x22] \x3d types.TransitArrayMap.prototype.forEach;\n  types.TransitArrayMap.prototype.get \x3d function(k, notFound) {\n    if (this.backingMap) {\n      return this.backingMap.get(k);\n    } else {\n      if (this.convert()) {\n        return this.get(k);\n      } else {\n        var i \x3d 0;\n        for (; i \x3c this._entries.length; i \x3d i + 2) {\n          if (eq.equals(this._entries[i], k)) {\n            return this._entries[i + 1];\n          }\n        }\n        return notFound;\n      }\n    }\n  };\n  types.TransitArrayMap.prototype[\x22get\x22] \x3d types.TransitArrayMap.prototype.get;\n  types.TransitArrayMap.prototype.has \x3d function(k) {\n    if (this.backingMap) {\n      return this.backingMap.has(k);\n    } else {\n      if (this.convert()) {\n        return this.has(k);\n      } else {\n        var i \x3d 0;\n        for (; i \x3c this._entries.length; i \x3d i + 2) {\n          if (eq.equals(this._entries[i], k)) {\n            return true;\n          }\n        }\n        return false;\n      }\n    }\n  };\n  types.TransitArrayMap.prototype[\x22has\x22] \x3d types.TransitArrayMap.prototype.has;\n  types.TransitArrayMap.prototype.set \x3d function(k, v) {\n    this.hashCode \x3d -1;\n    if (this.backingMap) {\n      this.backingMap.set(k, v);\n      this.size \x3d this.backingMap.size;\n    } else {\n      var i \x3d 0;\n      for (; i \x3c this._entries.length; i \x3d i + 2) {\n        if (eq.equals(this._entries[i], k)) {\n          this._entries[i + 1] \x3d v;\n          return;\n        }\n      }\n      this._entries.push(k);\n      this._entries.push(v);\n      this.size++;\n      if (this.size \x3e types.ARRAY_MAP_THRESHOLD) {\n        this.backingMap \x3d types.map(this._entries, false, true);\n        this._entries \x3d null;\n      }\n    }\n  };\n  types.TransitArrayMap.prototype[\x22set\x22] \x3d types.TransitArrayMap.prototype.set;\n  types.TransitArrayMap.prototype[\x22delete\x22] \x3d function(k) {\n    this.hashCode \x3d -1;\n    if (this.backingMap) {\n      var ret \x3d this.backingMap.delete(k);\n      this.size \x3d this.backingMap.size;\n      return ret;\n    } else {\n      var i \x3d 0;\n      for (; i \x3c this._entries.length; i \x3d i + 2) {\n        if (eq.equals(this._entries[i], k)) {\n          ret \x3d this._entries[i + 1];\n          this._entries.splice(i, 2);\n          this.size--;\n          return ret;\n        }\n      }\n    }\n  };\n  types.TransitArrayMap.prototype.clone \x3d function() {\n    var clone \x3d types.map();\n    this.forEach(function(v, k) {\n      clone.set(k, v);\n    });\n    return clone;\n  };\n  types.TransitArrayMap.prototype[\x22clone\x22] \x3d types.TransitArrayMap.prototype.clone;\n  types.TransitArrayMap.prototype[types.ITERATOR] \x3d function() {\n    return this.entries();\n  };\n  types.TransitArrayMap.prototype.com$cognitect$transit$hashCode \x3d function() {\n    if (this.backingMap) {\n      return this.backingMap.com$cognitect$transit$hashCode();\n    } else {\n      if (this.hashCode \x3d\x3d\x3d -1) {\n        this.hashCode \x3d eq.hashMapLike(this);\n      }\n      return this.hashCode;\n    }\n  };\n  types.TransitArrayMap.prototype.com$cognitect$transit$equals \x3d function(other) {\n    if (this.backingMap) {\n      return types.mapEquals(this.backingMap, other);\n    } else {\n      return types.mapEquals(this, other);\n    }\n  };\n  types.TransitMap \x3d function Transit$Map(keys, map, size) {\n    this.map \x3d map || {};\n    this._keys \x3d keys || [];\n    this.size \x3d size || 0;\n    this.hashCode \x3d -1;\n  };\n  types.TransitMap.prototype.toString \x3d function() {\n    return types.printMap(this);\n  };\n  types.TransitMap.prototype[\x22inspect\x22] \x3d function() {\n    return this.toString();\n  };\n  types.TransitMap.prototype.clear \x3d function() {\n    this.hashCode \x3d -1;\n    this.map \x3d {};\n    this._keys \x3d [];\n    this.size \x3d 0;\n  };\n  types.TransitMap.prototype[\x22clear\x22] \x3d types.TransitMap.prototype.clear;\n  types.TransitMap.prototype.getKeys \x3d function() {\n    if (this._keys !\x3d null) {\n      return this._keys;\n    } else {\n      return util.objectKeys(this.map);\n    }\n  };\n  types.TransitMap.prototype[\x22delete\x22] \x3d function(k) {\n    this.hashCode \x3d -1;\n    this._keys \x3d null;\n    var code \x3d eq.hashCode(k);\n    var bucket \x3d this.map[code];\n    var i \x3d 0;\n    for (; i \x3c bucket.length; i \x3d i + 2) {\n      if (eq.equals(k, bucket[i])) {\n        var ret \x3d bucket[i + 1];\n        bucket.splice(i, 2);\n        if (bucket.length \x3d\x3d\x3d 0) {\n          delete this.map[code];\n        }\n        this.size--;\n        return ret;\n      }\n    }\n  };\n  types.TransitMap.prototype.entries \x3d function() {\n    return new types.TransitMapIterator(this, types.ENTRIES);\n  };\n  types.TransitMap.prototype[\x22entries\x22] \x3d types.TransitMap.prototype.entries;\n  types.TransitMap.prototype.forEach \x3d function(callback) {\n    var ks \x3d this.getKeys();\n    var i \x3d 0;\n    for (; i \x3c ks.length; i++) {\n      var bucket \x3d this.map[ks[i]];\n      var j \x3d 0;\n      for (; j \x3c bucket.length; j \x3d j + 2) {\n        callback(bucket[j + 1], bucket[j], this);\n      }\n    }\n  };\n  types.TransitMap.prototype[\x22forEach\x22] \x3d types.TransitMap.prototype.forEach;\n  types.TransitMap.prototype.get \x3d function(k, notFound) {\n    var code \x3d eq.hashCode(k);\n    var bucket \x3d this.map[code];\n    if (bucket !\x3d null) {\n      var i \x3d 0;\n      for (; i \x3c bucket.length; i \x3d i + 2) {\n        if (eq.equals(k, bucket[i])) {\n          return bucket[i + 1];\n        }\n      }\n    } else {\n      return notFound;\n    }\n  };\n  types.TransitMap.prototype[\x22get\x22] \x3d types.TransitMap.prototype.get;\n  types.TransitMap.prototype.has \x3d function(k) {\n    var code \x3d eq.hashCode(k);\n    var bucket \x3d this.map[code];\n    if (bucket !\x3d null) {\n      var i \x3d 0;\n      for (; i \x3c bucket.length; i \x3d i + 2) {\n        if (eq.equals(k, bucket[i])) {\n          return true;\n        }\n      }\n      return false;\n    } else {\n      return false;\n    }\n  };\n  types.TransitMap.prototype[\x22has\x22] \x3d types.TransitMap.prototype.has;\n  types.TransitMap.prototype.keys \x3d function() {\n    return new types.TransitMapIterator(this, types.KEYS);\n  };\n  types.TransitMap.prototype[\x22keys\x22] \x3d types.TransitMap.prototype.keys;\n  types.TransitMap.prototype.keySet \x3d function() {\n    var keys \x3d this.getKeys();\n    var ret \x3d [];\n    var i \x3d 0;\n    for (; i \x3c keys.length; i++) {\n      var bucket \x3d this.map[keys[i]];\n      var j \x3d 0;\n      for (; j \x3c bucket.length; j \x3d j + 2) {\n        ret.push(bucket[j]);\n      }\n    }\n    return ret;\n  };\n  types.TransitMap.prototype[\x22keySet\x22] \x3d types.TransitMap.prototype.keySet;\n  types.TransitMap.prototype.set \x3d function(k, v) {\n    this.hashCode \x3d -1;\n    var code \x3d eq.hashCode(k);\n    var bucket \x3d this.map[code];\n    if (bucket \x3d\x3d null) {\n      if (this._keys) {\n        this._keys.push(code);\n      }\n      this.map[code] \x3d [k, v];\n      this.size++;\n    } else {\n      var newEntry \x3d true;\n      var i \x3d 0;\n      for (; i \x3c bucket.length; i \x3d i + 2) {\n        if (eq.equals(v, bucket[i])) {\n          newEntry \x3d false;\n          bucket[i] \x3d v;\n          break;\n        }\n      }\n      if (newEntry) {\n        bucket.push(k);\n        bucket.push(v);\n        this.size++;\n      }\n    }\n  };\n  types.TransitMap.prototype[\x22set\x22] \x3d types.TransitMap.prototype.set;\n  types.TransitMap.prototype.values \x3d function() {\n    return new types.TransitMapIterator(this, types.VALUES);\n  };\n  types.TransitMap.prototype[\x22values\x22] \x3d types.TransitMap.prototype.values;\n  types.TransitMap.prototype.clone \x3d function() {\n    var clone \x3d types.map();\n    this.forEach(function(v, k) {\n      clone.set(k, v);\n    });\n    return clone;\n  };\n  types.TransitMap.prototype[\x22clone\x22] \x3d types.TransitMap.prototype.clone;\n  types.TransitMap.prototype[types.ITERATOR] \x3d function() {\n    return this.entries();\n  };\n  types.TransitMap.prototype.com$cognitect$transit$hashCode \x3d function() {\n    if (this.hashCode \x3d\x3d\x3d -1) {\n      this.hashCode \x3d eq.hashMapLike(this);\n    }\n    return this.hashCode;\n  };\n  types.TransitMap.prototype.com$cognitect$transit$equals \x3d function(other) {\n    return types.mapEquals(this, other);\n  };\n  types.map \x3d function(arr, checkDups, hashMap) {\n    arr \x3d arr || [];\n    checkDups \x3d checkDups \x3d\x3d\x3d false ? checkDups : true;\n    hashMap \x3d hashMap \x3d\x3d\x3d true ? hashMap : false;\n    if (!hashMap \x26\x26 arr.length \x3c\x3d types.ARRAY_MAP_THRESHOLD * 2) {\n      if (checkDups) {\n        var t \x3d arr;\n        arr \x3d [];\n        var i \x3d 0;\n        for (; i \x3c t.length; i \x3d i + 2) {\n          var seen \x3d false;\n          var j \x3d 0;\n          for (; j \x3c arr.length; j \x3d j + 2) {\n            if (eq.equals(arr[j], t[i])) {\n              arr[j + 1] \x3d t[i + 1];\n              seen \x3d true;\n              break;\n            }\n          }\n          if (!seen) {\n            arr.push(t[i]);\n            arr.push(t[i + 1]);\n          }\n        }\n      }\n      return new types.TransitArrayMap(arr);\n    } else {\n      var map \x3d {};\n      var keys \x3d [];\n      var size \x3d 0;\n      i \x3d 0;\n      for (; i \x3c arr.length; i \x3d i + 2) {\n        var code \x3d eq.hashCode(arr[i]);\n        var bucket \x3d map[code];\n        if (bucket \x3d\x3d null) {\n          keys.push(code);\n          map[code] \x3d [arr[i], arr[i + 1]];\n          size++;\n        } else {\n          var newEntry \x3d true;\n          j \x3d 0;\n          for (; j \x3c bucket.length; j \x3d j + 2) {\n            if (eq.equals(bucket[j], arr[i])) {\n              bucket[j + 1] \x3d arr[i + 1];\n              newEntry \x3d false;\n              break;\n            }\n          }\n          if (newEntry) {\n            bucket.push(arr[i]);\n            bucket.push(arr[i + 1]);\n            size++;\n          }\n        }\n      }\n      return new types.TransitMap(keys, map, size);\n    }\n  };\n  types.isArrayMap \x3d function(x) {\n    return x instanceof types.TransitArrayMap;\n  };\n  types.isMap \x3d function(x) {\n    return x instanceof types.TransitArrayMap || x instanceof types.TransitMap;\n  };\n  types.TransitSet \x3d function Transit$Set(map) {\n    this.map \x3d map;\n    this.size \x3d map.size;\n  };\n  types.TransitSet.prototype.toString \x3d function() {\n    return types.printSet(this);\n  };\n  types.TransitSet.prototype[\x22inspect\x22] \x3d function() {\n    return this.toString();\n  };\n  types.TransitSet.prototype.add \x3d function(value) {\n    this.map.set(value, value);\n    this.size \x3d this.map.size;\n  };\n  types.TransitSet.prototype[\x22add\x22] \x3d types.TransitSet.prototype.add;\n  types.TransitSet.prototype.clear \x3d function() {\n    this.map \x3d new types.TransitMap();\n    this.size \x3d 0;\n  };\n  types.TransitSet.prototype[\x22clear\x22] \x3d types.TransitSet.prototype.clear;\n  types.TransitSet.prototype[\x22delete\x22] \x3d function(value) {\n    var ret \x3d this.map.delete(value);\n    this.size \x3d this.map.size;\n    return ret;\n  };\n  types.TransitSet.prototype.entries \x3d function() {\n    return this.map.entries();\n  };\n  types.TransitSet.prototype[\x22entries\x22] \x3d types.TransitSet.prototype.entries;\n  types.TransitSet.prototype.forEach \x3d function(iterator, thisArg) {\n    var self \x3d this;\n    this.map.forEach(function(v, k, m) {\n      iterator(k, self);\n    });\n  };\n  types.TransitSet.prototype[\x22forEach\x22] \x3d types.TransitSet.prototype.forEach;\n  types.TransitSet.prototype.has \x3d function(value) {\n    return this.map.has(value);\n  };\n  types.TransitSet.prototype[\x22has\x22] \x3d types.TransitSet.prototype.has;\n  types.TransitSet.prototype.keys \x3d function() {\n    return this.map.keys();\n  };\n  types.TransitSet.prototype[\x22keys\x22] \x3d types.TransitSet.prototype.keys;\n  types.TransitSet.prototype.keySet \x3d function() {\n    return this.map.keySet();\n  };\n  types.TransitSet.prototype[\x22keySet\x22] \x3d types.TransitSet.prototype.keySet;\n  types.TransitSet.prototype.values \x3d function() {\n    return this.map.values();\n  };\n  types.TransitSet.prototype[\x22values\x22] \x3d types.TransitSet.prototype.values;\n  types.TransitSet.prototype.clone \x3d function() {\n    var clone \x3d types.set();\n    this.forEach(function(k) {\n      clone.add(k);\n    });\n    return clone;\n  };\n  types.TransitSet.prototype[\x22clone\x22] \x3d types.TransitSet.prototype.clone;\n  types.TransitSet.prototype[types.ITERATOR] \x3d function() {\n    return this.values();\n  };\n  types.TransitSet.prototype.com$cognitect$transit$equals \x3d function(other) {\n    if (other instanceof types.TransitSet) {\n      if (this.size \x3d\x3d\x3d other.size) {\n        return eq.equals(this.map, other.map);\n      }\n    } else {\n      return false;\n    }\n  };\n  types.TransitSet.prototype.com$cognitect$transit$hashCode \x3d function(other) {\n    return eq.hashCode(this.map);\n  };\n  types.set \x3d function(arr) {\n    arr \x3d arr || [];\n    var map \x3d {};\n    var keys \x3d [];\n    var size \x3d 0;\n    var i \x3d 0;\n    for (; i \x3c arr.length; i++) {\n      var code \x3d eq.hashCode(arr[i]);\n      var vals \x3d map[code];\n      if (vals \x3d\x3d null) {\n        keys.push(code);\n        map[code] \x3d [arr[i], arr[i]];\n        size++;\n      } else {\n        var newEntry \x3d true;\n        var j \x3d 0;\n        for (; j \x3c vals.length; j \x3d j + 2) {\n          if (eq.equals(vals[j], arr[i])) {\n            newEntry \x3d false;\n            break;\n          }\n        }\n        if (newEntry) {\n          vals.push(arr[i]);\n          vals.push(arr[i]);\n          size++;\n        }\n      }\n    }\n    return new types.TransitSet(new types.TransitMap(keys, map, size));\n  };\n  types.isSet \x3d function(x) {\n    return x instanceof types.TransitSet;\n  };\n  types.quoted \x3d function(obj) {\n    return types.taggedValue(\x22\x27\x22, obj);\n  };\n  types.isQuoted \x3d function(x) {\n    return x instanceof types.TaggedValue \x26\x26 x.tag \x3d\x3d\x3d \x22\x27\x22;\n  };\n  types.list \x3d function(xs) {\n    return types.taggedValue(\x22list\x22, xs);\n  };\n  types.isList \x3d function(x) {\n    return x instanceof types.TaggedValue \x26\x26 x.tag \x3d\x3d\x3d \x22list\x22;\n  };\n  types.link \x3d function(rep) {\n    return types.taggedValue(\x22link\x22, rep);\n  };\n  types.isLink \x3d function(x) {\n    return x instanceof types.TaggedValue \x26\x26 x.tag \x3d\x3d\x3d \x22link\x22;\n  };\n  types.specialDouble \x3d function(v) {\n    switch(v) {\n      case \x22-INF\x22:\n        return -Infinity;\n      case \x22INF\x22:\n        return Infinity;\n      case \x22NaN\x22:\n        return NaN;\n      default:\n        throw new Error(\x22Invalid special double value \x22 + v);\n        break;\n    }\n  };\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.impl.decoder.js", true, "goog.provide(\x22com.cognitect.transit.impl.decoder\x22);\ngoog.require(\x22com.cognitect.transit.util\x22);\ngoog.require(\x22com.cognitect.transit.delimiters\x22);\ngoog.require(\x22com.cognitect.transit.caching\x22);\ngoog.require(\x22com.cognitect.transit.types\x22);\ngoog.scope(function() {\n  var decoder \x3d com.cognitect.transit.impl.decoder;\n  var util \x3d com.cognitect.transit.util;\n  var d \x3d com.cognitect.transit.delimiters;\n  var caching \x3d com.cognitect.transit.caching;\n  var types \x3d com.cognitect.transit.types;\n  decoder.Tag \x3d function Transit$Tag(s) {\n    this.str \x3d s;\n  };\n  decoder.tag \x3d function(s) {\n    return new decoder.Tag(s);\n  };\n  decoder.isTag \x3d function(x) {\n    return x \x26\x26 x instanceof decoder.Tag;\n  };\n  decoder.isGroundHandler \x3d function(handler) {\n    switch(handler) {\n      case \x22_\x22:\n      case \x22s\x22:\n      case \x22?\x22:\n      case \x22i\x22:\n      case \x22d\x22:\n      case \x22b\x22:\n      case \x22\x27\x22:\n      case \x22array\x22:\n      case \x22map\x22:\n        return true;\n    }\n    return false;\n  };\n  decoder.Decoder \x3d function Transit$Decoder(options) {\n    this.options \x3d options || {};\n    this.handlers \x3d {};\n    var h;\n    for (h in this.defaults.handlers) {\n      this.handlers[h] \x3d this.defaults.handlers[h];\n    }\n    for (h in this.options[\x22handlers\x22]) {\n      if (decoder.isGroundHandler(h)) {\n        throw new Error(\x27Cannot override handler for ground type \x22\x27 + h + \x27\x22\x27);\n      }\n      this.handlers[h] \x3d this.options[\x22handlers\x22][h];\n    }\n    this.preferStrings \x3d this.options[\x22preferStrings\x22] !\x3d null ? this.options[\x22preferStrings\x22] : this.defaults.preferStrings;\n    this.preferBuffers \x3d this.options[\x22preferBuffers\x22] !\x3d null ? this.options[\x22preferBuffers\x22] : this.defaults.preferBuffers;\n    this.defaultHandler \x3d this.options[\x22defaultHandler\x22] || this.defaults.defaultHandler;\n    this.mapBuilder \x3d this.options[\x22mapBuilder\x22];\n    this.arrayBuilder \x3d this.options[\x22arrayBuilder\x22];\n  };\n  decoder.Decoder.prototype.defaults \x3d {handlers:{\x22_\x22:function(v, d) {\n    return types.nullValue();\n  }, \x22?\x22:function(v, d) {\n    return types.boolValue(v);\n  }, \x22b\x22:function(v, d) {\n    return types.binary(v, d);\n  }, \x22i\x22:function(v, d) {\n    return types.intValue(v);\n  }, \x22n\x22:function(v, d) {\n    return types.bigInteger(v);\n  }, \x22d\x22:function(v, d) {\n    return types.floatValue(v);\n  }, \x22f\x22:function(v, d) {\n    return types.bigDecimalValue(v);\n  }, \x22c\x22:function(v, d) {\n    return types.charValue(v);\n  }, \x22:\x22:function(v, d) {\n    return types.keyword(v);\n  }, \x22$\x22:function(v, d) {\n    return types.symbol(v);\n  }, \x22r\x22:function(v, d) {\n    return types.uri(v);\n  }, \x22z\x22:function(v, d) {\n    return types.specialDouble(v);\n  }, \x22\x27\x22:function(v, d) {\n    return v;\n  }, \x22m\x22:function(v, d) {\n    return types.date(v);\n  }, \x22t\x22:function(v, d) {\n    return types.verboseDate(v);\n  }, \x22u\x22:function(v, d) {\n    return types.uuid(v);\n  }, \x22set\x22:function(v, d) {\n    return types.set(v);\n  }, \x22list\x22:function(v, d) {\n    return types.list(v);\n  }, \x22link\x22:function(v, d) {\n    return types.link(v);\n  }, \x22cmap\x22:function(v, d) {\n    return types.map(v, false);\n  }}, defaultHandler:function(c, val) {\n    return types.taggedValue(c, val);\n  }, preferStrings:true, preferBuffers:true};\n  decoder.Decoder.prototype.decode \x3d function(node, cache, asMapKey, tagValue) {\n    if (node \x3d\x3d null) {\n      return null;\n    }\n    var t \x3d typeof node;\n    switch(t) {\n      case \x22string\x22:\n        return this.decodeString(node, cache, asMapKey, tagValue);\n        break;\n      case \x22object\x22:\n        if (util.isArray(node)) {\n          if (node[0] \x3d\x3d\x3d \x22^ \x22) {\n            return this.decodeArrayHash(node, cache, asMapKey, tagValue);\n          } else {\n            return this.decodeArray(node, cache, asMapKey, tagValue);\n          }\n        } else {\n          return this.decodeHash(node, cache, asMapKey, tagValue);\n        }\n        break;\n    }\n    return node;\n  };\n  decoder.Decoder.prototype[\x22decode\x22] \x3d decoder.Decoder.prototype.decode;\n  decoder.Decoder.prototype.decodeString \x3d function(string, cache, asMapKey, tagValue) {\n    if (caching.isCacheable(string, asMapKey)) {\n      var val \x3d this.parseString(string, cache, false);\n      if (cache) {\n        cache.write(val, asMapKey);\n      }\n      return val;\n    } else if (caching.isCacheCode(string)) {\n      return cache.read(string, asMapKey);\n    } else {\n      return this.parseString(string, cache, asMapKey);\n    }\n  };\n  decoder.Decoder.prototype.decodeHash \x3d function(hash, cache, asMapKey, tagValue) {\n    var ks \x3d util.objectKeys(hash);\n    var key \x3d ks[0];\n    var tag \x3d ks.length \x3d\x3d 1 ? this.decode(key, cache, false, false) : null;\n    if (decoder.isTag(tag)) {\n      var val \x3d hash[key];\n      var handler \x3d this.handlers[tag.str];\n      if (handler !\x3d null) {\n        return handler(this.decode(val, cache, false, true), this);\n      } else {\n        return types.taggedValue(tag.str, this.decode(val, cache, false, false));\n      }\n    } else if (this.mapBuilder) {\n      if (ks.length \x3c types.SMALL_ARRAY_MAP_THRESHOLD * 2 \x26\x26 this.mapBuilder.fromArray) {\n        var nodep \x3d [];\n        var i \x3d 0;\n        for (; i \x3c ks.length; i++) {\n          var strKey \x3d ks[i];\n          nodep.push(this.decode(strKey, cache, true, false));\n          nodep.push(this.decode(hash[strKey], cache, false, false));\n        }\n        return this.mapBuilder.fromArray(nodep, hash);\n      } else {\n        var ret \x3d this.mapBuilder.init(hash);\n        i \x3d 0;\n        for (; i \x3c ks.length; i++) {\n          strKey \x3d ks[i];\n          ret \x3d this.mapBuilder.add(ret, this.decode(strKey, cache, true, false), this.decode(hash[strKey], cache, false, false), hash);\n        }\n        return this.mapBuilder.finalize(ret, hash);\n      }\n    } else {\n      nodep \x3d [];\n      i \x3d 0;\n      for (; i \x3c ks.length; i++) {\n        strKey \x3d ks[i];\n        nodep.push(this.decode(strKey, cache, true, false));\n        nodep.push(this.decode(hash[strKey], cache, false, false));\n      }\n      return types.map(nodep, false);\n    }\n  };\n  decoder.Decoder.prototype.decodeArrayHash \x3d function(node, cache, asMapKey, tagValue) {\n    if (this.mapBuilder) {\n      if (node.length \x3c types.SMALL_ARRAY_MAP_THRESHOLD * 2 + 1 \x26\x26 this.mapBuilder.fromArray) {\n        var nodep \x3d [];\n        var i \x3d 1;\n        for (; i \x3c node.length; i \x3d i + 2) {\n          nodep.push(this.decode(node[i], cache, true, false));\n          nodep.push(this.decode(node[i + 1], cache, false, false));\n        }\n        return this.mapBuilder.fromArray(nodep, node);\n      } else {\n        var ret \x3d this.mapBuilder.init(node);\n        i \x3d 1;\n        for (; i \x3c node.length; i \x3d i + 2) {\n          ret \x3d this.mapBuilder.add(ret, this.decode(node[i], cache, true, false), this.decode(node[i + 1], cache, false, false), node);\n        }\n        return this.mapBuilder.finalize(ret, node);\n      }\n    } else {\n      nodep \x3d [];\n      i \x3d 1;\n      for (; i \x3c node.length; i \x3d i + 2) {\n        nodep.push(this.decode(node[i], cache, true, false));\n        nodep.push(this.decode(node[i + 1], cache, false, false));\n      }\n      return types.map(nodep, false);\n    }\n  };\n  decoder.Decoder.prototype.decodeArray \x3d function(node, cache, asMapKey, tagValue) {\n    if (tagValue) {\n      var ret \x3d [];\n      var i \x3d 0;\n      for (; i \x3c node.length; i++) {\n        ret.push(this.decode(node[i], cache, asMapKey, false));\n      }\n      return ret;\n    } else {\n      var cacheIdx \x3d cache \x26\x26 cache.idx;\n      if (node.length \x3d\x3d\x3d 2 \x26\x26 typeof node[0] \x3d\x3d\x3d \x22string\x22) {\n        var tag \x3d this.decode(node[0], cache, false, false);\n        if (decoder.isTag(tag)) {\n          var val \x3d node[1];\n          var handler \x3d this.handlers[tag.str];\n          if (handler !\x3d null) {\n            ret \x3d handler(this.decode(val, cache, asMapKey, true), this);\n            return ret;\n          } else {\n            return types.taggedValue(tag.str, this.decode(val, cache, asMapKey, false));\n          }\n        }\n      }\n      if (cache \x26\x26 cacheIdx !\x3d cache.idx) {\n        cache.idx \x3d cacheIdx;\n      }\n      if (this.arrayBuilder) {\n        if (node.length \x3c\x3d 32 \x26\x26 this.arrayBuilder.fromArray) {\n          var arr \x3d [];\n          i \x3d 0;\n          for (; i \x3c node.length; i++) {\n            arr.push(this.decode(node[i], cache, asMapKey, false));\n          }\n          return this.arrayBuilder.fromArray(arr, node);\n        } else {\n          ret \x3d this.arrayBuilder.init(node);\n          i \x3d 0;\n          for (; i \x3c node.length; i++) {\n            ret \x3d this.arrayBuilder.add(ret, this.decode(node[i], cache, asMapKey, false), node);\n          }\n          return this.arrayBuilder.finalize(ret, node);\n        }\n      } else {\n        ret \x3d [];\n        i \x3d 0;\n        for (; i \x3c node.length; i++) {\n          ret.push(this.decode(node[i], cache, asMapKey, false));\n        }\n        return ret;\n      }\n    }\n  };\n  decoder.Decoder.prototype.parseString \x3d function(string, cache, asMapKey) {\n    if (string.charAt(0) \x3d\x3d\x3d d.ESC) {\n      var c \x3d string.charAt(1);\n      if (c \x3d\x3d\x3d d.ESC || c \x3d\x3d\x3d d.SUB || c \x3d\x3d\x3d d.RES) {\n        return string.substring(1);\n      } else if (c \x3d\x3d\x3d d.TAG) {\n        return decoder.tag(string.substring(2));\n      } else {\n        var handler \x3d this.handlers[c];\n        if (handler \x3d\x3d null) {\n          return this.defaultHandler(c, string.substring(2));\n        } else {\n          return handler(string.substring(2), this);\n        }\n      }\n    } else {\n      return string;\n    }\n  };\n  decoder.decoder \x3d function(options) {\n    return new decoder.Decoder(options);\n  };\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.impl.reader.js", true, "goog.provide(\x22com.cognitect.transit.impl.reader\x22);\ngoog.require(\x22com.cognitect.transit.impl.decoder\x22);\ngoog.require(\x22com.cognitect.transit.caching\x22);\ngoog.scope(function() {\n  var reader \x3d com.cognitect.transit.impl.reader;\n  var decoder \x3d com.cognitect.transit.impl.decoder;\n  var caching \x3d com.cognitect.transit.caching;\n  reader.JSONUnmarshaller \x3d function Transit$JSONUnmarshaller(opts) {\n    this.decoder \x3d new decoder.Decoder(opts);\n  };\n  reader.JSONUnmarshaller.prototype.unmarshal \x3d function(str, cache) {\n    return this.decoder.decode(JSON.parse(str), cache);\n  };\n  reader.Reader \x3d function Transit$Reader(unmarshaller, options) {\n    this.unmarshaller \x3d unmarshaller;\n    this.options \x3d options || {};\n    this.cache \x3d this.options[\x22cache\x22] ? this.options[\x22cache\x22] : new caching.ReadCache();\n  };\n  reader.Reader.prototype.read \x3d function(str) {\n    var ret \x3d this.unmarshaller.unmarshal(str, this.cache);\n    this.cache.clear();\n    return ret;\n  };\n  reader.Reader.prototype[\x22read\x22] \x3d reader.Reader.prototype.read;\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.handlers.js", true, "goog.provide(\x22com.cognitect.transit.handlers\x22);\ngoog.require(\x22com.cognitect.transit.util\x22);\ngoog.require(\x22com.cognitect.transit.types\x22);\ngoog.require(\x22goog.math.Long\x22);\ngoog.scope(function() {\n  var handlers \x3d com.cognitect.transit.handlers;\n  var util \x3d com.cognitect.transit.util;\n  var types \x3d com.cognitect.transit.types;\n  var Long \x3d goog.math.Long;\n  handlers.ctorGuid \x3d 0;\n  handlers.ctorGuidProperty \x3d \x22transit$guid$\x22 + util.randomUUID();\n  handlers.typeTag \x3d function(ctor) {\n    if (ctor \x3d\x3d null) {\n      return \x22null\x22;\n    } else if (ctor \x3d\x3d\x3d String) {\n      return \x22string\x22;\n    } else if (ctor \x3d\x3d\x3d Boolean) {\n      return \x22boolean\x22;\n    } else if (ctor \x3d\x3d\x3d Number) {\n      return \x22number\x22;\n    } else if (ctor \x3d\x3d\x3d Array) {\n      return \x22array\x22;\n    } else if (ctor \x3d\x3d\x3d Object) {\n      return \x22map\x22;\n    } else {\n      var tag \x3d ctor[handlers.ctorGuidProperty];\n      if (tag \x3d\x3d null) {\n        if (typeof Object.defineProperty !\x3d \x22undefined\x22) {\n          tag \x3d ++handlers.ctorGuid;\n          Object.defineProperty(ctor, handlers.ctorGuidProperty, {value:tag, enumerable:false});\n        } else {\n          ctor[handlers.ctorGuidProperty] \x3d tag \x3d ++handlers.ctorGuid;\n        }\n      }\n      return tag;\n    }\n  };\n  handlers.constructor \x3d function(x) {\n    if (x \x3d\x3d null) {\n      return null;\n    } else {\n      return x.constructor;\n    }\n  };\n  handlers.padZeros \x3d function(n, m) {\n    var s \x3d n.toString();\n    var i \x3d s.length;\n    for (; i \x3c m; i++) {\n      s \x3d \x220\x22 + s;\n    }\n    return s;\n  };\n  handlers.stringableKeys \x3d function(m) {\n    var stringable \x3d false;\n    var ks \x3d util.objectKeys(m);\n    var i \x3d 0;\n    for (; i \x3c ks.length; i++) {\n    }\n    return true;\n  };\n  handlers.NilHandler \x3d function Transit$NilHandler() {\n  };\n  handlers.NilHandler.prototype.tag \x3d function(v) {\n    return \x22_\x22;\n  };\n  handlers.NilHandler.prototype.rep \x3d function(v) {\n    return null;\n  };\n  handlers.NilHandler.prototype.stringRep \x3d function(v) {\n    return \x22null\x22;\n  };\n  handlers.StringHandler \x3d function Transit$StringHandler() {\n  };\n  handlers.StringHandler.prototype.tag \x3d function(v) {\n    return \x22s\x22;\n  };\n  handlers.StringHandler.prototype.rep \x3d function(v) {\n    return v;\n  };\n  handlers.StringHandler.prototype.stringRep \x3d function(v) {\n    return v;\n  };\n  handlers.NumberHandler \x3d function Transit$NumberHandler() {\n  };\n  handlers.NumberHandler.prototype.tag \x3d function(v) {\n    return \x22i\x22;\n  };\n  handlers.NumberHandler.prototype.rep \x3d function(v) {\n    return v;\n  };\n  handlers.NumberHandler.prototype.stringRep \x3d function(v) {\n    return v.toString();\n  };\n  handlers.IntegerHandler \x3d function Transit$IntegerHandler() {\n  };\n  handlers.IntegerHandler.prototype.tag \x3d function(v) {\n    return \x22i\x22;\n  };\n  handlers.IntegerHandler.prototype.rep \x3d function(v) {\n    return v.toString();\n  };\n  handlers.IntegerHandler.prototype.stringRep \x3d function(v) {\n    return v.toString();\n  };\n  handlers.BooleanHandler \x3d function Transit$BooleanHandler() {\n  };\n  handlers.BooleanHandler.prototype.tag \x3d function(v) {\n    return \x22?\x22;\n  };\n  handlers.BooleanHandler.prototype.rep \x3d function(v) {\n    return v;\n  };\n  handlers.BooleanHandler.prototype.stringRep \x3d function(v) {\n    return v.toString();\n  };\n  handlers.ArrayHandler \x3d function Transit$ArrayHandler() {\n  };\n  handlers.ArrayHandler.prototype.tag \x3d function(v) {\n    return \x22array\x22;\n  };\n  handlers.ArrayHandler.prototype.rep \x3d function(v) {\n    return v;\n  };\n  handlers.ArrayHandler.prototype.stringRep \x3d function(v) {\n    return null;\n  };\n  handlers.MapHandler \x3d function Transit$MapHandler() {\n  };\n  handlers.MapHandler.prototype.tag \x3d function(v) {\n    return \x22map\x22;\n  };\n  handlers.MapHandler.prototype.rep \x3d function(v) {\n    return v;\n  };\n  handlers.MapHandler.prototype.stringRep \x3d function(v) {\n    return null;\n  };\n  handlers.VerboseDateHandler \x3d function Transit$VerboseDateHandler() {\n  };\n  handlers.VerboseDateHandler.prototype.tag \x3d function(v) {\n    return \x22t\x22;\n  };\n  handlers.VerboseDateHandler.prototype.rep \x3d function(v) {\n    return v.getUTCFullYear() + \x22-\x22 + handlers.padZeros(v.getUTCMonth() + 1, 2) + \x22-\x22 + handlers.padZeros(v.getUTCDate(), 2) + \x22T\x22 + handlers.padZeros(v.getUTCHours(), 2) + \x22:\x22 + handlers.padZeros(v.getUTCMinutes(), 2) + \x22:\x22 + handlers.padZeros(v.getUTCSeconds(), 2) + \x22.\x22 + handlers.padZeros(v.getUTCMilliseconds(), 3) + \x22Z\x22;\n  };\n  handlers.VerboseDateHandler.prototype.stringRep \x3d function(v, h) {\n    return h.rep(v);\n  };\n  handlers.DateHandler \x3d function Transit$DateHandler() {\n  };\n  handlers.DateHandler.prototype.tag \x3d function(v) {\n    return \x22m\x22;\n  };\n  handlers.DateHandler.prototype.rep \x3d function(v) {\n    return v.valueOf();\n  };\n  handlers.DateHandler.prototype.stringRep \x3d function(v) {\n    return v.valueOf().toString();\n  };\n  handlers.DateHandler.prototype.getVerboseHandler \x3d function(v) {\n    return new handlers.VerboseDateHandler();\n  };\n  handlers.UUIDHandler \x3d function Transit$UUIDHandler() {\n  };\n  handlers.UUIDHandler.prototype.tag \x3d function(v) {\n    return \x22u\x22;\n  };\n  handlers.UUIDHandler.prototype.rep \x3d function(v) {\n    return v.toString();\n  };\n  handlers.UUIDHandler.prototype.stringRep \x3d function(v) {\n    return v.toString();\n  };\n  handlers.KeywordHandler \x3d function Transit$KeywordHandler() {\n  };\n  handlers.KeywordHandler.prototype.tag \x3d function(v) {\n    return \x22:\x22;\n  };\n  handlers.KeywordHandler.prototype.rep \x3d function(v) {\n    return v._name;\n  };\n  handlers.KeywordHandler.prototype.stringRep \x3d function(v, h) {\n    return h.rep(v);\n  };\n  handlers.SymbolHandler \x3d function Transit$SymbolHandler() {\n  };\n  handlers.SymbolHandler.prototype.tag \x3d function(v) {\n    return \x22$\x22;\n  };\n  handlers.SymbolHandler.prototype.rep \x3d function(v) {\n    return v._name;\n  };\n  handlers.SymbolHandler.prototype.stringRep \x3d function(v, h) {\n    return h.rep(v);\n  };\n  handlers.TaggedHandler \x3d function Transit$TaggedHandler() {\n  };\n  handlers.TaggedHandler.prototype.tag \x3d function(v) {\n    return v.tag;\n  };\n  handlers.TaggedHandler.prototype.rep \x3d function(v) {\n    return v.rep;\n  };\n  handlers.TaggedHandler.prototype.stringRep \x3d function(v, h) {\n    return null;\n  };\n  handlers.TransitSetHandler \x3d function Transit$TransitSetHandler() {\n  };\n  handlers.TransitSetHandler.prototype.tag \x3d function(v) {\n    return \x22set\x22;\n  };\n  handlers.TransitSetHandler.prototype.rep \x3d function(v) {\n    var arr \x3d [];\n    v.forEach(function(key, set) {\n      arr.push(key);\n    });\n    return types.taggedValue(\x22array\x22, arr);\n  };\n  handlers.TransitSetHandler.prototype.stringRep \x3d function(v, h) {\n    return null;\n  };\n  handlers.TransitArrayMapHandler \x3d function Transit$ArrayMapHandler() {\n  };\n  handlers.TransitArrayMapHandler.prototype.tag \x3d function(v) {\n    return \x22map\x22;\n  };\n  handlers.TransitArrayMapHandler.prototype.rep \x3d function(v) {\n    return v;\n  };\n  handlers.TransitArrayMapHandler.prototype.stringRep \x3d function(v, h) {\n    return null;\n  };\n  handlers.TransitMapHandler \x3d function Transit$MapHandler() {\n  };\n  handlers.TransitMapHandler.prototype.tag \x3d function(v) {\n    return \x22map\x22;\n  };\n  handlers.TransitMapHandler.prototype.rep \x3d function(v) {\n    return v;\n  };\n  handlers.TransitMapHandler.prototype.stringRep \x3d function(v, h) {\n    return null;\n  };\n  handlers.BufferHandler \x3d function Transit$BufferHandler() {\n  };\n  handlers.BufferHandler.prototype.tag \x3d function(v) {\n    return \x22b\x22;\n  };\n  handlers.BufferHandler.prototype.rep \x3d function(v) {\n    return v.toString(\x22base64\x22);\n  };\n  handlers.BufferHandler.prototype.stringRep \x3d function(v, h) {\n    return null;\n  };\n  handlers.Uint8ArrayHandler \x3d function Transit$Uint8ArrayHandler() {\n  };\n  handlers.Uint8ArrayHandler.prototype.tag \x3d function(v) {\n    return \x22b\x22;\n  };\n  handlers.Uint8ArrayHandler.prototype.rep \x3d function(v) {\n    return util.Uint8ToBase64(v);\n  };\n  handlers.Uint8ArrayHandler.prototype.stringRep \x3d function(v, h) {\n    return null;\n  };\n  handlers.defaultHandlers \x3d function(hs) {\n    hs.set(null, new handlers.NilHandler());\n    hs.set(String, new handlers.StringHandler());\n    hs.set(Number, new handlers.NumberHandler());\n    hs.set(Long, new handlers.IntegerHandler());\n    hs.set(Boolean, new handlers.BooleanHandler());\n    hs.set(Array, new handlers.ArrayHandler());\n    hs.set(Object, new handlers.MapHandler());\n    hs.set(Date, new handlers.DateHandler());\n    hs.set(types.UUID, new handlers.UUIDHandler());\n    hs.set(types.Keyword, new handlers.KeywordHandler());\n    hs.set(types.Symbol, new handlers.SymbolHandler());\n    hs.set(types.TaggedValue, new handlers.TaggedHandler());\n    hs.set(types.TransitSet, new handlers.TransitSetHandler());\n    hs.set(types.TransitArrayMap, new handlers.TransitArrayMapHandler());\n    hs.set(types.TransitMap, new handlers.TransitMapHandler());\n    if (typeof goog.global.Buffer !\x3d \x22undefined\x22) {\n      hs.set(goog.global.Buffer, new handlers.BufferHandler());\n    }\n    if (typeof Uint8Array !\x3d \x22undefined\x22) {\n      hs.set(Uint8Array, new handlers.Uint8ArrayHandler());\n    }\n    return hs;\n  };\n  handlers.Handlers \x3d function Transit$Handlers() {\n    this.handlers \x3d {};\n    handlers.defaultHandlers(this);\n  };\n  handlers.Handlers.prototype.get \x3d function(ctor) {\n    var h \x3d null;\n    if (typeof ctor \x3d\x3d\x3d \x22string\x22) {\n      h \x3d this.handlers[ctor];\n    } else {\n      h \x3d this.handlers[handlers.typeTag(ctor)];\n    }\n    if (h !\x3d null) {\n      return h;\n    } else {\n      return this.handlers[\x22default\x22];\n    }\n  };\n  handlers.Handlers.prototype[\x22get\x22] \x3d handlers.Handlers.prototype.get;\n  handlers.validTag \x3d function(tag) {\n    switch(tag) {\n      case \x22null\x22:\n      case \x22string\x22:\n      case \x22boolean\x22:\n      case \x22number\x22:\n      case \x22array\x22:\n      case \x22map\x22:\n        return false;\n        break;\n    }\n    return true;\n  };\n  handlers.Handlers.prototype.set \x3d function(ctor, handler) {\n    if (typeof ctor \x3d\x3d\x3d \x22string\x22 \x26\x26 handlers.validTag(ctor)) {\n      this.handlers[ctor] \x3d handler;\n    } else {\n      this.handlers[handlers.typeTag(ctor)] \x3d handler;\n    }\n  };\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.impl.writer.js", true, "goog.provide(\x22com.cognitect.transit.impl.writer\x22);\ngoog.require(\x22com.cognitect.transit.util\x22);\ngoog.require(\x22com.cognitect.transit.caching\x22);\ngoog.require(\x22com.cognitect.transit.handlers\x22);\ngoog.require(\x22com.cognitect.transit.types\x22);\ngoog.require(\x22com.cognitect.transit.delimiters\x22);\ngoog.require(\x22goog.math.Long\x22);\ngoog.scope(function() {\n  var writer \x3d com.cognitect.transit.impl.writer;\n  var util \x3d com.cognitect.transit.util;\n  var caching \x3d com.cognitect.transit.caching;\n  var handlers \x3d com.cognitect.transit.handlers;\n  var types \x3d com.cognitect.transit.types;\n  var d \x3d com.cognitect.transit.delimiters;\n  var Long \x3d goog.math.Long;\n  writer.escape \x3d function(string) {\n    if (string.length \x3e 0) {\n      var c \x3d string.charAt(0);\n      if (c \x3d\x3d\x3d d.ESC || c \x3d\x3d\x3d d.SUB || c \x3d\x3d\x3d d.RES) {\n        return d.ESC + string;\n      } else {\n        return string;\n      }\n    } else {\n      return string;\n    }\n  };\n  writer.JSONMarshaller \x3d function Transit$JSONMarshaller(opts) {\n    this.opts \x3d opts || {};\n    this.preferStrings \x3d this.opts[\x22preferStrings\x22] !\x3d null ? this.opts[\x22preferStrings\x22] : true;\n    this.objectBuilder \x3d this.opts[\x22objectBuilder\x22] || null;\n    this.transform \x3d this.opts[\x22transform\x22] || null;\n    this.handlers \x3d new handlers.Handlers();\n    var optsHandlers \x3d this.opts[\x22handlers\x22];\n    if (optsHandlers) {\n      if (util.isArray(optsHandlers) || !optsHandlers.forEach) {\n        throw new Error(\x27transit writer \x22handlers\x22 option must be a map\x27);\n      }\n      var self \x3d this;\n      optsHandlers.forEach(function(v, k) {\n        if (k !\x3d\x3d undefined) {\n          self.handlers.set(k, v);\n        } else {\n          throw new Error(\x22Cannot create handler for JavaScript undefined\x22);\n        }\n      });\n    }\n    this.handlerForForeign \x3d this.opts[\x22handlerForForeign\x22];\n    this.unpack \x3d this.opts[\x22unpack\x22] || function(x) {\n      if (types.isArrayMap(x) \x26\x26 x.backingMap \x3d\x3d\x3d null) {\n        return x._entries;\n      } else {\n        return false;\n      }\n    };\n    this.verbose \x3d this.opts \x26\x26 this.opts[\x22verbose\x22] || false;\n  };\n  writer.JSONMarshaller.prototype.handler \x3d function(obj) {\n    var h \x3d this.handlers.get(handlers.constructor(obj));\n    if (h !\x3d null) {\n      return h;\n    } else {\n      var tag \x3d obj \x26\x26 obj[\x22transitTag\x22];\n      if (tag) {\n        return this.handlers.get(tag);\n      } else {\n        return null;\n      }\n    }\n  };\n  writer.JSONMarshaller.prototype.registerHandler \x3d function(ctor, handler) {\n    this.handlers.set(ctor, handler);\n  };\n  writer.JSONMarshaller.prototype.emitNil \x3d function(asMapKey, cache) {\n    if (asMapKey) {\n      return this.emitString(d.ESC, \x22_\x22, \x22\x22, asMapKey, cache);\n    } else {\n      return null;\n    }\n  };\n  writer.JSONMarshaller.prototype.emitString \x3d function(prefix, tag, s, asMapKey, cache) {\n    var string \x3d prefix + tag + s;\n    if (cache) {\n      return cache.write(string, asMapKey);\n    } else {\n      return string;\n    }\n  };\n  writer.JSONMarshaller.prototype.emitBoolean \x3d function(b, asMapKey, cache) {\n    if (asMapKey) {\n      var s \x3d b.toString();\n      return this.emitString(d.ESC, \x22?\x22, s[0], asMapKey, cache);\n    } else {\n      return b;\n    }\n  };\n  writer.JSONMarshaller.prototype.emitInteger \x3d function(i, asMapKey, cache) {\n    if (i \x3d\x3d\x3d Infinity) {\n      return this.emitString(d.ESC, \x22z\x22, \x22INF\x22, asMapKey, cache);\n    } else if (i \x3d\x3d\x3d -Infinity) {\n      return this.emitString(d.ESC, \x22z\x22, \x22-INF\x22, asMapKey, cache);\n    } else if (isNaN(i)) {\n      return this.emitString(d.ESC, \x22z\x22, \x22NaN\x22, asMapKey, cache);\n    } else if (asMapKey || typeof i \x3d\x3d\x3d \x22string\x22 || i instanceof Long) {\n      return this.emitString(d.ESC, \x22i\x22, i.toString(), asMapKey, cache);\n    } else {\n      return i;\n    }\n  };\n  writer.JSONMarshaller.prototype.emitDouble \x3d function(d, asMapKey, cache) {\n    if (asMapKey) {\n      return this.emitString(d.ESC, \x22d\x22, d, asMapKey, cache);\n    } else {\n      return d;\n    }\n  };\n  writer.JSONMarshaller.prototype.emitBinary \x3d function(b, asMapKey, cache) {\n    return this.emitString(d.ESC, \x22b\x22, b, asMapKey, cache);\n  };\n  writer.JSONMarshaller.prototype.emitQuoted \x3d function(em, obj, cache) {\n    if (em.verbose) {\n      var ret \x3d {};\n      var k \x3d this.emitString(d.ESC_TAG, \x22\x27\x22, \x22\x22, true, cache);\n      ret[k] \x3d writer.marshal(this, obj, false, cache);\n      return ret;\n    } else {\n      return [this.emitString(d.ESC_TAG, \x22\x27\x22, \x22\x22, true, cache), writer.marshal(this, obj, false, cache)];\n    }\n  };\n  writer.emitObjects \x3d function(em, iterable, cache) {\n    var ret \x3d [];\n    if (util.isArray(iterable)) {\n      var i \x3d 0;\n      for (; i \x3c iterable.length; i++) {\n        ret.push(writer.marshal(em, iterable[i], false, cache));\n      }\n    } else {\n      iterable.forEach(function(v, i) {\n        ret.push(writer.marshal(em, v, false, cache));\n      });\n    }\n    return ret;\n  };\n  writer.emitArray \x3d function(em, iterable, skip, cache) {\n    return writer.emitObjects(em, iterable, cache);\n  };\n  writer.isStringableKey \x3d function(em, k) {\n    if (typeof k !\x3d\x3d \x22string\x22) {\n      var h \x3d em.handler(k);\n      return h \x26\x26 h.tag(k).length \x3d\x3d\x3d 1;\n    } else {\n      return true;\n    }\n  };\n  writer.stringableKeys \x3d function(em, obj) {\n    var arr \x3d em.unpack(obj);\n    var stringableKeys \x3d true;\n    if (arr) {\n      var i \x3d 0;\n      for (; i \x3c arr.length; i \x3d i + 2) {\n        stringableKeys \x3d writer.isStringableKey(em, arr[i]);\n        if (!stringableKeys) {\n          break;\n        }\n      }\n      return stringableKeys;\n    } else if (obj.keys) {\n      var iter \x3d obj.keys();\n      var step \x3d null;\n      if (iter.next) {\n        step \x3d iter.next();\n        for (; !step.done;) {\n          stringableKeys \x3d writer.isStringableKey(em, step.value);\n          if (!stringableKeys) {\n            break;\n          }\n          step \x3d iter.next();\n        }\n        return stringableKeys;\n      }\n    }\n    if (obj.forEach) {\n      obj.forEach(function(v, k) {\n        stringableKeys \x3d stringableKeys \x26\x26 writer.isStringableKey(em, k);\n      });\n      return stringableKeys;\n    } else {\n      throw new Error(\x22Cannot walk keys of object type \x22 + handlers.constructor(obj).name);\n    }\n  };\n  writer.isForeignObject \x3d function(x) {\n    if (x.constructor[\x22transit$isObject\x22]) {\n      return true;\n    }\n    var ret \x3d x.constructor.toString();\n    ret \x3d ret.substr(\x22function \x22.length);\n    ret \x3d ret.substr(0, ret.indexOf(\x22(\x22));\n    var isObject \x3d ret \x3d\x3d \x22Object\x22;\n    if (typeof Object.defineProperty !\x3d \x22undefined\x22) {\n      Object.defineProperty(x.constructor, \x22transit$isObject\x22, {value:isObject, enumerable:false});\n    } else {\n      x.constructor[\x22transit$isObject\x22] \x3d isObject;\n    }\n    return isObject;\n  };\n  writer.emitMap \x3d function(em, obj, skip, cache) {\n    var arr \x3d null;\n    var rep \x3d null;\n    var tag \x3d null;\n    var ks \x3d null;\n    var i \x3d 0;\n    if (obj.constructor \x3d\x3d\x3d Object || obj.forEach !\x3d null || em.handlerForForeign \x26\x26 writer.isForeignObject(obj)) {\n      if (em.verbose) {\n        if (obj.forEach !\x3d null) {\n          if (writer.stringableKeys(em, obj)) {\n            var ret \x3d {};\n            obj.forEach(function(v, k) {\n              ret[writer.marshal(em, k, true, false)] \x3d writer.marshal(em, v, false, cache);\n            });\n            return ret;\n          } else {\n            arr \x3d em.unpack(obj);\n            rep \x3d [];\n            tag \x3d em.emitString(d.ESC_TAG, \x22cmap\x22, \x22\x22, true, cache);\n            if (arr) {\n              for (; i \x3c arr.length; i \x3d i + 2) {\n                rep.push(writer.marshal(em, arr[i], false, false));\n                rep.push(writer.marshal(em, arr[i + 1], false, cache));\n              }\n            } else {\n              obj.forEach(function(v, k) {\n                rep.push(writer.marshal(em, k, false, false));\n                rep.push(writer.marshal(em, v, false, cache));\n              });\n            }\n            ret \x3d {};\n            ret[tag] \x3d rep;\n            return ret;\n          }\n        } else {\n          ks \x3d util.objectKeys(obj);\n          ret \x3d {};\n          for (; i \x3c ks.length; i++) {\n            ret[writer.marshal(em, ks[i], true, false)] \x3d writer.marshal(em, obj[ks[i]], false, cache);\n          }\n          return ret;\n        }\n      } else {\n        if (obj.forEach !\x3d null) {\n          if (writer.stringableKeys(em, obj)) {\n            arr \x3d em.unpack(obj);\n            ret \x3d [\x22^ \x22];\n            if (arr) {\n              for (; i \x3c arr.length; i \x3d i + 2) {\n                ret.push(writer.marshal(em, arr[i], true, cache));\n                ret.push(writer.marshal(em, arr[i + 1], false, cache));\n              }\n            } else {\n              obj.forEach(function(v, k) {\n                ret.push(writer.marshal(em, k, true, cache));\n                ret.push(writer.marshal(em, v, false, cache));\n              });\n            }\n            return ret;\n          } else {\n            arr \x3d em.unpack(obj);\n            rep \x3d [];\n            tag \x3d em.emitString(d.ESC_TAG, \x22cmap\x22, \x22\x22, true, cache);\n            if (arr) {\n              for (; i \x3c arr.length; i \x3d i + 2) {\n                rep.push(writer.marshal(em, arr[i], false, cache));\n                rep.push(writer.marshal(em, arr[i + 1], false, cache));\n              }\n            } else {\n              obj.forEach(function(v, k) {\n                rep.push(writer.marshal(em, k, false, cache));\n                rep.push(writer.marshal(em, v, false, cache));\n              });\n            }\n            return [tag, rep];\n          }\n        } else {\n          ret \x3d [\x22^ \x22];\n          ks \x3d util.objectKeys(obj);\n          for (; i \x3c ks.length; i++) {\n            ret.push(writer.marshal(em, ks[i], true, cache));\n            ret.push(writer.marshal(em, obj[ks[i]], false, cache));\n          }\n          return ret;\n        }\n      }\n    } else if (em.objectBuilder !\x3d null) {\n      return em.objectBuilder(obj, function(k) {\n        return writer.marshal(em, k, true, cache);\n      }, function(v) {\n        return writer.marshal(em, v, false, cache);\n      });\n    } else {\n      var name \x3d handlers.constructor(obj).name;\n      var err \x3d new Error(\x22Cannot write \x22 + name);\n      err.data \x3d {obj:obj, type:name};\n      throw err;\n    }\n  };\n  writer.emitTaggedMap \x3d function(em, tag, rep, skip, cache) {\n    if (em.verbose) {\n      var ret \x3d {};\n      ret[em.emitString(d.ESC_TAG, tag, \x22\x22, true, cache)] \x3d writer.marshal(em, rep, false, cache);\n      return ret;\n    } else {\n      return [em.emitString(d.ESC_TAG, tag, \x22\x22, true, cache), writer.marshal(em, rep, false, cache)];\n    }\n  };\n  writer.emitEncoded \x3d function(em, h, tag, rep, obj, asMapKey, cache) {\n    if (tag.length \x3d\x3d\x3d 1) {\n      if (typeof rep \x3d\x3d\x3d \x22string\x22) {\n        return em.emitString(d.ESC, tag, rep, asMapKey, cache);\n      } else if (asMapKey || em.preferStrings) {\n        var vh \x3d em.verbose \x26\x26 h.getVerboseHandler();\n        if (vh) {\n          tag \x3d vh.tag(obj);\n          rep \x3d vh.stringRep(obj, vh);\n        } else {\n          rep \x3d h.stringRep(obj, h);\n        }\n        if (rep !\x3d\x3d null) {\n          return em.emitString(d.ESC, tag, rep, asMapKey, cache);\n        } else {\n          var err \x3d new Error(\x27Tag \x22\x27 + tag + \x27\x22 cannot be encoded as string\x27);\n          err.data \x3d {tag:tag, rep:rep, obj:obj};\n          throw err;\n        }\n      } else {\n        return writer.emitTaggedMap(em, tag, rep, asMapKey, cache);\n      }\n    } else {\n      return writer.emitTaggedMap(em, tag, rep, asMapKey, cache);\n    }\n  };\n  writer.marshal \x3d function(em, obj, asMapKey, cache) {\n    if (em.transform !\x3d\x3d null) {\n      obj \x3d em.transform(obj);\n    }\n    var h \x3d em.handler(obj) || (em.handlerForForeign ? em.handlerForForeign(obj, em.handlers) : null);\n    var tag \x3d h ? h.tag(obj) : null;\n    var rep \x3d h ? h.rep(obj) : null;\n    if (h !\x3d null \x26\x26 tag !\x3d null) {\n      switch(tag) {\n        case \x22_\x22:\n          return em.emitNil(asMapKey, cache);\n          break;\n        case \x22s\x22:\n          return em.emitString(\x22\x22, \x22\x22, writer.escape(rep), asMapKey, cache);\n          break;\n        case \x22?\x22:\n          return em.emitBoolean(rep, asMapKey, cache);\n          break;\n        case \x22i\x22:\n          return em.emitInteger(rep, asMapKey, cache);\n          break;\n        case \x22d\x22:\n          return em.emitDouble(rep, asMapKey, cache);\n          break;\n        case \x22b\x22:\n          return em.emitBinary(rep, asMapKey, cache);\n          break;\n        case \x22\x27\x22:\n          return em.emitQuoted(em, rep, cache);\n          break;\n        case \x22array\x22:\n          return writer.emitArray(em, rep, asMapKey, cache);\n          break;\n        case \x22map\x22:\n          return writer.emitMap(em, rep, asMapKey, cache);\n          break;\n        default:\n          return writer.emitEncoded(em, h, tag, rep, obj, asMapKey, cache);\n          break;\n      }\n    } else {\n      var name \x3d handlers.constructor(obj).name;\n      var err \x3d new Error(\x22Cannot write \x22 + name);\n      err.data \x3d {obj:obj, type:name};\n      throw err;\n    }\n  };\n  writer.maybeQuoted \x3d function(em, obj) {\n    var h \x3d em.handler(obj) || (em.handlerForForeign ? em.handlerForForeign(obj, em.handlers) : null);\n    if (h !\x3d null) {\n      if (h.tag(obj).length \x3d\x3d\x3d 1) {\n        return types.quoted(obj);\n      } else {\n        return obj;\n      }\n    } else {\n      var name \x3d handlers.constructor(obj).name;\n      var err \x3d new Error(\x22Cannot write \x22 + name);\n      err.data \x3d {obj:obj, type:name};\n      throw err;\n    }\n  };\n  writer.marshalTop \x3d function(em, obj, asMapKey, cache) {\n    return JSON.stringify(writer.marshal(em, writer.maybeQuoted(em, obj), asMapKey, cache));\n  };\n  writer.Writer \x3d function Transit$Writer(marshaller, options) {\n    this._marshaller \x3d marshaller;\n    this.options \x3d options || {};\n    if (this.options[\x22cache\x22] \x3d\x3d\x3d false) {\n      this.cache \x3d null;\n    } else {\n      this.cache \x3d this.options[\x22cache\x22] ? this.options[\x22cache\x22] : new caching.WriteCache();\n    }\n  };\n  writer.Writer.prototype.marshaller \x3d function() {\n    return this._marshaller;\n  };\n  writer.Writer.prototype[\x22marshaller\x22] \x3d writer.Writer.prototype.marshaller;\n  writer.Writer.prototype.write \x3d function(obj, opts) {\n    var ret \x3d null;\n    var ropts \x3d opts || {};\n    var asMapKey \x3d ropts[\x22asMapKey\x22] || false;\n    var cache \x3d this._marshaller.verbose ? false : this.cache;\n    if (ropts[\x22marshalTop\x22] \x3d\x3d\x3d false) {\n      ret \x3d writer.marshal(this._marshaller, obj, asMapKey, cache);\n    } else {\n      ret \x3d writer.marshalTop(this._marshaller, obj, asMapKey, cache);\n    }\n    if (this.cache !\x3d null) {\n      this.cache.clear();\n    }\n    return ret;\n  };\n  writer.Writer.prototype[\x22write\x22] \x3d writer.Writer.prototype.write;\n  writer.Writer.prototype.register \x3d function(type, handler) {\n    this._marshaller.registerHandler(type, handler);\n  };\n  writer.Writer.prototype[\x22register\x22] \x3d writer.Writer.prototype.register;\n});\n");
SHADOW_ENV.evalLoad("com.cognitect.transit.js", true, "goog.provide(\x22com.cognitect.transit\x22);\ngoog.require(\x22com.cognitect.transit.util\x22);\ngoog.require(\x22com.cognitect.transit.impl.reader\x22);\ngoog.require(\x22com.cognitect.transit.impl.writer\x22);\ngoog.require(\x22com.cognitect.transit.types\x22);\ngoog.require(\x22com.cognitect.transit.eq\x22);\ngoog.require(\x22com.cognitect.transit.impl.decoder\x22);\ngoog.require(\x22com.cognitect.transit.caching\x22);\nvar TRANSIT_DEV \x3d true;\nvar TRANSIT_NODE_TARGET \x3d false;\nvar TRANSIT_BROWSER_TARGET \x3d false;\nvar TRANSIT_BROWSER_AMD_TARGET \x3d false;\ngoog.scope(function() {\n  var transit \x3d com.cognitect.transit;\n  var util \x3d com.cognitect.transit.util;\n  var reader \x3d com.cognitect.transit.impl.reader;\n  var writer \x3d com.cognitect.transit.impl.writer;\n  var decoder \x3d com.cognitect.transit.impl.decoder;\n  var types \x3d com.cognitect.transit.types;\n  var eq \x3d com.cognitect.transit.eq;\n  var caching \x3d com.cognitect.transit.caching;\n  transit.MapLike;\n  transit.SetLike;\n  transit.reader \x3d function(type, opts) {\n    if (type \x3d\x3d\x3d \x22json\x22 || type \x3d\x3d\x3d \x22json-verbose\x22 || type \x3d\x3d null) {\n      type \x3d \x22json\x22;\n      var unmarshaller \x3d new reader.JSONUnmarshaller(opts);\n      return new reader.Reader(unmarshaller, opts);\n    } else {\n      throw new Error(\x22Cannot create reader of type \x22 + type);\n    }\n  };\n  transit.writer \x3d function(type, opts) {\n    if (type \x3d\x3d\x3d \x22json\x22 || type \x3d\x3d\x3d \x22json-verbose\x22 || type \x3d\x3d null) {\n      if (type \x3d\x3d\x3d \x22json-verbose\x22) {\n        if (opts \x3d\x3d null) {\n          opts \x3d {};\n        }\n        opts[\x22verbose\x22] \x3d true;\n      }\n      var marshaller \x3d new writer.JSONMarshaller(opts);\n      return new writer.Writer(marshaller, opts);\n    } else {\n      var err \x3d new Error(\x27Type must be \x22json\x22\x27);\n      err.data \x3d {type:type};\n      throw err;\n    }\n  };\n  transit.makeWriteHandler \x3d function(obj) {\n    var Handler \x3d function() {\n    };\n    Handler.prototype.tag \x3d obj[\x22tag\x22];\n    Handler.prototype.rep \x3d obj[\x22rep\x22];\n    Handler.prototype.stringRep \x3d obj[\x22stringRep\x22];\n    Handler.prototype.getVerboseHandler \x3d obj[\x22getVerboseHandler\x22];\n    return new Handler();\n  };\n  transit.makeBuilder \x3d function(obj) {\n    var Builder \x3d function() {\n    };\n    Builder.prototype.init \x3d obj[\x22init\x22];\n    Builder.prototype.add \x3d obj[\x22add\x22];\n    Builder.prototype.finalize \x3d obj[\x22finalize\x22];\n    Builder.prototype.fromArray \x3d obj[\x22fromArray\x22];\n    return new Builder();\n  };\n  transit.date \x3d types.date;\n  transit.integer \x3d types.intValue;\n  transit.isInteger \x3d types.isInteger;\n  transit.uuid \x3d types.uuid;\n  transit.isUUID \x3d types.isUUID;\n  transit.bigInt \x3d types.bigInteger;\n  transit.isBigInt \x3d types.isBigInteger;\n  transit.bigDec \x3d types.bigDecimalValue;\n  transit.isBigDec \x3d types.isBigDecimal;\n  transit.keyword \x3d types.keyword;\n  transit.isKeyword \x3d types.isKeyword;\n  transit.symbol \x3d types.symbol;\n  transit.isSymbol \x3d types.isSymbol;\n  transit.binary \x3d types.binary;\n  transit.isBinary \x3d types.isBinary;\n  transit.uri \x3d types.uri;\n  transit.isURI \x3d types.isURI;\n  transit.map \x3d types.map;\n  transit.isMap \x3d types.isMap;\n  transit.set \x3d types.set;\n  transit.isSet \x3d types.isSet;\n  transit.list \x3d types.list;\n  transit.isList \x3d types.isList;\n  transit.quoted \x3d types.quoted;\n  transit.isQuoted \x3d types.isQuoted;\n  transit.tagged \x3d types.taggedValue;\n  transit.isTaggedValue \x3d types.isTaggedValue;\n  transit.link \x3d types.link;\n  transit.isLink \x3d types.isLink;\n  transit.hash \x3d eq.hashCode;\n  transit.hashMapLike \x3d eq.hashMapLike;\n  transit.hashArrayLike \x3d eq.hashArrayLike;\n  transit.equals \x3d eq.equals;\n  transit.extendToEQ \x3d eq.extendToEQ;\n  transit.mapToObject \x3d function(m) {\n    var ret \x3d {};\n    m.forEach(function(v, k) {\n      if (typeof k !\x3d\x3d \x22string\x22) {\n        throw Error(\x22Cannot convert map with non-string keys\x22);\n      } else {\n        ret[k] \x3d v;\n      }\n    });\n    return ret;\n  };\n  transit.objectToMap \x3d function(obj) {\n    var ret \x3d transit.map();\n    var p;\n    for (p in obj) {\n      if (obj.hasOwnProperty(p)) {\n        ret.set(p, obj[p]);\n      }\n    }\n    return ret;\n  };\n  transit.decoder \x3d decoder.decoder;\n  transit.readCache \x3d caching.readCache;\n  transit.writeCache \x3d caching.writeCache;\n  transit.UUIDfromString \x3d types.UUIDfromString;\n  transit.randomUUID \x3d util.randomUUID;\n  transit.stringableKeys \x3d writer.stringableKeys;\n  if (TRANSIT_BROWSER_TARGET) {\n    goog.exportSymbol(\x22transit.reader\x22, transit.reader);\n    goog.exportSymbol(\x22transit.writer\x22, transit.writer);\n    goog.exportSymbol(\x22transit.makeBuilder\x22, transit.makeBuilder);\n    goog.exportSymbol(\x22transit.makeWriteHandler\x22, transit.makeWriteHandler);\n    goog.exportSymbol(\x22transit.date\x22, types.date);\n    goog.exportSymbol(\x22transit.integer\x22, types.intValue);\n    goog.exportSymbol(\x22transit.isInteger\x22, types.isInteger);\n    goog.exportSymbol(\x22transit.uuid\x22, types.uuid);\n    goog.exportSymbol(\x22transit.isUUID\x22, types.isUUID);\n    goog.exportSymbol(\x22transit.bigInt\x22, types.bigInteger);\n    goog.exportSymbol(\x22transit.isBigInt\x22, types.isBigInteger);\n    goog.exportSymbol(\x22transit.bigDec\x22, types.bigDecimalValue);\n    goog.exportSymbol(\x22transit.isBigDec\x22, types.isBigDecimal);\n    goog.exportSymbol(\x22transit.keyword\x22, types.keyword);\n    goog.exportSymbol(\x22transit.isKeyword\x22, types.isKeyword);\n    goog.exportSymbol(\x22transit.symbol\x22, types.symbol);\n    goog.exportSymbol(\x22transit.isSymbol\x22, types.isSymbol);\n    goog.exportSymbol(\x22transit.binary\x22, types.binary);\n    goog.exportSymbol(\x22transit.isBinary\x22, types.isBinary);\n    goog.exportSymbol(\x22transit.uri\x22, types.uri);\n    goog.exportSymbol(\x22transit.isURI\x22, types.isURI);\n    goog.exportSymbol(\x22transit.map\x22, types.map);\n    goog.exportSymbol(\x22transit.isMap\x22, types.isMap);\n    goog.exportSymbol(\x22transit.set\x22, types.set);\n    goog.exportSymbol(\x22transit.isSet\x22, types.isSet);\n    goog.exportSymbol(\x22transit.list\x22, types.list);\n    goog.exportSymbol(\x22transit.isList\x22, types.isList);\n    goog.exportSymbol(\x22transit.quoted\x22, types.quoted);\n    goog.exportSymbol(\x22transit.isQuoted\x22, types.isQuoted);\n    goog.exportSymbol(\x22transit.tagged\x22, types.taggedValue);\n    goog.exportSymbol(\x22transit.isTaggedValue\x22, types.isTaggedValue);\n    goog.exportSymbol(\x22transit.link\x22, types.link);\n    goog.exportSymbol(\x22transit.isLink\x22, types.isLink);\n    goog.exportSymbol(\x22transit.hash\x22, eq.hashCode);\n    goog.exportSymbol(\x22transit.hashMapLike\x22, eq.hashMapLike);\n    goog.exportSymbol(\x22transit.hashArrayLike\x22, eq.hashArrayLike);\n    goog.exportSymbol(\x22transit.equals\x22, eq.equals);\n    goog.exportSymbol(\x22transit.extendToEQ\x22, eq.extendToEQ);\n    goog.exportSymbol(\x22transit.mapToObject\x22, transit.mapToObject);\n    goog.exportSymbol(\x22transit.objectToMap\x22, transit.objectToMap);\n    goog.exportSymbol(\x22transit.decoder\x22, decoder.decoder);\n    goog.exportSymbol(\x22transit.UUIDfromString\x22, types.UUIDfromString);\n    goog.exportSymbol(\x22transit.randomUUID\x22, util.randomUUID);\n    goog.exportSymbol(\x22transit.stringableKeys\x22, writer.stringableKeys);\n    goog.exportSymbol(\x22transit.readCache\x22, caching.readCache);\n    goog.exportSymbol(\x22transit.writeCache\x22, caching.writeCache);\n  }\n  if (TRANSIT_NODE_TARGET) {\n    module.exports \x3d {reader:transit.reader, writer:transit.writer, makeBuilder:transit.makeBuilder, makeWriteHandler:transit.makeWriteHandler, date:types.date, integer:types.intValue, isInteger:types.isInteger, uuid:types.uuid, isUUID:types.isUUID, bigInt:types.bigInteger, isBigInt:types.isBigInteger, bigDec:types.bigDecimalValue, isBigDec:types.isBigDecimal, keyword:types.keyword, isKeyword:types.isKeyword, symbol:types.symbol, isSymbol:types.isSymbol, binary:types.binary, isBinary:types.isBinary, \n    uri:types.uri, isURI:types.isURI, map:types.map, isMap:types.isMap, set:types.set, isSet:types.isSet, list:types.list, isList:types.isList, quoted:types.quoted, isQuoted:types.isQuoted, tagged:types.taggedValue, isTaggedValue:types.isTaggedValue, link:types.link, isLink:types.isLink, hash:eq.hashCode, hashArrayLike:eq.hashArrayLike, hashMapLike:eq.hashMapLike, equals:eq.equals, extendToEQ:eq.extendToEQ, mapToObject:transit.mapToObject, objectToMap:transit.objectToMap, decoder:decoder.decoder, \n    UUIDfromString:types.UUIDfromString, randomUUID:util.randomUUID, stringableKeys:writer.stringableKeys, readCache:caching.readCache, writeCache:caching.writeCache};\n  }\n});\n");
SHADOW_ENV.evalLoad("cognitect.transit.js", true, "goog.provide(\x27cognitect.transit\x27);\ngoog.scope(function(){\n  cognitect.transit.goog$module$goog$object \x3d goog.module.get(\x27goog.object\x27);\n  cognitect.transit.goog$module$goog$math$Long \x3d goog.module.get(\x27goog.math.Long\x27);\n});\n(cljs.core.UUID.prototype.cljs$core$IEquiv$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.UUID.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this$,other){\nvar this$__$1 \x3d this;\nif((other instanceof cljs.core.UUID)){\nreturn (this$__$1.uuid \x3d\x3d\x3d other.uuid);\n} else {\nif((other instanceof com.cognitect.transit.types.UUID)){\nreturn (this$__$1.uuid \x3d\x3d\x3d other.toString());\n} else {\nreturn false;\n\n}\n}\n}));\n(cljs.core.UUID.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.UUID.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (this$,other){\nvar this$__$1 \x3d this;\nif((((other instanceof cljs.core.UUID)) || ((other instanceof com.cognitect.transit.types.UUID)))){\nreturn cljs.core.compare(this$__$1.toString(),other.toString());\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(other)].join(\x27\x27)));\n}\n}));\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IComparable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IComparable$_compare$arity$2 \x3d (function (this$,other){\nvar this$__$1 \x3d this;\nif((((other instanceof cljs.core.UUID)) || ((other instanceof com.cognitect.transit.types.UUID)))){\nreturn cljs.core.compare(this$__$1.toString(),other.toString());\n} else {\nthrow (new Error([\x22Cannot compare \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$__$1),\x22 to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(other)].join(\x27\x27)));\n}\n}));\n(cognitect.transit.goog$module$goog$math$Long.prototype.cljs$core$IEquiv$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cognitect.transit.goog$module$goog$math$Long.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this$,other){\nvar this$__$1 \x3d this;\nreturn this$__$1.equiv(other);\n}));\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IEquiv$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this$,other){\nvar this$__$1 \x3d this;\nif((other instanceof cljs.core.UUID)){\nreturn other.cljs$core$IEquiv$_equiv$arity$2(null, this$__$1);\n} else {\nreturn this$__$1.equiv(other);\n}\n}));\n\n(com.cognitect.transit.types.TaggedValue.prototype.cljs$core$IEquiv$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(com.cognitect.transit.types.TaggedValue.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this$,other){\nvar this$__$1 \x3d this;\nreturn this$__$1.equiv(other);\n}));\n(cognitect.transit.goog$module$goog$math$Long.prototype.cljs$core$IHash$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cognitect.transit.goog$module$goog$math$Long.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn com.cognitect.transit.eq.hashCode(this$__$1);\n}));\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IHash$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn cljs.core.hash(this$__$1.toString());\n}));\n\n(com.cognitect.transit.types.TaggedValue.prototype.cljs$core$IHash$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(com.cognitect.transit.types.TaggedValue.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this$){\nvar this$__$1 \x3d this;\nreturn com.cognitect.transit.eq.hashCode(this$__$1);\n}));\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IUUID$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IPrintWithWriter$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(com.cognitect.transit.types.UUID.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (uuid,writer,_){\nvar uuid__$1 \x3d this;\nreturn cljs.core._write(writer,[\x22#uuid \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(uuid__$1.toString()),\x22\\\x22\x22].join(\x27\x27));\n}));\ncognitect.transit.opts_merge \x3d (function cognitect$transit$opts_merge(a,b){\nvar seq__21791_22439 \x3d cljs.core.seq(cljs.core.js_keys(b));\nvar chunk__21792_22440 \x3d null;\nvar count__21793_22441 \x3d (0);\nvar i__21794_22442 \x3d (0);\nwhile(true){\nif((i__21794_22442 \x3c count__21793_22441)){\nvar k_22444 \x3d chunk__21792_22440.cljs$core$IIndexed$_nth$arity$2(null, i__21794_22442);\nvar v_22445 \x3d cognitect.transit.goog$module$goog$object.get(b,k_22444);\ncognitect.transit.goog$module$goog$object.set(a,k_22444,v_22445);\n\n\nvar G__22447 \x3d seq__21791_22439;\nvar G__22448 \x3d chunk__21792_22440;\nvar G__22449 \x3d count__21793_22441;\nvar G__22450 \x3d (i__21794_22442 + (1));\nseq__21791_22439 \x3d G__22447;\nchunk__21792_22440 \x3d G__22448;\ncount__21793_22441 \x3d G__22449;\ni__21794_22442 \x3d G__22450;\ncontinue;\n} else {\nvar temp__5804__auto___22451 \x3d cljs.core.seq(seq__21791_22439);\nif(temp__5804__auto___22451){\nvar seq__21791_22452__$1 \x3d temp__5804__auto___22451;\nif(cljs.core.chunked_seq_QMARK_(seq__21791_22452__$1)){\nvar c__5525__auto___22454 \x3d cljs.core.chunk_first(seq__21791_22452__$1);\nvar G__22455 \x3d cljs.core.chunk_rest(seq__21791_22452__$1);\nvar G__22456 \x3d c__5525__auto___22454;\nvar G__22457 \x3d cljs.core.count(c__5525__auto___22454);\nvar G__22458 \x3d (0);\nseq__21791_22439 \x3d G__22455;\nchunk__21792_22440 \x3d G__22456;\ncount__21793_22441 \x3d G__22457;\ni__21794_22442 \x3d G__22458;\ncontinue;\n} else {\nvar k_22459 \x3d cljs.core.first(seq__21791_22452__$1);\nvar v_22460 \x3d cognitect.transit.goog$module$goog$object.get(b,k_22459);\ncognitect.transit.goog$module$goog$object.set(a,k_22459,v_22460);\n\n\nvar G__22461 \x3d cljs.core.next(seq__21791_22452__$1);\nvar G__22462 \x3d null;\nvar G__22463 \x3d (0);\nvar G__22464 \x3d (0);\nseq__21791_22439 \x3d G__22461;\nchunk__21792_22440 \x3d G__22462;\ncount__21793_22441 \x3d G__22463;\ni__21794_22442 \x3d G__22464;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn a;\n});\n\n/**\n* @constructor\n*/\ncognitect.transit.MapBuilder \x3d (function (){\n});\n(cognitect.transit.MapBuilder.prototype.init \x3d (function (node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY);\n}));\n\n(cognitect.transit.MapBuilder.prototype.add \x3d (function (m,k,v,node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(m,k,v);\n}));\n\n(cognitect.transit.MapBuilder.prototype.finalize \x3d (function (m,node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn cljs.core.persistent_BANG_(m);\n}));\n\n(cognitect.transit.MapBuilder.prototype.fromArray \x3d (function (arr,node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (cljs.core.PersistentArrayMap.fromArray.cljs$core$IFn$_invoke$arity$3 ? cljs.core.PersistentArrayMap.fromArray.cljs$core$IFn$_invoke$arity$3(arr,true,true) : cljs.core.PersistentArrayMap.fromArray.call(null, arr,true,true));\n}));\n\n(cognitect.transit.MapBuilder.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.MapBuilder.cljs$lang$type \x3d true);\n\n(cognitect.transit.MapBuilder.cljs$lang$ctorStr \x3d \x22cognitect.transit/MapBuilder\x22);\n\n(cognitect.transit.MapBuilder.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/MapBuilder\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/MapBuilder.\n */\ncognitect.transit.__GT_MapBuilder \x3d (function cognitect$transit$__GT_MapBuilder(){\nreturn (new cognitect.transit.MapBuilder());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.VectorBuilder \x3d (function (){\n});\n(cognitect.transit.VectorBuilder.prototype.init \x3d (function (node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn cljs.core.transient$(cljs.core.PersistentVector.EMPTY);\n}));\n\n(cognitect.transit.VectorBuilder.prototype.add \x3d (function (v,x,node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(v,x);\n}));\n\n(cognitect.transit.VectorBuilder.prototype.finalize \x3d (function (v,node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn cljs.core.persistent_BANG_(v);\n}));\n\n(cognitect.transit.VectorBuilder.prototype.fromArray \x3d (function (arr,node){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (cljs.core.PersistentVector.fromArray.cljs$core$IFn$_invoke$arity$2 ? cljs.core.PersistentVector.fromArray.cljs$core$IFn$_invoke$arity$2(arr,true) : cljs.core.PersistentVector.fromArray.call(null, arr,true));\n}));\n\n(cognitect.transit.VectorBuilder.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.VectorBuilder.cljs$lang$type \x3d true);\n\n(cognitect.transit.VectorBuilder.cljs$lang$ctorStr \x3d \x22cognitect.transit/VectorBuilder\x22);\n\n(cognitect.transit.VectorBuilder.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/VectorBuilder\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/VectorBuilder.\n */\ncognitect.transit.__GT_VectorBuilder \x3d (function cognitect$transit$__GT_VectorBuilder(){\nreturn (new cognitect.transit.VectorBuilder());\n});\n\n/**\n * Return a transit reader. type may be either :json or :json-verbose.\n * opts may be a map optionally containing a :handlers entry. The value\n * of :handlers should be map from string tag to a decoder function of one\n * argument which returns the in-memory representation of the semantic transit\n * value. If a :default handler is provided, it will be used when no matching\n * read handler can be found.\n */\ncognitect.transit.reader \x3d (function cognitect$transit$reader(var_args){\nvar G__21862 \x3d arguments.length;\nswitch (G__21862) {\ncase 1:\nreturn cognitect.transit.reader.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cognitect.transit.reader.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cognitect.transit.reader.cljs$core$IFn$_invoke$arity$1 \x3d (function (type){\nreturn cognitect.transit.reader.cljs$core$IFn$_invoke$arity$2(type,null);\n}));\n\n(cognitect.transit.reader.cljs$core$IFn$_invoke$arity$2 \x3d (function (type,opts){\nreturn com.cognitect.transit.reader(cljs.core.name(type),cognitect.transit.opts_merge(({\x22handlers\x22: cljs.core.clj__GT_js(cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 6, [\x22$\x22,(function (v){\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(v);\n}),\x22:\x22,(function (v){\nreturn cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(v);\n}),\x22set\x22,(function (v){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentHashSet.EMPTY,v);\n}),\x22list\x22,(function (v){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.List.EMPTY,v.reverse());\n}),\x22cmap\x22,(function (v){\nvar i \x3d (0);\nvar ret \x3d cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY);\nwhile(true){\nif((i \x3c v.length)){\nvar G__22490 \x3d (i + (2));\nvar G__22491 \x3d cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(ret,(v[i]),(v[(i + (1))]));\ni \x3d G__22490;\nret \x3d G__22491;\ncontinue;\n} else {\nreturn cljs.core.persistent_BANG_(ret);\n}\nbreak;\n}\n}),\x22with-meta\x22,(function (v){\nreturn cljs.core.with_meta((v[(0)]),(v[(1)]));\n})], null),cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781).cljs$core$IFn$_invoke$arity$1(opts),new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328))], 0))), \x22defaultHandler\x22: new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781).cljs$core$IFn$_invoke$arity$1(opts)), \x22mapBuilder\x22: (new cognitect.transit.MapBuilder()), \x22arrayBuilder\x22: (new cognitect.transit.VectorBuilder()), \x22preferStrings\x22: false, \x22preferBuffers\x22: false}),cljs.core.clj__GT_js(clojure.set.rename_keys(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(opts,new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781)),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22array-builder\x22,\x22array-builder\x22,1275998041),new cljs.core.Keyword(null,\x22arrayBuilder\x22,\x22arrayBuilder\x22,1446317421),new cljs.core.Keyword(null,\x22map-builder\x22,\x22map-builder\x22,-1843343288),new cljs.core.Keyword(null,\x22mapBuilder\x22,\x22mapBuilder\x22,-278083754),new cljs.core.Keyword(null,\x22prefer-strings\x22,\x22prefer-strings\x22,1254507185),new cljs.core.Keyword(null,\x22preferStrings\x22,\x22preferStrings\x22,-1532249482),new cljs.core.Keyword(null,\x22prefer-buffers\x22,\x22prefer-buffers\x22,377042081),new cljs.core.Keyword(null,\x22preferBuffers\x22,\x22preferBuffers\x22,1843176451)], null)))));\n}));\n\n(cognitect.transit.reader.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Read a transit encoded string into ClojureScript values given a\n * transit reader.\n */\ncognitect.transit.read \x3d (function cognitect$transit$read(r,str){\nreturn r.read(str);\n});\n\n/**\n* @constructor\n*/\ncognitect.transit.KeywordHandler \x3d (function (){\n});\n(cognitect.transit.KeywordHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22:\x22;\n}));\n\n(cognitect.transit.KeywordHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn v.fqn;\n}));\n\n(cognitect.transit.KeywordHandler.prototype.stringRep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn v.fqn;\n}));\n\n(cognitect.transit.KeywordHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.KeywordHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.KeywordHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/KeywordHandler\x22);\n\n(cognitect.transit.KeywordHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/KeywordHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/KeywordHandler.\n */\ncognitect.transit.__GT_KeywordHandler \x3d (function cognitect$transit$__GT_KeywordHandler(){\nreturn (new cognitect.transit.KeywordHandler());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.SymbolHandler \x3d (function (){\n});\n(cognitect.transit.SymbolHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22$\x22;\n}));\n\n(cognitect.transit.SymbolHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn v.str;\n}));\n\n(cognitect.transit.SymbolHandler.prototype.stringRep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn v.str;\n}));\n\n(cognitect.transit.SymbolHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.SymbolHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.SymbolHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/SymbolHandler\x22);\n\n(cognitect.transit.SymbolHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/SymbolHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/SymbolHandler.\n */\ncognitect.transit.__GT_SymbolHandler \x3d (function cognitect$transit$__GT_SymbolHandler(){\nreturn (new cognitect.transit.SymbolHandler());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.ListHandler \x3d (function (){\n});\n(cognitect.transit.ListHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22list\x22;\n}));\n\n(cognitect.transit.ListHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d [];\nvar seq__21972_22537 \x3d cljs.core.seq(v);\nvar chunk__21973_22538 \x3d null;\nvar count__21974_22539 \x3d (0);\nvar i__21975_22540 \x3d (0);\nwhile(true){\nif((i__21975_22540 \x3c count__21974_22539)){\nvar x_22542 \x3d chunk__21973_22538.cljs$core$IIndexed$_nth$arity$2(null, i__21975_22540);\nret.push(x_22542);\n\n\nvar G__22546 \x3d seq__21972_22537;\nvar G__22547 \x3d chunk__21973_22538;\nvar G__22548 \x3d count__21974_22539;\nvar G__22549 \x3d (i__21975_22540 + (1));\nseq__21972_22537 \x3d G__22546;\nchunk__21973_22538 \x3d G__22547;\ncount__21974_22539 \x3d G__22548;\ni__21975_22540 \x3d G__22549;\ncontinue;\n} else {\nvar temp__5804__auto___22550 \x3d cljs.core.seq(seq__21972_22537);\nif(temp__5804__auto___22550){\nvar seq__21972_22551__$1 \x3d temp__5804__auto___22550;\nif(cljs.core.chunked_seq_QMARK_(seq__21972_22551__$1)){\nvar c__5525__auto___22552 \x3d cljs.core.chunk_first(seq__21972_22551__$1);\nvar G__22553 \x3d cljs.core.chunk_rest(seq__21972_22551__$1);\nvar G__22554 \x3d c__5525__auto___22552;\nvar G__22555 \x3d cljs.core.count(c__5525__auto___22552);\nvar G__22556 \x3d (0);\nseq__21972_22537 \x3d G__22553;\nchunk__21973_22538 \x3d G__22554;\ncount__21974_22539 \x3d G__22555;\ni__21975_22540 \x3d G__22556;\ncontinue;\n} else {\nvar x_22557 \x3d cljs.core.first(seq__21972_22551__$1);\nret.push(x_22557);\n\n\nvar G__22558 \x3d cljs.core.next(seq__21972_22551__$1);\nvar G__22559 \x3d null;\nvar G__22560 \x3d (0);\nvar G__22561 \x3d (0);\nseq__21972_22537 \x3d G__22558;\nchunk__21973_22538 \x3d G__22559;\ncount__21974_22539 \x3d G__22560;\ni__21975_22540 \x3d G__22561;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn com.cognitect.transit.tagged(\x22array\x22,ret);\n}));\n\n(cognitect.transit.ListHandler.prototype.stringRep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn null;\n}));\n\n(cognitect.transit.ListHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.ListHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.ListHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/ListHandler\x22);\n\n(cognitect.transit.ListHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/ListHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/ListHandler.\n */\ncognitect.transit.__GT_ListHandler \x3d (function cognitect$transit$__GT_ListHandler(){\nreturn (new cognitect.transit.ListHandler());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.MapHandler \x3d (function (){\n});\n(cognitect.transit.MapHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22map\x22;\n}));\n\n(cognitect.transit.MapHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn v;\n}));\n\n(cognitect.transit.MapHandler.prototype.stringRep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn null;\n}));\n\n(cognitect.transit.MapHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.MapHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.MapHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/MapHandler\x22);\n\n(cognitect.transit.MapHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/MapHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/MapHandler.\n */\ncognitect.transit.__GT_MapHandler \x3d (function cognitect$transit$__GT_MapHandler(){\nreturn (new cognitect.transit.MapHandler());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.SetHandler \x3d (function (){\n});\n(cognitect.transit.SetHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22set\x22;\n}));\n\n(cognitect.transit.SetHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d [];\nvar seq__22041_22579 \x3d cljs.core.seq(v);\nvar chunk__22042_22580 \x3d null;\nvar count__22043_22581 \x3d (0);\nvar i__22044_22582 \x3d (0);\nwhile(true){\nif((i__22044_22582 \x3c count__22043_22581)){\nvar x_22583 \x3d chunk__22042_22580.cljs$core$IIndexed$_nth$arity$2(null, i__22044_22582);\nret.push(x_22583);\n\n\nvar G__22584 \x3d seq__22041_22579;\nvar G__22585 \x3d chunk__22042_22580;\nvar G__22586 \x3d count__22043_22581;\nvar G__22587 \x3d (i__22044_22582 + (1));\nseq__22041_22579 \x3d G__22584;\nchunk__22042_22580 \x3d G__22585;\ncount__22043_22581 \x3d G__22586;\ni__22044_22582 \x3d G__22587;\ncontinue;\n} else {\nvar temp__5804__auto___22588 \x3d cljs.core.seq(seq__22041_22579);\nif(temp__5804__auto___22588){\nvar seq__22041_22589__$1 \x3d temp__5804__auto___22588;\nif(cljs.core.chunked_seq_QMARK_(seq__22041_22589__$1)){\nvar c__5525__auto___22593 \x3d cljs.core.chunk_first(seq__22041_22589__$1);\nvar G__22594 \x3d cljs.core.chunk_rest(seq__22041_22589__$1);\nvar G__22595 \x3d c__5525__auto___22593;\nvar G__22596 \x3d cljs.core.count(c__5525__auto___22593);\nvar G__22597 \x3d (0);\nseq__22041_22579 \x3d G__22594;\nchunk__22042_22580 \x3d G__22595;\ncount__22043_22581 \x3d G__22596;\ni__22044_22582 \x3d G__22597;\ncontinue;\n} else {\nvar x_22598 \x3d cljs.core.first(seq__22041_22589__$1);\nret.push(x_22598);\n\n\nvar G__22599 \x3d cljs.core.next(seq__22041_22589__$1);\nvar G__22600 \x3d null;\nvar G__22601 \x3d (0);\nvar G__22602 \x3d (0);\nseq__22041_22579 \x3d G__22599;\nchunk__22042_22580 \x3d G__22600;\ncount__22043_22581 \x3d G__22601;\ni__22044_22582 \x3d G__22602;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn com.cognitect.transit.tagged(\x22array\x22,ret);\n}));\n\n(cognitect.transit.SetHandler.prototype.stringRep \x3d (function (){\nvar self__ \x3d this;\nvar v \x3d this;\nreturn null;\n}));\n\n(cognitect.transit.SetHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.SetHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.SetHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/SetHandler\x22);\n\n(cognitect.transit.SetHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/SetHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/SetHandler.\n */\ncognitect.transit.__GT_SetHandler \x3d (function cognitect$transit$__GT_SetHandler(){\nreturn (new cognitect.transit.SetHandler());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.VectorHandler \x3d (function (){\n});\n(cognitect.transit.VectorHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22array\x22;\n}));\n\n(cognitect.transit.VectorHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nvar ret \x3d [];\nvar seq__22118_22610 \x3d cljs.core.seq(v);\nvar chunk__22119_22611 \x3d null;\nvar count__22120_22612 \x3d (0);\nvar i__22121_22613 \x3d (0);\nwhile(true){\nif((i__22121_22613 \x3c count__22120_22612)){\nvar x_22615 \x3d chunk__22119_22611.cljs$core$IIndexed$_nth$arity$2(null, i__22121_22613);\nret.push(x_22615);\n\n\nvar G__22616 \x3d seq__22118_22610;\nvar G__22617 \x3d chunk__22119_22611;\nvar G__22618 \x3d count__22120_22612;\nvar G__22619 \x3d (i__22121_22613 + (1));\nseq__22118_22610 \x3d G__22616;\nchunk__22119_22611 \x3d G__22617;\ncount__22120_22612 \x3d G__22618;\ni__22121_22613 \x3d G__22619;\ncontinue;\n} else {\nvar temp__5804__auto___22620 \x3d cljs.core.seq(seq__22118_22610);\nif(temp__5804__auto___22620){\nvar seq__22118_22622__$1 \x3d temp__5804__auto___22620;\nif(cljs.core.chunked_seq_QMARK_(seq__22118_22622__$1)){\nvar c__5525__auto___22623 \x3d cljs.core.chunk_first(seq__22118_22622__$1);\nvar G__22624 \x3d cljs.core.chunk_rest(seq__22118_22622__$1);\nvar G__22625 \x3d c__5525__auto___22623;\nvar G__22626 \x3d cljs.core.count(c__5525__auto___22623);\nvar G__22627 \x3d (0);\nseq__22118_22610 \x3d G__22624;\nchunk__22119_22611 \x3d G__22625;\ncount__22120_22612 \x3d G__22626;\ni__22121_22613 \x3d G__22627;\ncontinue;\n} else {\nvar x_22628 \x3d cljs.core.first(seq__22118_22622__$1);\nret.push(x_22628);\n\n\nvar G__22630 \x3d cljs.core.next(seq__22118_22622__$1);\nvar G__22631 \x3d null;\nvar G__22632 \x3d (0);\nvar G__22633 \x3d (0);\nseq__22118_22610 \x3d G__22630;\nchunk__22119_22611 \x3d G__22631;\ncount__22120_22612 \x3d G__22632;\ni__22121_22613 \x3d G__22633;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn ret;\n}));\n\n(cognitect.transit.VectorHandler.prototype.stringRep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn null;\n}));\n\n(cognitect.transit.VectorHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.VectorHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.VectorHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/VectorHandler\x22);\n\n(cognitect.transit.VectorHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/VectorHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/VectorHandler.\n */\ncognitect.transit.__GT_VectorHandler \x3d (function cognitect$transit$__GT_VectorHandler(){\nreturn (new cognitect.transit.VectorHandler());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.UUIDHandler \x3d (function (){\n});\n(cognitect.transit.UUIDHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22u\x22;\n}));\n\n(cognitect.transit.UUIDHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn v.uuid;\n}));\n\n(cognitect.transit.UUIDHandler.prototype.stringRep \x3d (function (v){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn this$.rep(v);\n}));\n\n(cognitect.transit.UUIDHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.UUIDHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.UUIDHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/UUIDHandler\x22);\n\n(cognitect.transit.UUIDHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/UUIDHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/UUIDHandler.\n */\ncognitect.transit.__GT_UUIDHandler \x3d (function cognitect$transit$__GT_UUIDHandler(){\nreturn (new cognitect.transit.UUIDHandler());\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.WithMeta \x3d (function (value,meta){\nthis.value \x3d value;\nthis.meta \x3d meta;\n});\n\n(cognitect.transit.WithMeta.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22value\x22,\x22value\x22,1946509744,null),new cljs.core.Symbol(null,\x22meta\x22,\x22meta\x22,-1154898805,null)], null);\n}));\n\n(cognitect.transit.WithMeta.cljs$lang$type \x3d true);\n\n(cognitect.transit.WithMeta.cljs$lang$ctorStr \x3d \x22cognitect.transit/WithMeta\x22);\n\n(cognitect.transit.WithMeta.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/WithMeta\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/WithMeta.\n */\ncognitect.transit.__GT_WithMeta \x3d (function cognitect$transit$__GT_WithMeta(value,meta){\nreturn (new cognitect.transit.WithMeta(value,meta));\n});\n\n\n/**\n* @constructor\n*/\ncognitect.transit.WithMetaHandler \x3d (function (){\n});\n(cognitect.transit.WithMetaHandler.prototype.tag \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn \x22with-meta\x22;\n}));\n\n(cognitect.transit.WithMetaHandler.prototype.rep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn com.cognitect.transit.tagged(\x22array\x22,[v.value,v.meta]);\n}));\n\n(cognitect.transit.WithMetaHandler.prototype.stringRep \x3d (function (v){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn null;\n}));\n\n(cognitect.transit.WithMetaHandler.getBasis \x3d (function (){\nreturn cljs.core.PersistentVector.EMPTY;\n}));\n\n(cognitect.transit.WithMetaHandler.cljs$lang$type \x3d true);\n\n(cognitect.transit.WithMetaHandler.cljs$lang$ctorStr \x3d \x22cognitect.transit/WithMetaHandler\x22);\n\n(cognitect.transit.WithMetaHandler.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/WithMetaHandler\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/WithMetaHandler.\n */\ncognitect.transit.__GT_WithMetaHandler \x3d (function cognitect$transit$__GT_WithMetaHandler(){\nreturn (new cognitect.transit.WithMetaHandler());\n});\n\n/**\n * Return a transit writer. type maybe either :json or :json-verbose.\n *   opts is a map with the following optional keys:\n * \n *  :handlers  - a map of type constructors to handler instances. Can optionally\n *               provide a :default write handler which will be used if no\n *               matching handler can be found.\n *  :transform - a function of one argument returning a transformed value. Will\n *               be invoked on a value before it is written.\n */\ncognitect.transit.writer \x3d (function cognitect$transit$writer(var_args){\nvar G__22223 \x3d arguments.length;\nswitch (G__22223) {\ncase 1:\nreturn cognitect.transit.writer.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cognitect.transit.writer.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cognitect.transit.writer.cljs$core$IFn$_invoke$arity$1 \x3d (function (type){\nreturn cognitect.transit.writer.cljs$core$IFn$_invoke$arity$2(type,null);\n}));\n\n(cognitect.transit.writer.cljs$core$IFn$_invoke$arity$2 \x3d (function (type,opts){\nvar keyword_handler \x3d (new cognitect.transit.KeywordHandler());\nvar symbol_handler \x3d (new cognitect.transit.SymbolHandler());\nvar list_handler \x3d (new cognitect.transit.ListHandler());\nvar map_handler \x3d (new cognitect.transit.MapHandler());\nvar set_handler \x3d (new cognitect.transit.SetHandler());\nvar vector_handler \x3d (new cognitect.transit.VectorHandler());\nvar uuid_handler \x3d (new cognitect.transit.UUIDHandler());\nvar meta_handler \x3d (new cognitect.transit.WithMetaHandler());\nvar handlers \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.PersistentHashMap.fromArrays([cljs.core.PersistentHashMap,cljs.core.Cons,cljs.core.PersistentArrayMap,cljs.core.NodeSeq,cljs.core.PersistentQueue,cljs.core.IndexedSeq,cljs.core.Keyword,cljs.core.BlackNode,cljs.core.EmptyList,cljs.core.LazySeq,cljs.core.Subvec,cljs.core.PersistentQueueSeq,cljs.core.ArrayNodeSeq,cljs.core.ValSeq,cognitect.transit.WithMeta,cljs.core.PersistentArrayMapSeq,cljs.core.PersistentVector,cljs.core.List,cljs.core.RSeq,cljs.core.PersistentHashSet,cljs.core.PersistentTreeMap,cljs.core.KeySeq,cljs.core.ChunkedSeq,cljs.core.PersistentTreeSet,cljs.core.ChunkedCons,cljs.core.Symbol,cljs.core.UUID,cljs.core.Range,cljs.core.PersistentTreeMapSeq,cljs.core.RedNode],[map_handler,list_handler,map_handler,list_handler,list_handler,list_handler,keyword_handler,vector_handler,list_handler,list_handler,vector_handler,list_handler,list_handler,list_handler,meta_handler,list_handler,vector_handler,list_handler,list_handler,set_handler,map_handler,list_handler,list_handler,set_handler,list_handler,symbol_handler,uuid_handler,list_handler,list_handler,vector_handler]),(((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.Eduction !\x3d\x3d \x27undefined\x27))?cljs.core.PersistentArrayMap.createAsIfByAssoc([cljs.core.Eduction,list_handler]):null),(((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.Repeat !\x3d\x3d \x27undefined\x27))?cljs.core.PersistentArrayMap.createAsIfByAssoc([cljs.core.Repeat,list_handler]):null),(((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.core.MapEntry !\x3d\x3d \x27undefined\x27))?cljs.core.PersistentArrayMap.createAsIfByAssoc([cljs.core.MapEntry,vector_handler]):null),new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781).cljs$core$IFn$_invoke$arity$1(opts)], 0));\nreturn com.cognitect.transit.writer(cljs.core.name(type),cognitect.transit.opts_merge(({\x22objectBuilder\x22: (function (m,kfn,vfn){\nreturn cljs.core.reduce_kv((function (obj,k,v){\nvar G__22262 \x3d obj;\nG__22262.push((kfn.cljs$core$IFn$_invoke$arity$1 ? kfn.cljs$core$IFn$_invoke$arity$1(k) : kfn.call(null, k)),(vfn.cljs$core$IFn$_invoke$arity$1 ? vfn.cljs$core$IFn$_invoke$arity$1(v) : vfn.call(null, v)));\n\nreturn G__22262;\n}),[\x22^ \x22],m);\n}), \x22handlers\x22: (function (){var x22266 \x3d cljs.core.clone(handlers);\n(x22266.forEach \x3d (function (f){\nvar coll \x3d this;\nvar seq__22272 \x3d cljs.core.seq(coll);\nvar chunk__22273 \x3d null;\nvar count__22274 \x3d (0);\nvar i__22275 \x3d (0);\nwhile(true){\nif((i__22275 \x3c count__22274)){\nvar vec__22298 \x3d chunk__22273.cljs$core$IIndexed$_nth$arity$2(null, i__22275);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22298,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22298,(1),null);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),k)){\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,\x22default\x22) : f.call(null, v,\x22default\x22));\n} else {\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n}\n\n\nvar G__22699 \x3d seq__22272;\nvar G__22700 \x3d chunk__22273;\nvar G__22701 \x3d count__22274;\nvar G__22702 \x3d (i__22275 + (1));\nseq__22272 \x3d G__22699;\nchunk__22273 \x3d G__22700;\ncount__22274 \x3d G__22701;\ni__22275 \x3d G__22702;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__22272);\nif(temp__5804__auto__){\nvar seq__22272__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__22272__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__22272__$1);\nvar G__22703 \x3d cljs.core.chunk_rest(seq__22272__$1);\nvar G__22704 \x3d c__5525__auto__;\nvar G__22705 \x3d cljs.core.count(c__5525__auto__);\nvar G__22706 \x3d (0);\nseq__22272 \x3d G__22703;\nchunk__22273 \x3d G__22704;\ncount__22274 \x3d G__22705;\ni__22275 \x3d G__22706;\ncontinue;\n} else {\nvar vec__22303 \x3d cljs.core.first(seq__22272__$1);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22303,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22303,(1),null);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),k)){\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,\x22default\x22) : f.call(null, v,\x22default\x22));\n} else {\n(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null, v,k));\n}\n\n\nvar G__22715 \x3d cljs.core.next(seq__22272__$1);\nvar G__22716 \x3d null;\nvar G__22717 \x3d (0);\nvar G__22718 \x3d (0);\nseq__22272 \x3d G__22715;\nchunk__22273 \x3d G__22716;\ncount__22274 \x3d G__22717;\ni__22275 \x3d G__22718;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\nreturn x22266;\n})(), \x22unpack\x22: (function (x){\nif((x instanceof cljs.core.PersistentArrayMap)){\nreturn x.arr;\n} else {\nreturn false;\n}\n})}),cljs.core.clj__GT_js(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(opts,new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781)))));\n}));\n\n(cognitect.transit.writer.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Encode an object into a transit string given a transit writer.\n */\ncognitect.transit.write \x3d (function cognitect$transit$write(w,o){\nreturn w.write(o);\n});\n/**\n * Construct a read handler. Implemented as identity, exists primarily\n * for API compatiblity with transit-clj\n */\ncognitect.transit.read_handler \x3d (function cognitect$transit$read_handler(from_rep){\nreturn from_rep;\n});\ncognitect.transit.fn_or_val \x3d (function cognitect$transit$fn_or_val(f){\nif(cljs.core.fn_QMARK_(f)){\nreturn f;\n} else {\nreturn cljs.core.constantly(f);\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncognitect.transit.t_cognitect$transit22352 \x3d (function (tag_fn,rep_fn,str_rep_fn,verbose_handler_fn,meta22353){\nthis.tag_fn \x3d tag_fn;\nthis.rep_fn \x3d rep_fn;\nthis.str_rep_fn \x3d str_rep_fn;\nthis.verbose_handler_fn \x3d verbose_handler_fn;\nthis.meta22353 \x3d meta22353;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cognitect.transit.t_cognitect$transit22352.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_22354,meta22353__$1){\nvar self__ \x3d this;\nvar _22354__$1 \x3d this;\nreturn (new cognitect.transit.t_cognitect$transit22352(self__.tag_fn,self__.rep_fn,self__.str_rep_fn,self__.verbose_handler_fn,meta22353__$1));\n}));\n\n(cognitect.transit.t_cognitect$transit22352.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_22354){\nvar self__ \x3d this;\nvar _22354__$1 \x3d this;\nreturn self__.meta22353;\n}));\n\n(cognitect.transit.t_cognitect$transit22352.prototype.tag \x3d (function (o){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.tag_fn.cljs$core$IFn$_invoke$arity$1 ? self__.tag_fn.cljs$core$IFn$_invoke$arity$1(o) : self__.tag_fn.call(null, o));\n}));\n\n(cognitect.transit.t_cognitect$transit22352.prototype.rep \x3d (function (o){\nvar self__ \x3d this;\nvar _ \x3d this;\nreturn (self__.rep_fn.cljs$core$IFn$_invoke$arity$1 ? self__.rep_fn.cljs$core$IFn$_invoke$arity$1(o) : self__.rep_fn.call(null, o));\n}));\n\n(cognitect.transit.t_cognitect$transit22352.prototype.stringRep \x3d (function (o){\nvar self__ \x3d this;\nvar _ \x3d this;\nif(cljs.core.truth_(self__.str_rep_fn)){\nreturn (self__.str_rep_fn.cljs$core$IFn$_invoke$arity$1 ? self__.str_rep_fn.cljs$core$IFn$_invoke$arity$1(o) : self__.str_rep_fn.call(null, o));\n} else {\nreturn null;\n}\n}));\n\n(cognitect.transit.t_cognitect$transit22352.prototype.getVerboseHandler \x3d (function (){\nvar self__ \x3d this;\nvar _ \x3d this;\nif(cljs.core.truth_(self__.verbose_handler_fn)){\nreturn (self__.verbose_handler_fn.cljs$core$IFn$_invoke$arity$0 ? self__.verbose_handler_fn.cljs$core$IFn$_invoke$arity$0() : self__.verbose_handler_fn.call(null, ));\n} else {\nreturn null;\n}\n}));\n\n(cognitect.transit.t_cognitect$transit22352.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22tag-fn\x22,\x22tag-fn\x22,242055482,null),new cljs.core.Symbol(null,\x22rep-fn\x22,\x22rep-fn\x22,-1724891035,null),new cljs.core.Symbol(null,\x22str-rep-fn\x22,\x22str-rep-fn\x22,-1179615016,null),new cljs.core.Symbol(null,\x22verbose-handler-fn\x22,\x22verbose-handler-fn\x22,547340594,null),new cljs.core.Symbol(null,\x22meta22353\x22,\x22meta22353\x22,1587281312,null)], null);\n}));\n\n(cognitect.transit.t_cognitect$transit22352.cljs$lang$type \x3d true);\n\n(cognitect.transit.t_cognitect$transit22352.cljs$lang$ctorStr \x3d \x22cognitect.transit/t_cognitect$transit22352\x22);\n\n(cognitect.transit.t_cognitect$transit22352.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cognitect.transit/t_cognitect$transit22352\x22);\n}));\n\n/**\n * Positional factory function for cognitect.transit/t_cognitect$transit22352.\n */\ncognitect.transit.__GT_t_cognitect$transit22352 \x3d (function cognitect$transit$__GT_t_cognitect$transit22352(tag_fn,rep_fn,str_rep_fn,verbose_handler_fn,meta22353){\nreturn (new cognitect.transit.t_cognitect$transit22352(tag_fn,rep_fn,str_rep_fn,verbose_handler_fn,meta22353));\n});\n\n\n/**\n * Creates a transit write handler whose tag, rep,\n * stringRep, and verboseWriteHandler methods\n * invoke the provided fns.\n */\ncognitect.transit.write_handler \x3d (function cognitect$transit$write_handler(var_args){\nvar G__22327 \x3d arguments.length;\nswitch (G__22327) {\ncase 2:\nreturn cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$2 \x3d (function (tag_fn,rep_fn){\nreturn cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$4(tag_fn,rep_fn,null,null);\n}));\n\n(cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$3 \x3d (function (tag_fn,rep_fn,str_rep_fn){\nreturn cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$4(tag_fn,rep_fn,str_rep_fn,null);\n}));\n\n(cognitect.transit.write_handler.cljs$core$IFn$_invoke$arity$4 \x3d (function (tag_fn,rep_fn,str_rep_fn,verbose_handler_fn){\nvar tag_fn__$1 \x3d cognitect.transit.fn_or_val(tag_fn);\nvar rep_fn__$1 \x3d cognitect.transit.fn_or_val(rep_fn);\nvar str_rep_fn__$1 \x3d cognitect.transit.fn_or_val(str_rep_fn);\nvar verbose_handler_fn__$1 \x3d cognitect.transit.fn_or_val(verbose_handler_fn);\nreturn (new cognitect.transit.t_cognitect$transit22352(tag_fn__$1,rep_fn__$1,str_rep_fn__$1,verbose_handler_fn__$1,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(cognitect.transit.write_handler.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Construct a tagged value. tag must be a string and rep can\n * be any transit encodeable value.\n */\ncognitect.transit.tagged_value \x3d (function cognitect$transit$tagged_value(tag,rep){\nreturn com.cognitect.transit.types.taggedValue(tag,rep);\n});\n/**\n * Returns true if x is a transit tagged value, false otherwise.\n */\ncognitect.transit.tagged_value_QMARK_ \x3d (function cognitect$transit$tagged_value_QMARK_(x){\nreturn com.cognitect.transit.types.isTaggedValue(x);\n});\n/**\n * Construct a transit integer value. Returns JavaScript number if\n *   in the 53bit integer range, a goog.math.Long instance if above. s\n *   may be a string or a JavaScript number.\n */\ncognitect.transit.integer \x3d (function cognitect$transit$integer(s){\nreturn com.cognitect.transit.types.intValue(s);\n});\n/**\n * Returns true if x is an integer value between the 53bit and 64bit\n *   range, false otherwise.\n */\ncognitect.transit.integer_QMARK_ \x3d (function cognitect$transit$integer_QMARK_(x){\nreturn com.cognitect.transit.types.isInteger(x);\n});\n/**\n * Construct a big integer from a string.\n */\ncognitect.transit.bigint \x3d (function cognitect$transit$bigint(s){\nreturn com.cognitect.transit.types.bigInteger(s);\n});\n/**\n * Returns true if x is a transit big integer value, false otherwise.\n */\ncognitect.transit.bigint_QMARK_ \x3d (function cognitect$transit$bigint_QMARK_(x){\nreturn com.cognitect.transit.types.isBigInteger(x);\n});\n/**\n * Construct a big decimal from a string.\n */\ncognitect.transit.bigdec \x3d (function cognitect$transit$bigdec(s){\nreturn com.cognitect.transit.types.bigDecimalValue(s);\n});\n/**\n * Returns true if x is a transit big decimal value, false otherwise.\n */\ncognitect.transit.bigdec_QMARK_ \x3d (function cognitect$transit$bigdec_QMARK_(x){\nreturn com.cognitect.transit.types.isBigDecimal(x);\n});\n/**\n * Construct a URI from a string.\n */\ncognitect.transit.uri \x3d (function cognitect$transit$uri(s){\nreturn com.cognitect.transit.types.uri(s);\n});\n/**\n * Returns true if x is a transit URI value, false otherwise.\n */\ncognitect.transit.uri_QMARK_ \x3d (function cognitect$transit$uri_QMARK_(x){\nreturn com.cognitect.transit.types.isURI(x);\n});\n/**\n * Construct a UUID from a string.\n */\ncognitect.transit.uuid \x3d (function cognitect$transit$uuid(s){\nreturn com.cognitect.transit.types.uuid(s);\n});\n/**\n * Returns true if x is a transit UUID value, false otherwise.\n */\ncognitect.transit.uuid_QMARK_ \x3d (function cognitect$transit$uuid_QMARK_(x){\nvar or__5002__auto__ \x3d com.cognitect.transit.types.isUUID(x);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (x instanceof cljs.core.UUID);\n}\n});\n/**\n * Construct a transit binary value. s should be base64 encoded\n * string.\n */\ncognitect.transit.binary \x3d (function cognitect$transit$binary(s){\nreturn com.cognitect.transit.types.binary(s);\n});\n/**\n * Returns true if x is a transit binary value, false otherwise.\n */\ncognitect.transit.binary_QMARK_ \x3d (function cognitect$transit$binary_QMARK_(x){\nreturn com.cognitect.transit.types.isBinary(x);\n});\n/**\n * Construct a quoted transit value. x should be a transit\n * encodeable value.\n */\ncognitect.transit.quoted \x3d (function cognitect$transit$quoted(x){\nreturn com.cognitect.transit.types.quoted(x);\n});\n/**\n * Returns true if x is a transit quoted value, false otherwise.\n */\ncognitect.transit.quoted_QMARK_ \x3d (function cognitect$transit$quoted_QMARK_(x){\nreturn com.cognitect.transit.types.isQuoted(x);\n});\n/**\n * Construct a transit link value. x should be an IMap instance\n * containing at a minimum the following keys: :href, :rel. It\n * may optionall include :name, :render, and :prompt. :href must\n * be a transit URI, all other values are strings, and :render must\n * be either :image or :link.\n */\ncognitect.transit.link \x3d (function cognitect$transit$link(x){\nreturn com.cognitect.transit.types.link(x);\n});\n/**\n * Returns true if x a transit link value, false if otherwise.\n */\ncognitect.transit.link_QMARK_ \x3d (function cognitect$transit$link_QMARK_(x){\nreturn com.cognitect.transit.types.isLink(x);\n});\n/**\n * For :transform. Will write any metadata present on the value.\n */\ncognitect.transit.write_meta \x3d (function cognitect$transit$write_meta(x){\nif((((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition0$ \x26 (131072))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IMeta$))))?true:false):false)){\nvar m \x3d x.cljs$core$IMeta$_meta$arity$1(null, );\nif((!((m \x3d\x3d null)))){\nreturn (new cognitect.transit.WithMeta(x.cljs$core$IWithMeta$_with_meta$arity$2(null, null),m));\n} else {\nreturn x;\n}\n} else {\nreturn x;\n}\n});\n");
SHADOW_ENV.evalLoad("shadow.remote.runtime.api.js", true, "goog.provide(\x27shadow.remote.runtime.api\x27);\n\n/**\n * @interface\n */\nshadow.remote.runtime.api.IRuntime \x3d function(){};\n\nvar shadow$remote$runtime$api$IRuntime$relay_msg$dyn_19800 \x3d (function (runtime,msg){\nvar x__5350__auto__ \x3d (((runtime \x3d\x3d null))?null:runtime);\nvar m__5351__auto__ \x3d (shadow.remote.runtime.api.relay_msg[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(runtime,msg) : m__5351__auto__.call(null, runtime,msg));\n} else {\nvar m__5349__auto__ \x3d (shadow.remote.runtime.api.relay_msg[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(runtime,msg) : m__5349__auto__.call(null, runtime,msg));\n} else {\nthrow cljs.core.missing_protocol(\x22IRuntime.relay-msg\x22,runtime);\n}\n}\n});\nshadow.remote.runtime.api.relay_msg \x3d (function shadow$remote$runtime$api$relay_msg(runtime,msg){\nif((((!((runtime \x3d\x3d null)))) \x26\x26 ((!((runtime.shadow$remote$runtime$api$IRuntime$relay_msg$arity$2 \x3d\x3d null)))))){\nreturn runtime.shadow$remote$runtime$api$IRuntime$relay_msg$arity$2(runtime,msg);\n} else {\nreturn shadow$remote$runtime$api$IRuntime$relay_msg$dyn_19800(runtime,msg);\n}\n});\n\nvar shadow$remote$runtime$api$IRuntime$add_extension$dyn_19809 \x3d (function (runtime,key,spec){\nvar x__5350__auto__ \x3d (((runtime \x3d\x3d null))?null:runtime);\nvar m__5351__auto__ \x3d (shadow.remote.runtime.api.add_extension[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(runtime,key,spec) : m__5351__auto__.call(null, runtime,key,spec));\n} else {\nvar m__5349__auto__ \x3d (shadow.remote.runtime.api.add_extension[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(runtime,key,spec) : m__5349__auto__.call(null, runtime,key,spec));\n} else {\nthrow cljs.core.missing_protocol(\x22IRuntime.add-extension\x22,runtime);\n}\n}\n});\nshadow.remote.runtime.api.add_extension \x3d (function shadow$remote$runtime$api$add_extension(runtime,key,spec){\nif((((!((runtime \x3d\x3d null)))) \x26\x26 ((!((runtime.shadow$remote$runtime$api$IRuntime$add_extension$arity$3 \x3d\x3d null)))))){\nreturn runtime.shadow$remote$runtime$api$IRuntime$add_extension$arity$3(runtime,key,spec);\n} else {\nreturn shadow$remote$runtime$api$IRuntime$add_extension$dyn_19809(runtime,key,spec);\n}\n});\n\nvar shadow$remote$runtime$api$IRuntime$del_extension$dyn_19811 \x3d (function (runtime,key){\nvar x__5350__auto__ \x3d (((runtime \x3d\x3d null))?null:runtime);\nvar m__5351__auto__ \x3d (shadow.remote.runtime.api.del_extension[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(runtime,key) : m__5351__auto__.call(null, runtime,key));\n} else {\nvar m__5349__auto__ \x3d (shadow.remote.runtime.api.del_extension[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(runtime,key) : m__5349__auto__.call(null, runtime,key));\n} else {\nthrow cljs.core.missing_protocol(\x22IRuntime.del-extension\x22,runtime);\n}\n}\n});\nshadow.remote.runtime.api.del_extension \x3d (function shadow$remote$runtime$api$del_extension(runtime,key){\nif((((!((runtime \x3d\x3d null)))) \x26\x26 ((!((runtime.shadow$remote$runtime$api$IRuntime$del_extension$arity$2 \x3d\x3d null)))))){\nreturn runtime.shadow$remote$runtime$api$IRuntime$del_extension$arity$2(runtime,key);\n} else {\nreturn shadow$remote$runtime$api$IRuntime$del_extension$dyn_19811(runtime,key);\n}\n});\n\n\n/**\n * @interface\n */\nshadow.remote.runtime.api.Inspectable \x3d function(){};\n\nvar shadow$remote$runtime$api$Inspectable$describe$dyn_19818 \x3d (function (thing,opts){\nvar x__5350__auto__ \x3d (((thing \x3d\x3d null))?null:thing);\nvar m__5351__auto__ \x3d (shadow.remote.runtime.api.describe[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(thing,opts) : m__5351__auto__.call(null, thing,opts));\n} else {\nvar m__5349__auto__ \x3d (shadow.remote.runtime.api.describe[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(thing,opts) : m__5349__auto__.call(null, thing,opts));\n} else {\nthrow cljs.core.missing_protocol(\x22Inspectable.describe\x22,thing);\n}\n}\n});\n/**\n * returns a map descriptor that tells system how to handle things further\n */\nshadow.remote.runtime.api.describe \x3d (function shadow$remote$runtime$api$describe(thing,opts){\nvar temp__5802__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.meta(thing),cljs.core.with_meta(new cljs.core.Symbol(\x22shadow.remote.runtime.api\x22,\x22describe\x22,\x22shadow.remote.runtime.api/describe\x22,1388020131,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(\x22cljs.analyzer\x22,\x22no-resolve\x22,\x22cljs.analyzer/no-resolve\x22,-1872351017),true], null)));\nif(temp__5802__auto__){\nvar meta_impl__5352__auto__ \x3d temp__5802__auto__;\nreturn (meta_impl__5352__auto__.cljs$core$IFn$_invoke$arity$2 ? meta_impl__5352__auto__.cljs$core$IFn$_invoke$arity$2(thing,opts) : meta_impl__5352__auto__.call(null, thing,opts));\n} else {\nif((((!((thing \x3d\x3d null)))) \x26\x26 ((!((thing.shadow$remote$runtime$api$Inspectable$describe$arity$2 \x3d\x3d null)))))){\nreturn thing.shadow$remote$runtime$api$Inspectable$describe$arity$2(thing,opts);\n} else {\nreturn shadow$remote$runtime$api$Inspectable$describe$dyn_19818(thing,opts);\n}\n}\n});\n\n\n/**\n * @interface\n */\nshadow.remote.runtime.api.IEvalCLJS \x3d function(){};\n\nvar shadow$remote$runtime$api$IEvalCLJS$_cljs_eval$dyn_19832 \x3d (function (runtime,input,callback){\nvar x__5350__auto__ \x3d (((runtime \x3d\x3d null))?null:runtime);\nvar m__5351__auto__ \x3d (shadow.remote.runtime.api._cljs_eval[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(runtime,input,callback) : m__5351__auto__.call(null, runtime,input,callback));\n} else {\nvar m__5349__auto__ \x3d (shadow.remote.runtime.api._cljs_eval[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(runtime,input,callback) : m__5349__auto__.call(null, runtime,input,callback));\n} else {\nthrow cljs.core.missing_protocol(\x22IEvalCLJS.-cljs-eval\x22,runtime);\n}\n}\n});\nshadow.remote.runtime.api._cljs_eval \x3d (function shadow$remote$runtime$api$_cljs_eval(runtime,input,callback){\nif((((!((runtime \x3d\x3d null)))) \x26\x26 ((!((runtime.shadow$remote$runtime$api$IEvalCLJS$_cljs_eval$arity$3 \x3d\x3d null)))))){\nreturn runtime.shadow$remote$runtime$api$IEvalCLJS$_cljs_eval$arity$3(runtime,input,callback);\n} else {\nreturn shadow$remote$runtime$api$IEvalCLJS$_cljs_eval$dyn_19832(runtime,input,callback);\n}\n});\n\n\n\n/**\n * @interface\n */\nshadow.remote.runtime.api.IEvalJS \x3d function(){};\n\nvar shadow$remote$runtime$api$IEvalJS$_js_eval$dyn_19847 \x3d (function (runtime,code){\nvar x__5350__auto__ \x3d (((runtime \x3d\x3d null))?null:runtime);\nvar m__5351__auto__ \x3d (shadow.remote.runtime.api._js_eval[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(runtime,code) : m__5351__auto__.call(null, runtime,code));\n} else {\nvar m__5349__auto__ \x3d (shadow.remote.runtime.api._js_eval[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(runtime,code) : m__5349__auto__.call(null, runtime,code));\n} else {\nthrow cljs.core.missing_protocol(\x22IEvalJS.-js-eval\x22,runtime);\n}\n}\n});\nshadow.remote.runtime.api._js_eval \x3d (function shadow$remote$runtime$api$_js_eval(runtime,code){\nif((((!((runtime \x3d\x3d null)))) \x26\x26 ((!((runtime.shadow$remote$runtime$api$IEvalJS$_js_eval$arity$2 \x3d\x3d null)))))){\nreturn runtime.shadow$remote$runtime$api$IEvalJS$_js_eval$arity$2(runtime,code);\n} else {\nreturn shadow$remote$runtime$api$IEvalJS$_js_eval$dyn_19847(runtime,code);\n}\n});\n\n\nshadow.remote.runtime.api.cljs_eval \x3d (function shadow$remote$runtime$api$cljs_eval(runtime,p__19783,callback){\nvar map__19784 \x3d p__19783;\nvar map__19784__$1 \x3d cljs.core.__destructure_map(map__19784);\nvar input \x3d map__19784__$1;\nvar code \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19784__$1,new cljs.core.Keyword(null,\x22code\x22,\x22code\x22,1586293142));\nvar ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19784__$1,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760));\nif(((typeof code \x3d\x3d\x3d \x27string\x27) \x26\x26 (cljs.core.simple_symbol_QMARK_(ns)))){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid cljs-eval input\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22input\x22,\x22input\x22,556931961),input], null));\n}\n\nreturn shadow.remote.runtime.api._cljs_eval(runtime,input,callback);\n});\n\nshadow.remote.runtime.api.js_eval \x3d (function shadow$remote$runtime$api$js_eval(runtime,code){\nif(typeof code \x3d\x3d\x3d \x27string\x27){\n} else {\nthrow (new Error(\x22Assert failed: (string? code)\x22));\n}\n\nreturn shadow.remote.runtime.api._js_eval(runtime,code);\n});\n");
SHADOW_ENV.evalLoad("shadow.remote.runtime.shared.js", true, "goog.provide(\x27shadow.remote.runtime.shared\x27);\nshadow.remote.runtime.shared.init_state \x3d (function shadow$remote$runtime$shared$init_state(client_info){\nreturn new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22client-info\x22,\x22client-info\x22,1958982504),client_info,new cljs.core.Keyword(null,\x22call-id-seq\x22,\x22call-id-seq\x22,-1679248218),(0),new cljs.core.Keyword(null,\x22call-handlers\x22,\x22call-handlers\x22,386605551),cljs.core.PersistentArrayMap.EMPTY], null);\n});\nshadow.remote.runtime.shared.now \x3d (function shadow$remote$runtime$shared$now(){\nreturn Date.now();\n});\nshadow.remote.runtime.shared.get_client_id \x3d (function shadow$remote$runtime$shared$get_client_id(p__19820){\nvar map__19823 \x3d p__19820;\nvar map__19823__$1 \x3d cljs.core.__destructure_map(map__19823);\nvar runtime \x3d map__19823__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19823__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22runtime has no assigned runtime-id\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),runtime], null));\n}\n});\nshadow.remote.runtime.shared.relay_msg \x3d (function shadow$remote$runtime$shared$relay_msg(runtime,msg){\nvar self_id_20158 \x3d shadow.remote.runtime.shared.get_client_id(runtime);\nif(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007).cljs$core$IFn$_invoke$arity$1(msg),self_id_20158)){\nshadow.remote.runtime.api.relay_msg(runtime,msg);\n} else {\nPromise.resolve((1)).then((function (){\nvar G__19829 \x3d runtime;\nvar G__19830 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(msg,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),self_id_20158);\nreturn (shadow.remote.runtime.shared.process.cljs$core$IFn$_invoke$arity$2 ? shadow.remote.runtime.shared.process.cljs$core$IFn$_invoke$arity$2(G__19829,G__19830) : shadow.remote.runtime.shared.process.call(null, G__19829,G__19830));\n}));\n}\n\nreturn msg;\n});\nshadow.remote.runtime.shared.reply \x3d (function shadow$remote$runtime$shared$reply(runtime,p__19837,res){\nvar map__19838 \x3d p__19837;\nvar map__19838__$1 \x3d cljs.core.__destructure_map(map__19838);\nvar call_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19838__$1,new cljs.core.Keyword(null,\x22call-id\x22,\x22call-id\x22,1043012968));\nvar from \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19838__$1,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044));\nvar res__$1 \x3d (function (){var G__19840 \x3d res;\nvar G__19840__$1 \x3d (cljs.core.truth_(call_id)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__19840,new cljs.core.Keyword(null,\x22call-id\x22,\x22call-id\x22,1043012968),call_id):G__19840);\nif(cljs.core.truth_(from)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__19840__$1,new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),from);\n} else {\nreturn G__19840__$1;\n}\n})();\nreturn shadow.remote.runtime.api.relay_msg(runtime,res__$1);\n});\nshadow.remote.runtime.shared.call \x3d (function shadow$remote$runtime$shared$call(var_args){\nvar G__19851 \x3d arguments.length;\nswitch (G__19851) {\ncase 3:\nreturn shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$3 \x3d (function (runtime,msg,handlers){\nreturn shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$4(runtime,msg,handlers,(0));\n}));\n\n(shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$4 \x3d (function (p__19857,msg,handlers,timeout_after_ms){\nvar map__19858 \x3d p__19857;\nvar map__19858__$1 \x3d cljs.core.__destructure_map(map__19858);\nvar runtime \x3d map__19858__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19858__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nif(cljs.core.map_QMARK_(msg)){\n} else {\nthrow (new Error(\x22Assert failed: (map? msg)\x22));\n}\n\nif(cljs.core.map_QMARK_(handlers)){\n} else {\nthrow (new Error(\x22Assert failed: (map? handlers)\x22));\n}\n\nif(cljs.core.nat_int_QMARK_(timeout_after_ms)){\n} else {\nthrow (new Error(\x22Assert failed: (nat-int? timeout-after-ms)\x22));\n}\n\nvar call_id \x3d new cljs.core.Keyword(null,\x22call-id-seq\x22,\x22call-id-seq\x22,-1679248218).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.update,new cljs.core.Keyword(null,\x22call-id-seq\x22,\x22call-id-seq\x22,-1679248218),cljs.core.inc);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc_in,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22call-handlers\x22,\x22call-handlers\x22,386605551),call_id], null),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781),handlers,new cljs.core.Keyword(null,\x22called-at\x22,\x22called-at\x22,607081160),shadow.remote.runtime.shared.now(),new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),msg,new cljs.core.Keyword(null,\x22timeout\x22,\x22timeout\x22,-318625318),timeout_after_ms], null));\n\nreturn shadow.remote.runtime.api.relay_msg(runtime,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(msg,new cljs.core.Keyword(null,\x22call-id\x22,\x22call-id\x22,1043012968),call_id));\n}));\n\n(shadow.remote.runtime.shared.call.cljs$lang$maxFixedArity \x3d 4);\n\nshadow.remote.runtime.shared.trigger_BANG_ \x3d (function shadow$remote$runtime$shared$trigger_BANG_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___20202 \x3d arguments.length;\nvar i__5727__auto___20203 \x3d (0);\nwhile(true){\nif((i__5727__auto___20203 \x3c len__5726__auto___20202)){\nargs__5732__auto__.push((arguments[i__5727__auto___20203]));\n\nvar G__20204 \x3d (i__5727__auto___20203 + (1));\ni__5727__auto___20203 \x3d G__20204;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn shadow.remote.runtime.shared.trigger_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(shadow.remote.runtime.shared.trigger_BANG_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (p__19874,ev,args){\nvar map__19879 \x3d p__19874;\nvar map__19879__$1 \x3d cljs.core.__destructure_map(map__19879);\nvar runtime \x3d map__19879__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19879__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar seq__19882 \x3d cljs.core.seq(cljs.core.vals(new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref))));\nvar chunk__19885 \x3d null;\nvar count__19886 \x3d (0);\nvar i__19887 \x3d (0);\nwhile(true){\nif((i__19887 \x3c count__19886)){\nvar ext \x3d chunk__19885.cljs$core$IIndexed$_nth$arity$2(null, i__19887);\nvar ev_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(ext,ev);\nif(cljs.core.truth_(ev_fn)){\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2(ev_fn,args);\n\n\nvar G__20215 \x3d seq__19882;\nvar G__20216 \x3d chunk__19885;\nvar G__20217 \x3d count__19886;\nvar G__20218 \x3d (i__19887 + (1));\nseq__19882 \x3d G__20215;\nchunk__19885 \x3d G__20216;\ncount__19886 \x3d G__20217;\ni__19887 \x3d G__20218;\ncontinue;\n} else {\nvar G__20222 \x3d seq__19882;\nvar G__20223 \x3d chunk__19885;\nvar G__20224 \x3d count__19886;\nvar G__20225 \x3d (i__19887 + (1));\nseq__19882 \x3d G__20222;\nchunk__19885 \x3d G__20223;\ncount__19886 \x3d G__20224;\ni__19887 \x3d G__20225;\ncontinue;\n}\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__19882);\nif(temp__5804__auto__){\nvar seq__19882__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__19882__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__19882__$1);\nvar G__20231 \x3d cljs.core.chunk_rest(seq__19882__$1);\nvar G__20232 \x3d c__5525__auto__;\nvar G__20233 \x3d cljs.core.count(c__5525__auto__);\nvar G__20234 \x3d (0);\nseq__19882 \x3d G__20231;\nchunk__19885 \x3d G__20232;\ncount__19886 \x3d G__20233;\ni__19887 \x3d G__20234;\ncontinue;\n} else {\nvar ext \x3d cljs.core.first(seq__19882__$1);\nvar ev_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(ext,ev);\nif(cljs.core.truth_(ev_fn)){\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2(ev_fn,args);\n\n\nvar G__20242 \x3d cljs.core.next(seq__19882__$1);\nvar G__20243 \x3d null;\nvar G__20244 \x3d (0);\nvar G__20245 \x3d (0);\nseq__19882 \x3d G__20242;\nchunk__19885 \x3d G__20243;\ncount__19886 \x3d G__20244;\ni__19887 \x3d G__20245;\ncontinue;\n} else {\nvar G__20247 \x3d cljs.core.next(seq__19882__$1);\nvar G__20248 \x3d null;\nvar G__20249 \x3d (0);\nvar G__20250 \x3d (0);\nseq__19882 \x3d G__20247;\nchunk__19885 \x3d G__20248;\ncount__19886 \x3d G__20249;\ni__19887 \x3d G__20250;\ncontinue;\n}\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n}));\n\n(shadow.remote.runtime.shared.trigger_BANG_.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(shadow.remote.runtime.shared.trigger_BANG_.cljs$lang$applyTo \x3d (function (seq19866){\nvar G__19867 \x3d cljs.core.first(seq19866);\nvar seq19866__$1 \x3d cljs.core.next(seq19866);\nvar G__19868 \x3d cljs.core.first(seq19866__$1);\nvar seq19866__$2 \x3d cljs.core.next(seq19866__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__19867,G__19868,seq19866__$2);\n}));\n\nshadow.remote.runtime.shared.welcome \x3d (function shadow$remote$runtime$shared$welcome(p__19920,p__19921){\nvar map__19922 \x3d p__19920;\nvar map__19922__$1 \x3d cljs.core.__destructure_map(map__19922);\nvar runtime \x3d map__19922__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19922__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar map__19923 \x3d p__19921;\nvar map__19923__$1 \x3d cljs.core.__destructure_map(map__19923);\nvar msg \x3d map__19923__$1;\nvar client_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19923__$1,new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(state_ref,cljs.core.assoc,new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140),client_id,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22welcome\x22,\x22welcome\x22,-578152123),true], 0));\n\nvar map__19930 \x3d cljs.core.deref(state_ref);\nvar map__19930__$1 \x3d cljs.core.__destructure_map(map__19930);\nvar client_info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19930__$1,new cljs.core.Keyword(null,\x22client-info\x22,\x22client-info\x22,1958982504));\nvar extensions \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19930__$1,new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196));\nshadow.remote.runtime.shared.relay_msg(runtime,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22hello\x22,\x22hello\x22,-245025397),new cljs.core.Keyword(null,\x22client-info\x22,\x22client-info\x22,1958982504),client_info], null));\n\nreturn shadow.remote.runtime.shared.trigger_BANG_(runtime,new cljs.core.Keyword(null,\x22on-welcome\x22,\x22on-welcome\x22,1895317125));\n});\nshadow.remote.runtime.shared.ping \x3d (function shadow$remote$runtime$shared$ping(runtime,msg){\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22pong\x22,\x22pong\x22,-172484958)], null));\n});\nshadow.remote.runtime.shared.request_supported_ops \x3d (function shadow$remote$runtime$shared$request_supported_ops(p__19937,msg){\nvar map__19939 \x3d p__19937;\nvar map__19939__$1 \x3d cljs.core.__destructure_map(map__19939);\nvar runtime \x3d map__19939__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19939__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22supported-ops\x22,\x22supported-ops\x22,337914702),new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic(cljs.core.set(cljs.core.keys(new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref)))),new cljs.core.Keyword(null,\x22welcome\x22,\x22welcome\x22,-578152123),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22unknown-relay-op\x22,\x22unknown-relay-op\x22,170832753),new cljs.core.Keyword(null,\x22unknown-op\x22,\x22unknown-op\x22,1900385996),new cljs.core.Keyword(null,\x22request-supported-ops\x22,\x22request-supported-ops\x22,-1034994502),new cljs.core.Keyword(null,\x22tool-disconnect\x22,\x22tool-disconnect\x22,189103996)], 0))], null));\n});\nshadow.remote.runtime.shared.unknown_relay_op \x3d (function shadow$remote$runtime$shared$unknown_relay_op(msg){\nreturn console.warn(\x22unknown-relay-op\x22,msg);\n});\nshadow.remote.runtime.shared.unknown_op \x3d (function shadow$remote$runtime$shared$unknown_op(msg){\nreturn console.warn(\x22unknown-op\x22,msg);\n});\nshadow.remote.runtime.shared.add_extension_STAR_ \x3d (function shadow$remote$runtime$shared$add_extension_STAR_(p__19953,key,p__19954){\nvar map__19956 \x3d p__19953;\nvar map__19956__$1 \x3d cljs.core.__destructure_map(map__19956);\nvar state \x3d map__19956__$1;\nvar extensions \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19956__$1,new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196));\nvar map__19958 \x3d p__19954;\nvar map__19958__$1 \x3d cljs.core.__destructure_map(map__19958);\nvar spec \x3d map__19958__$1;\nvar ops \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19958__$1,new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063));\nvar transit_write_handlers \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19958__$1,new cljs.core.Keyword(null,\x22transit-write-handlers\x22,\x22transit-write-handlers\x22,1886308716));\nif(cljs.core.contains_QMARK_(extensions,key)){\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22extension already registered\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),key,new cljs.core.Keyword(null,\x22spec\x22,\x22spec\x22,347520401),spec], null));\n} else {\n}\n\nreturn cljs.core.reduce_kv((function (state__$1,op_kw,op_handler){\nif(cljs.core.truth_(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(state__$1,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),op_kw], null)))){\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22op already registered\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),key,new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),op_kw], null));\n} else {\n}\n\nreturn cljs.core.assoc_in(state__$1,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),op_kw], null),op_handler);\n}),cljs.core.assoc_in(state,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196),key], null),spec),ops);\n});\nshadow.remote.runtime.shared.add_extension \x3d (function shadow$remote$runtime$shared$add_extension(p__19969,key,spec){\nvar map__19970 \x3d p__19969;\nvar map__19970__$1 \x3d cljs.core.__destructure_map(map__19970);\nvar runtime \x3d map__19970__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__19970__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,shadow.remote.runtime.shared.add_extension_STAR_,key,spec);\n\nvar temp__5808__auto___20281 \x3d new cljs.core.Keyword(null,\x22on-welcome\x22,\x22on-welcome\x22,1895317125).cljs$core$IFn$_invoke$arity$1(spec);\nif((temp__5808__auto___20281 \x3d\x3d null)){\n} else {\nvar on_welcome_20283 \x3d temp__5808__auto___20281;\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22welcome\x22,\x22welcome\x22,-578152123).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref)))){\n(on_welcome_20283.cljs$core$IFn$_invoke$arity$0 ? on_welcome_20283.cljs$core$IFn$_invoke$arity$0() : on_welcome_20283.call(null, ));\n} else {\n}\n}\n\nreturn runtime;\n});\nshadow.remote.runtime.shared.add_defaults \x3d (function shadow$remote$runtime$shared$add_defaults(runtime){\nreturn shadow.remote.runtime.shared.add_extension(runtime,new cljs.core.Keyword(\x22shadow.remote.runtime.shared\x22,\x22defaults\x22,\x22shadow.remote.runtime.shared/defaults\x22,-1821257543),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22welcome\x22,\x22welcome\x22,-578152123),(function (p1__19982_SHARP_){\nreturn shadow.remote.runtime.shared.welcome(runtime,p1__19982_SHARP_);\n}),new cljs.core.Keyword(null,\x22unknown-relay-op\x22,\x22unknown-relay-op\x22,170832753),(function (p1__19983_SHARP_){\nreturn shadow.remote.runtime.shared.unknown_relay_op(p1__19983_SHARP_);\n}),new cljs.core.Keyword(null,\x22unknown-op\x22,\x22unknown-op\x22,1900385996),(function (p1__19985_SHARP_){\nreturn shadow.remote.runtime.shared.unknown_op(p1__19985_SHARP_);\n}),new cljs.core.Keyword(null,\x22ping\x22,\x22ping\x22,-1670114784),(function (p1__19986_SHARP_){\nreturn shadow.remote.runtime.shared.ping(runtime,p1__19986_SHARP_);\n}),new cljs.core.Keyword(null,\x22request-supported-ops\x22,\x22request-supported-ops\x22,-1034994502),(function (p1__19988_SHARP_){\nreturn shadow.remote.runtime.shared.request_supported_ops(runtime,p1__19988_SHARP_);\n})], null)], null));\n});\nshadow.remote.runtime.shared.del_extension_STAR_ \x3d (function shadow$remote$runtime$shared$del_extension_STAR_(state,key){\nvar ext \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(state,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196),key], null));\nif(cljs.core.not(ext)){\nreturn state;\n} else {\nreturn cljs.core.reduce_kv((function (state__$1,op_kw,op_handler){\nreturn cljs.core.update_in.cljs$core$IFn$_invoke$arity$4(state__$1,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063)], null),cljs.core.dissoc,op_kw);\n}),cljs.core.update.cljs$core$IFn$_invoke$arity$4(state,new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196),cljs.core.dissoc,key),new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063).cljs$core$IFn$_invoke$arity$1(ext));\n}\n});\nshadow.remote.runtime.shared.del_extension \x3d (function shadow$remote$runtime$shared$del_extension(p__20012,key){\nvar map__20013 \x3d p__20012;\nvar map__20013__$1 \x3d cljs.core.__destructure_map(map__20013);\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__20013__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(state_ref,shadow.remote.runtime.shared.del_extension_STAR_,key);\n});\nshadow.remote.runtime.shared.unhandled_call_result \x3d (function shadow$remote$runtime$shared$unhandled_call_result(call_config,msg){\nreturn console.warn(\x22unhandled call result\x22,msg,call_config);\n});\nshadow.remote.runtime.shared.unhandled_client_not_found \x3d (function shadow$remote$runtime$shared$unhandled_client_not_found(p__20021,msg){\nvar map__20024 \x3d p__20021;\nvar map__20024__$1 \x3d cljs.core.__destructure_map(map__20024);\nvar runtime \x3d map__20024__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__20024__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nreturn shadow.remote.runtime.shared.trigger_BANG_.cljs$core$IFn$_invoke$arity$variadic(runtime,new cljs.core.Keyword(null,\x22on-client-not-found\x22,\x22on-client-not-found\x22,-642452849),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([msg], 0));\n});\nshadow.remote.runtime.shared.reply_unknown_op \x3d (function shadow$remote$runtime$shared$reply_unknown_op(runtime,msg){\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22unknown-op\x22,\x22unknown-op\x22,1900385996),new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),msg], null));\n});\nshadow.remote.runtime.shared.process \x3d (function shadow$remote$runtime$shared$process(p__20051,p__20052){\nvar map__20053 \x3d p__20051;\nvar map__20053__$1 \x3d cljs.core.__destructure_map(map__20053);\nvar runtime \x3d map__20053__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__20053__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar map__20054 \x3d p__20052;\nvar map__20054__$1 \x3d cljs.core.__destructure_map(map__20054);\nvar msg \x3d map__20054__$1;\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__20054__$1,new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955));\nvar call_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__20054__$1,new cljs.core.Keyword(null,\x22call-id\x22,\x22call-id\x22,1043012968));\nvar state \x3d cljs.core.deref(state_ref);\nvar op_handler \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(state,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),op], null));\nif(cljs.core.truth_(call_id)){\nvar cfg \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(state,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22call-handlers\x22,\x22call-handlers\x22,386605551),call_id], null));\nvar call_handler \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(cfg,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781),op], null));\nif(cljs.core.truth_(call_handler)){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(state_ref,cljs.core.update,new cljs.core.Keyword(null,\x22call-handlers\x22,\x22call-handlers\x22,386605551),cljs.core.dissoc,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([call_id], 0));\n\nreturn (call_handler.cljs$core$IFn$_invoke$arity$1 ? call_handler.cljs$core$IFn$_invoke$arity$1(msg) : call_handler.call(null, msg));\n} else {\nif(cljs.core.truth_(op_handler)){\nreturn (op_handler.cljs$core$IFn$_invoke$arity$1 ? op_handler.cljs$core$IFn$_invoke$arity$1(msg) : op_handler.call(null, msg));\n} else {\nreturn shadow.remote.runtime.shared.unhandled_call_result(cfg,msg);\n\n}\n}\n} else {\nif(cljs.core.truth_(op_handler)){\nreturn (op_handler.cljs$core$IFn$_invoke$arity$1 ? op_handler.cljs$core$IFn$_invoke$arity$1(msg) : op_handler.call(null, msg));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22client-not-found\x22,\x22client-not-found\x22,-1754042614),op)){\nreturn shadow.remote.runtime.shared.unhandled_client_not_found(runtime,msg);\n} else {\nreturn shadow.remote.runtime.shared.reply_unknown_op(runtime,msg);\n\n}\n}\n}\n});\nshadow.remote.runtime.shared.run_on_idle \x3d (function shadow$remote$runtime$shared$run_on_idle(state_ref){\nvar seq__20074 \x3d cljs.core.seq(cljs.core.vals(new cljs.core.Keyword(null,\x22extensions\x22,\x22extensions\x22,-1103629196).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref))));\nvar chunk__20076 \x3d null;\nvar count__20077 \x3d (0);\nvar i__20078 \x3d (0);\nwhile(true){\nif((i__20078 \x3c count__20077)){\nvar map__20102 \x3d chunk__20076.cljs$core$IIndexed$_nth$arity$2(null, i__20078);\nvar map__20102__$1 \x3d cljs.core.__destructure_map(map__20102);\nvar on_idle \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__20102__$1,new cljs.core.Keyword(null,\x22on-idle\x22,\x22on-idle\x22,2044706602));\nif(cljs.core.truth_(on_idle)){\n(on_idle.cljs$core$IFn$_invoke$arity$0 ? on_idle.cljs$core$IFn$_invoke$arity$0() : on_idle.call(null, ));\n\n\nvar G__20306 \x3d seq__20074;\nvar G__20307 \x3d chunk__20076;\nvar G__20308 \x3d count__20077;\nvar G__20309 \x3d (i__20078 + (1));\nseq__20074 \x3d G__20306;\nchunk__20076 \x3d G__20307;\ncount__20077 \x3d G__20308;\ni__20078 \x3d G__20309;\ncontinue;\n} else {\nvar G__20310 \x3d seq__20074;\nvar G__20311 \x3d chunk__20076;\nvar G__20312 \x3d count__20077;\nvar G__20313 \x3d (i__20078 + (1));\nseq__20074 \x3d G__20310;\nchunk__20076 \x3d G__20311;\ncount__20077 \x3d G__20312;\ni__20078 \x3d G__20313;\ncontinue;\n}\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__20074);\nif(temp__5804__auto__){\nvar seq__20074__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__20074__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__20074__$1);\nvar G__20316 \x3d cljs.core.chunk_rest(seq__20074__$1);\nvar G__20317 \x3d c__5525__auto__;\nvar G__20318 \x3d cljs.core.count(c__5525__auto__);\nvar G__20319 \x3d (0);\nseq__20074 \x3d G__20316;\nchunk__20076 \x3d G__20317;\ncount__20077 \x3d G__20318;\ni__20078 \x3d G__20319;\ncontinue;\n} else {\nvar map__20116 \x3d cljs.core.first(seq__20074__$1);\nvar map__20116__$1 \x3d cljs.core.__destructure_map(map__20116);\nvar on_idle \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__20116__$1,new cljs.core.Keyword(null,\x22on-idle\x22,\x22on-idle\x22,2044706602));\nif(cljs.core.truth_(on_idle)){\n(on_idle.cljs$core$IFn$_invoke$arity$0 ? on_idle.cljs$core$IFn$_invoke$arity$0() : on_idle.call(null, ));\n\n\nvar G__20321 \x3d cljs.core.next(seq__20074__$1);\nvar G__20322 \x3d null;\nvar G__20323 \x3d (0);\nvar G__20324 \x3d (0);\nseq__20074 \x3d G__20321;\nchunk__20076 \x3d G__20322;\ncount__20077 \x3d G__20323;\ni__20078 \x3d G__20324;\ncontinue;\n} else {\nvar G__20325 \x3d cljs.core.next(seq__20074__$1);\nvar G__20326 \x3d null;\nvar G__20327 \x3d (0);\nvar G__20328 \x3d (0);\nseq__20074 \x3d G__20325;\nchunk__20076 \x3d G__20326;\ncount__20077 \x3d G__20327;\ni__20078 \x3d G__20328;\ncontinue;\n}\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\n");
SHADOW_ENV.evalLoad("clojure.core.protocols.js", true, "goog.provide(\x27clojure.core.protocols\x27);\n\n/**\n * @interface\n */\nclojure.core.protocols.Datafiable \x3d function(){};\n\nvar clojure$core$protocols$Datafiable$datafy$dyn_19757 \x3d (function (o){\nvar x__5350__auto__ \x3d (((o \x3d\x3d null))?null:o);\nvar m__5351__auto__ \x3d (clojure.core.protocols.datafy[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5351__auto__.call(null, o));\n} else {\nvar m__5349__auto__ \x3d (clojure.core.protocols.datafy[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__5349__auto__.call(null, o));\n} else {\nthrow cljs.core.missing_protocol(\x22Datafiable.datafy\x22,o);\n}\n}\n});\n/**\n * return a representation of o as data (default identity)\n */\nclojure.core.protocols.datafy \x3d (function clojure$core$protocols$datafy(o){\nvar temp__5802__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.meta(o),cljs.core.with_meta(new cljs.core.Symbol(\x22clojure.core.protocols\x22,\x22datafy\x22,\x22clojure.core.protocols/datafy\x22,707534751,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(\x22cljs.analyzer\x22,\x22no-resolve\x22,\x22cljs.analyzer/no-resolve\x22,-1872351017),true], null)));\nif(temp__5802__auto__){\nvar meta_impl__5352__auto__ \x3d temp__5802__auto__;\nreturn (meta_impl__5352__auto__.cljs$core$IFn$_invoke$arity$1 ? meta_impl__5352__auto__.cljs$core$IFn$_invoke$arity$1(o) : meta_impl__5352__auto__.call(null, o));\n} else {\nif((((!((o \x3d\x3d null)))) \x26\x26 ((!((o.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d\x3d null)))))){\nreturn o.clojure$core$protocols$Datafiable$datafy$arity$1(o);\n} else {\nreturn clojure$core$protocols$Datafiable$datafy$dyn_19757(o);\n}\n}\n});\n\n(clojure.core.protocols.Datafiable[\x22null\x22] \x3d true);\n\n(clojure.core.protocols.datafy[\x22null\x22] \x3d (function (_){\nreturn null;\n}));\n\n(clojure.core.protocols.Datafiable[\x22_\x22] \x3d true);\n\n(clojure.core.protocols.datafy[\x22_\x22] \x3d (function (o){\nreturn o;\n}));\n\n/**\n * @interface\n */\nclojure.core.protocols.Navigable \x3d function(){};\n\nvar clojure$core$protocols$Navigable$nav$dyn_19774 \x3d (function (coll,k,v){\nvar x__5350__auto__ \x3d (((coll \x3d\x3d null))?null:coll);\nvar m__5351__auto__ \x3d (clojure.core.protocols.nav[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,v) : m__5351__auto__.call(null, coll,k,v));\n} else {\nvar m__5349__auto__ \x3d (clojure.core.protocols.nav[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,v) : m__5349__auto__.call(null, coll,k,v));\n} else {\nthrow cljs.core.missing_protocol(\x22Navigable.nav\x22,coll);\n}\n}\n});\n/**\n * return (possibly transformed) v in the context of coll and k (a key/index or nil),\n * defaults to returning v.\n */\nclojure.core.protocols.nav \x3d (function clojure$core$protocols$nav(coll,k,v){\nvar temp__5802__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.meta(coll),cljs.core.with_meta(new cljs.core.Symbol(\x22clojure.core.protocols\x22,\x22nav\x22,\x22clojure.core.protocols/nav\x22,298936762,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(\x22cljs.analyzer\x22,\x22no-resolve\x22,\x22cljs.analyzer/no-resolve\x22,-1872351017),true], null)));\nif(temp__5802__auto__){\nvar meta_impl__5352__auto__ \x3d temp__5802__auto__;\nreturn (meta_impl__5352__auto__.cljs$core$IFn$_invoke$arity$3 ? meta_impl__5352__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,v) : meta_impl__5352__auto__.call(null, coll,k,v));\n} else {\nif((((!((coll \x3d\x3d null)))) \x26\x26 ((!((coll.clojure$core$protocols$Navigable$nav$arity$3 \x3d\x3d null)))))){\nreturn coll.clojure$core$protocols$Navigable$nav$arity$3(coll,k,v);\n} else {\nreturn clojure$core$protocols$Navigable$nav$dyn_19774(coll,k,v);\n}\n}\n});\n\n(clojure.core.protocols.Navigable[\x22_\x22] \x3d true);\n\n(clojure.core.protocols.nav[\x22_\x22] \x3d (function (_,___$1,x){\nreturn x;\n}));\n");
SHADOW_ENV.evalLoad("shadow.remote.runtime.cljs.js_builtins.js", true, "goog.provide(\x27shadow.remote.runtime.cljs.js_builtins\x27);\ngoog.scope(function(){\n  shadow.remote.runtime.cljs.js_builtins.goog$module$goog$object \x3d goog.module.get(\x27goog.object\x27);\n});\n(clojure.core.protocols.Datafiable[\x22object\x22] \x3d true);\n\n(clojure.core.protocols.datafy[\x22object\x22] \x3d (function (o){\nif((!((o.__proto__ \x3d\x3d\x3d Object.prototype)))){\nreturn o;\n} else {\nreturn cljs.core.with_meta(cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,key){\nreturn cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(m,key,shadow.remote.runtime.cljs.js_builtins.goog$module$goog$object.get(o,key));\n}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),shadow.remote.runtime.cljs.js_builtins.goog$module$goog$object.getKeys(o))),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Symbol(\x22clojure.core.protocols\x22,\x22nav\x22,\x22clojure.core.protocols/nav\x22,298936762,null),(function (coll,k,v){\nreturn shadow.remote.runtime.cljs.js_builtins.goog$module$goog$object.get(o,k);\n})], null));\n}\n}));\n\n(clojure.core.protocols.Datafiable[\x22array\x22] \x3d true);\n\n(clojure.core.protocols.datafy[\x22array\x22] \x3d (function (o){\nreturn cljs.core.vec(o);\n}));\n\n(Error.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(Error.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (e){\nvar e__$1 \x3d this;\nvar data \x3d cljs.core.ex_data(e__$1);\nvar file \x3d e__$1.fileName;\nvar line \x3d e__$1.lineNumber;\nvar column \x3d e__$1.columnNumber;\nvar G__19798 \x3d new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22message\x22,\x22message\x22,-406056002),e__$1.message,new cljs.core.Keyword(null,\x22name\x22,\x22name\x22,1843675177),e__$1.name,new cljs.core.Keyword(null,\x22stack\x22,\x22stack\x22,-793405930),e__$1.stack], null);\nvar G__19798__$1 \x3d (((!((data \x3d\x3d null))))?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__19798,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),data):G__19798);\nvar G__19798__$2 \x3d (cljs.core.truth_(file)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__19798__$1,new cljs.core.Keyword(null,\x22file\x22,\x22file\x22,-1269645878),file):G__19798__$1);\nvar G__19798__$3 \x3d (cljs.core.truth_(line)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__19798__$2,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),line):G__19798__$2);\nif(cljs.core.truth_(column)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__19798__$3,new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095),column);\n} else {\nreturn G__19798__$3;\n}\n}));\n");
SHADOW_ENV.evalLoad("clojure.datafy.js", true, "goog.provide(\x27clojure.datafy\x27);\n/**\n * Attempts to return x as data.\n *   datafy will return the value of clojure.protocols/datafy. If\n *   the value has been transformed and the result supports\n *   metadata, :clojure.datafy/obj will be set on the metadata to the\n *   original value of x.\n */\nclojure.datafy.datafy \x3d (function clojure$datafy$datafy(x){\nvar v \x3d clojure.core.protocols.datafy(x);\nif((v \x3d\x3d\x3d x)){\nreturn v;\n} else {\nif((((!((v \x3d\x3d null))))?(((((v.cljs$lang$protocol_mask$partition0$ \x26 (262144))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d v.cljs$core$IWithMeta$))))?true:false):false)){\nreturn cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$4(v,cljs.core.assoc,new cljs.core.Keyword(\x22clojure.datafy\x22,\x22obj\x22,\x22clojure.datafy/obj\x22,-330079421),x);\n} else {\nreturn v;\n}\n}\n});\n/**\n * Returns (possibly transformed) v in the context of coll and k (a\n *   key/index or nil). Callers should attempt to provide the key/index\n *   context k for Indexed/Associative/ILookup colls if possible, but not\n *   to fabricate one e.g. for sequences (pass nil). nav will return the\n *   value of clojure.core.protocols/nav.\n */\nclojure.datafy.nav \x3d (function clojure$datafy$nav(coll,k,v){\nreturn clojure.core.protocols.nav(coll,k,v);\n});\nclojure.datafy.datify_ref \x3d (function clojure$datafy$datify_ref(r){\nreturn cljs.core.with_meta(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.deref(r)], null),cljs.core.meta(r));\n});\n(Error.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(Error.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (x){\nvar x__$1 \x3d this;\nreturn cljs.core.Throwable__GT_map(x__$1);\n}));\n\n(cljs.core.ExceptionInfo.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.ExceptionInfo.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (x){\nvar x__$1 \x3d this;\nreturn cljs.core.Throwable__GT_map(x__$1);\n}));\n\n(cljs.core.Var.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Var.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (r){\nvar r__$1 \x3d this;\nreturn clojure.datafy.datify_ref(r__$1);\n}));\n\n(cljs.core.Reduced.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Reduced.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (r){\nvar r__$1 \x3d this;\nreturn clojure.datafy.datify_ref(r__$1);\n}));\n\n(cljs.core.Atom.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Atom.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (r){\nvar r__$1 \x3d this;\nreturn clojure.datafy.datify_ref(r__$1);\n}));\n\n(cljs.core.Volatile.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Volatile.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (r){\nvar r__$1 \x3d this;\nreturn clojure.datafy.datify_ref(r__$1);\n}));\n\n(cljs.core.Delay.prototype.clojure$core$protocols$Datafiable$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Delay.prototype.clojure$core$protocols$Datafiable$datafy$arity$1 \x3d (function (r){\nvar r__$1 \x3d this;\nreturn clojure.datafy.datify_ref(r__$1);\n}));\n");
SHADOW_ENV.evalLoad("cljs.pprint.js", true, "goog.provide(\x27cljs.pprint\x27);\ncljs.pprint.print \x3d (function cljs$pprint$print(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27761 \x3d arguments.length;\nvar i__5727__auto___27762 \x3d (0);\nwhile(true){\nif((i__5727__auto___27762 \x3c len__5726__auto___27761)){\nargs__5732__auto__.push((arguments[i__5727__auto___27762]));\n\nvar G__27763 \x3d (i__5727__auto___27762 + (1));\ni__5727__auto___27762 \x3d G__27763;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic \x3d (function (more){\nreturn cljs.core._write(cljs.core._STAR_out_STAR_,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.print_str,more));\n}));\n\n(cljs.pprint.print.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.pprint.print.cljs$lang$applyTo \x3d (function (seq21715){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21715));\n}));\n\ncljs.pprint.println \x3d (function cljs$pprint$println(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27768 \x3d arguments.length;\nvar i__5727__auto___27769 \x3d (0);\nwhile(true){\nif((i__5727__auto___27769 \x3c len__5726__auto___27768)){\nargs__5732__auto__.push((arguments[i__5727__auto___27769]));\n\nvar G__27770 \x3d (i__5727__auto___27769 + (1));\ni__5727__auto___27769 \x3d G__27770;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.pprint.println.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.pprint.println.cljs$core$IFn$_invoke$arity$variadic \x3d (function (more){\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.pprint.print,more);\n\nreturn cljs.core._write(cljs.core._STAR_out_STAR_,\x22\\n\x22);\n}));\n\n(cljs.pprint.println.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.pprint.println.cljs$lang$applyTo \x3d (function (seq21733){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21733));\n}));\n\ncljs.pprint.print_char \x3d (function cljs$pprint$print_char(c){\nreturn cljs.core._write(cljs.core._STAR_out_STAR_,(function (){var pred__21746 \x3d cljs.core._EQ_;\nvar expr__21747 \x3d c;\nif(cljs.core.truth_((function (){var G__21749 \x3d \x22\\b\x22;\nvar G__21750 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21749,G__21750) : pred__21746.call(null, G__21749,G__21750));\n})())){\nreturn \x22\\\\backspace\x22;\n} else {\nif(cljs.core.truth_((function (){var G__21755 \x3d \x22 \x22;\nvar G__21756 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21755,G__21756) : pred__21746.call(null, G__21755,G__21756));\n})())){\nreturn \x22\\\\space\x22;\n} else {\nif(cljs.core.truth_((function (){var G__21757 \x3d \x22\\t\x22;\nvar G__21758 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21757,G__21758) : pred__21746.call(null, G__21757,G__21758));\n})())){\nreturn \x22\\\\tab\x22;\n} else {\nif(cljs.core.truth_((function (){var G__21762 \x3d \x22\\n\x22;\nvar G__21763 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21762,G__21763) : pred__21746.call(null, G__21762,G__21763));\n})())){\nreturn \x22\\\\newline\x22;\n} else {\nif(cljs.core.truth_((function (){var G__21764 \x3d \x22\\f\x22;\nvar G__21765 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21764,G__21765) : pred__21746.call(null, G__21764,G__21765));\n})())){\nreturn \x22\\\\formfeed\x22;\n} else {\nif(cljs.core.truth_((function (){var G__21767 \x3d \x22\\r\x22;\nvar G__21768 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21767,G__21768) : pred__21746.call(null, G__21767,G__21768));\n})())){\nreturn \x22\\\\return\x22;\n} else {\nif(cljs.core.truth_((function (){var G__21774 \x3d \x22\\\x22\x22;\nvar G__21775 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21774,G__21775) : pred__21746.call(null, G__21774,G__21775));\n})())){\nreturn \x22\\\\\\\x22\x22;\n} else {\nif(cljs.core.truth_((function (){var G__21776 \x3d \x22\\\\\x22;\nvar G__21777 \x3d expr__21747;\nreturn (pred__21746.cljs$core$IFn$_invoke$arity$2 ? pred__21746.cljs$core$IFn$_invoke$arity$2(G__21776,G__21777) : pred__21746.call(null, G__21776,G__21777));\n})())){\nreturn \x22\\\\\\\\\x22;\n} else {\nreturn [\x22\\\\\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(c)].join(\x27\x27);\n}\n}\n}\n}\n}\n}\n}\n}\n})());\n});\ncljs.pprint.pr \x3d (function cljs$pprint$pr(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27783 \x3d arguments.length;\nvar i__5727__auto___27784 \x3d (0);\nwhile(true){\nif((i__5727__auto___27784 \x3c len__5726__auto___27783)){\nargs__5732__auto__.push((arguments[i__5727__auto___27784]));\n\nvar G__27785 \x3d (i__5727__auto___27784 + (1));\ni__5727__auto___27784 \x3d G__27785;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.pprint.pr.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.pprint.pr.cljs$core$IFn$_invoke$arity$variadic \x3d (function (more){\nreturn cljs.core._write(cljs.core._STAR_out_STAR_,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.pr_str,more));\n}));\n\n(cljs.pprint.pr.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.pprint.pr.cljs$lang$applyTo \x3d (function (seq21781){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21781));\n}));\n\ncljs.pprint.prn \x3d (function cljs$pprint$prn(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27789 \x3d arguments.length;\nvar i__5727__auto___27791 \x3d (0);\nwhile(true){\nif((i__5727__auto___27791 \x3c len__5726__auto___27789)){\nargs__5732__auto__.push((arguments[i__5727__auto___27791]));\n\nvar G__27792 \x3d (i__5727__auto___27791 + (1));\ni__5727__auto___27791 \x3d G__27792;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.pprint.prn.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.pprint.prn.cljs$core$IFn$_invoke$arity$variadic \x3d (function (more){\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.pprint.pr,more);\n\nreturn cljs.core._write(cljs.core._STAR_out_STAR_,\x22\\n\x22);\n}));\n\n(cljs.pprint.prn.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.pprint.prn.cljs$lang$applyTo \x3d (function (seq21795){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21795));\n}));\n\n/**\n * Returns true if n is an float.\n */\ncljs.pprint.float_QMARK_ \x3d (function cljs$pprint$float_QMARK_(n){\nreturn ((typeof n \x3d\x3d\x3d \x27number\x27) \x26\x26 ((((!(isNaN(n)))) \x26\x26 ((((!((n \x3d\x3d\x3d Infinity)))) \x26\x26 ((!((parseFloat(n) \x3d\x3d\x3d parseInt(n,(10)))))))))));\n});\n/**\n * Convert char to int\n */\ncljs.pprint.char_code \x3d (function cljs$pprint$char_code(c){\nif(typeof c \x3d\x3d\x3d \x27number\x27){\nreturn c;\n} else {\nif(((typeof c \x3d\x3d\x3d \x27string\x27) \x26\x26 ((c.length \x3d\x3d\x3d (1))))){\nreturn c.charCodeAt((0));\n} else {\nthrow (new Error(\x22Argument to char must be a character or number\x22));\n\n}\n}\n});\ncljs.pprint.map_passing_context \x3d (function cljs$pprint$map_passing_context(func,initial_context,lis){\nvar context \x3d initial_context;\nvar lis__$1 \x3d lis;\nvar acc \x3d cljs.core.PersistentVector.EMPTY;\nwhile(true){\nif(cljs.core.empty_QMARK_(lis__$1)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [acc,context], null);\n} else {\nvar this$ \x3d cljs.core.first(lis__$1);\nvar remainder \x3d cljs.core.next(lis__$1);\nvar vec__21826 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(func,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [this$,context], null));\nvar result \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21826,(0),null);\nvar new_context \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21826,(1),null);\nvar G__27801 \x3d new_context;\nvar G__27802 \x3d remainder;\nvar G__27803 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(acc,result);\ncontext \x3d G__27801;\nlis__$1 \x3d G__27802;\nacc \x3d G__27803;\ncontinue;\n}\nbreak;\n}\n});\ncljs.pprint.consume \x3d (function cljs$pprint$consume(func,initial_context){\nvar context \x3d initial_context;\nvar acc \x3d cljs.core.PersistentVector.EMPTY;\nwhile(true){\nvar vec__21846 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(func,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [context], null));\nvar result \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21846,(0),null);\nvar new_context \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21846,(1),null);\nif(cljs.core.not(result)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [acc,new_context], null);\n} else {\nvar G__27808 \x3d new_context;\nvar G__27809 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(acc,result);\ncontext \x3d G__27808;\nacc \x3d G__27809;\ncontinue;\n}\nbreak;\n}\n});\ncljs.pprint.consume_while \x3d (function cljs$pprint$consume_while(func,initial_context){\nvar context \x3d initial_context;\nvar acc \x3d cljs.core.PersistentVector.EMPTY;\nwhile(true){\nvar vec__21856 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(func,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [context], null));\nvar result \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21856,(0),null);\nvar continue$ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21856,(1),null);\nvar new_context \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21856,(2),null);\nif(cljs.core.not(continue$)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [acc,context], null);\n} else {\nvar G__27817 \x3d new_context;\nvar G__27818 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(acc,result);\ncontext \x3d G__27817;\nacc \x3d G__27818;\ncontinue;\n}\nbreak;\n}\n});\ncljs.pprint.unzip_map \x3d (function cljs$pprint$unzip_map(m){\n\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,(function (){var iter__5480__auto__ \x3d (function cljs$pprint$unzip_map_$_iter__21863(s__21864){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__21864__$1 \x3d s__21864;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__21864__$1);\nif(temp__5804__auto__){\nvar s__21864__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__21864__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__21864__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__21866 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__21865 \x3d (0);\nwhile(true){\nif((i__21865 \x3c size__5479__auto__)){\nvar vec__21874 \x3d cljs.core._nth(c__5478__auto__,i__21865);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21874,(0),null);\nvar vec__21877 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21874,(1),null);\nvar v1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21877,(0),null);\nvar v2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21877,(1),null);\ncljs.core.chunk_append(b__21866,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v1], null));\n\nvar G__27822 \x3d (i__21865 + (1));\ni__21865 \x3d G__27822;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21866),cljs$pprint$unzip_map_$_iter__21863(cljs.core.chunk_rest(s__21864__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21866),null);\n}\n} else {\nvar vec__21895 \x3d cljs.core.first(s__21864__$2);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21895,(0),null);\nvar vec__21898 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21895,(1),null);\nvar v1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21898,(0),null);\nvar v2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21898,(1),null);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v1], null),cljs$pprint$unzip_map_$_iter__21863(cljs.core.rest(s__21864__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(m);\n})()),cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,(function (){var iter__5480__auto__ \x3d (function cljs$pprint$unzip_map_$_iter__21902(s__21903){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__21903__$1 \x3d s__21903;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__21903__$1);\nif(temp__5804__auto__){\nvar s__21903__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__21903__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__21903__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__21905 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__21904 \x3d (0);\nwhile(true){\nif((i__21904 \x3c size__5479__auto__)){\nvar vec__21916 \x3d cljs.core._nth(c__5478__auto__,i__21904);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21916,(0),null);\nvar vec__21919 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21916,(1),null);\nvar v1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21919,(0),null);\nvar v2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21919,(1),null);\ncljs.core.chunk_append(b__21905,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v2], null));\n\nvar G__27840 \x3d (i__21904 + (1));\ni__21904 \x3d G__27840;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21905),cljs$pprint$unzip_map_$_iter__21902(cljs.core.chunk_rest(s__21903__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21905),null);\n}\n} else {\nvar vec__21927 \x3d cljs.core.first(s__21903__$2);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21927,(0),null);\nvar vec__21930 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21927,(1),null);\nvar v1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21930,(0),null);\nvar v2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21930,(1),null);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v2], null),cljs$pprint$unzip_map_$_iter__21902(cljs.core.rest(s__21903__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(m);\n})())], null);\n});\ncljs.pprint.tuple_map \x3d (function cljs$pprint$tuple_map(m,v1){\n\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,(function (){var iter__5480__auto__ \x3d (function cljs$pprint$tuple_map_$_iter__21942(s__21943){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__21943__$1 \x3d s__21943;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__21943__$1);\nif(temp__5804__auto__){\nvar s__21943__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__21943__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__21943__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__21945 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__21944 \x3d (0);\nwhile(true){\nif((i__21944 \x3c size__5479__auto__)){\nvar vec__21956 \x3d cljs.core._nth(c__5478__auto__,i__21944);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21956,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21956,(1),null);\ncljs.core.chunk_append(b__21945,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [v,v1], null)], null));\n\nvar G__27849 \x3d (i__21944 + (1));\ni__21944 \x3d G__27849;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21945),cljs$pprint$tuple_map_$_iter__21942(cljs.core.chunk_rest(s__21943__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__21945),null);\n}\n} else {\nvar vec__21962 \x3d cljs.core.first(s__21943__$2);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21962,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21962,(1),null);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [v,v1], null)], null),cljs$pprint$tuple_map_$_iter__21942(cljs.core.rest(s__21943__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(m);\n})());\n});\ncljs.pprint.rtrim \x3d (function cljs$pprint$rtrim(s,c){\n\nvar len \x3d cljs.core.count(s);\nif((((len \x3e (0))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(s,(cljs.core.count(s) - (1))),c)))){\nvar n \x3d (len - (1));\nwhile(true){\nif((n \x3c (0))){\nreturn \x22\x22;\n} else {\nif((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(s,n),c)))){\nreturn cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),(n + (1)));\n} else {\nvar G__27854 \x3d (n - (1));\nn \x3d G__27854;\ncontinue;\n\n}\n}\nbreak;\n}\n} else {\nreturn s;\n}\n});\ncljs.pprint.ltrim \x3d (function cljs$pprint$ltrim(s,c){\n\nvar len \x3d cljs.core.count(s);\nif((((len \x3e (0))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(s,(0)),c)))){\nvar n \x3d (0);\nwhile(true){\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(n,len)) || ((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(s,n),c)))))){\nreturn cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,n);\n} else {\nvar G__27862 \x3d (n + (1));\nn \x3d G__27862;\ncontinue;\n}\nbreak;\n}\n} else {\nreturn s;\n}\n});\ncljs.pprint.prefix_count \x3d (function cljs$pprint$prefix_count(aseq,val){\n\nvar test \x3d ((cljs.core.coll_QMARK_(val))?cljs.core.set(val):cljs.core.PersistentHashSet.createAsIfByAssoc([val]));\nvar pos \x3d (0);\nwhile(true){\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(pos,cljs.core.count(aseq))) || (cljs.core.not((function (){var G__21991 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(aseq,pos);\nreturn (test.cljs$core$IFn$_invoke$arity$1 ? test.cljs$core$IFn$_invoke$arity$1(G__21991) : test.call(null, G__21991));\n})())))){\nreturn pos;\n} else {\nvar G__27871 \x3d (pos + (1));\npos \x3d G__27871;\ncontinue;\n}\nbreak;\n}\n});\n\n/**\n * @interface\n */\ncljs.pprint.IPrettyFlush \x3d function(){};\n\nvar cljs$pprint$IPrettyFlush$_ppflush$dyn_27872 \x3d (function (pp){\nvar x__5350__auto__ \x3d (((pp \x3d\x3d null))?null:pp);\nvar m__5351__auto__ \x3d (cljs.pprint._ppflush[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(pp) : m__5351__auto__.call(null, pp));\n} else {\nvar m__5349__auto__ \x3d (cljs.pprint._ppflush[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(pp) : m__5349__auto__.call(null, pp));\n} else {\nthrow cljs.core.missing_protocol(\x22IPrettyFlush.-ppflush\x22,pp);\n}\n}\n});\ncljs.pprint._ppflush \x3d (function cljs$pprint$_ppflush(pp){\nif((((!((pp \x3d\x3d null)))) \x26\x26 ((!((pp.cljs$pprint$IPrettyFlush$_ppflush$arity$1 \x3d\x3d null)))))){\nreturn pp.cljs$pprint$IPrettyFlush$_ppflush$arity$1(pp);\n} else {\nreturn cljs$pprint$IPrettyFlush$_ppflush$dyn_27872(pp);\n}\n});\n\ncljs.pprint._STAR_default_page_width_STAR_ \x3d (72);\ncljs.pprint.get_field \x3d (function cljs$pprint$get_field(this$,sym){\nvar G__22021 \x3d cljs.core.deref(cljs.core.deref(this$));\nreturn (sym.cljs$core$IFn$_invoke$arity$1 ? sym.cljs$core$IFn$_invoke$arity$1(G__22021) : sym.call(null, G__22021));\n});\ncljs.pprint.set_field \x3d (function cljs$pprint$set_field(this$,sym,new_val){\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,sym,new_val);\n});\ncljs.pprint.get_column \x3d (function cljs$pprint$get_column(this$){\nreturn cljs.pprint.get_field(this$,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599));\n});\ncljs.pprint.get_line \x3d (function cljs$pprint$get_line(this$){\nreturn cljs.pprint.get_field(this$,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235));\n});\ncljs.pprint.get_max_column \x3d (function cljs$pprint$get_max_column(this$){\nreturn cljs.pprint.get_field(this$,new cljs.core.Keyword(null,\x22max\x22,\x22max\x22,61366548));\n});\ncljs.pprint.set_max_column \x3d (function cljs$pprint$set_max_column(this$,new_max){\ncljs.pprint.set_field(this$,new cljs.core.Keyword(null,\x22max\x22,\x22max\x22,61366548),new_max);\n\nreturn null;\n});\ncljs.pprint.get_writer \x3d (function cljs$pprint$get_writer(this$){\nreturn cljs.pprint.get_field(this$,new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322));\n});\ncljs.pprint.c_write_char \x3d (function cljs$pprint$c_write_char(this$,c){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(c,\x22\\n\x22)){\ncljs.pprint.set_field(this$,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599),(0));\n\ncljs.pprint.set_field(this$,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),(cljs.pprint.get_field(this$,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235)) + (1)));\n} else {\ncljs.pprint.set_field(this$,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599),(cljs.pprint.get_field(this$,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599)) + (1)));\n}\n\nreturn cljs.core._write(cljs.pprint.get_field(this$,new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322)),c);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IDeref}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.pprint.t_cljs$pprint22133 \x3d (function (writer,max_columns,fields,meta22134){\nthis.writer \x3d writer;\nthis.max_columns \x3d max_columns;\nthis.fields \x3d fields;\nthis.meta22134 \x3d meta22134;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1074167808;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.pprint.t_cljs$pprint22133.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_22135,meta22134__$1){\nvar self__ \x3d this;\nvar _22135__$1 \x3d this;\nreturn (new cljs.pprint.t_cljs$pprint22133(self__.writer,self__.max_columns,self__.fields,meta22134__$1));\n}));\n\n(cljs.pprint.t_cljs$pprint22133.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_22135){\nvar self__ \x3d this;\nvar _22135__$1 \x3d this;\nreturn self__.meta22134;\n}));\n\n(cljs.pprint.t_cljs$pprint22133.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.fields;\n}));\n\n(cljs.pprint.t_cljs$pprint22133.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core._flush(self__.writer);\n}));\n\n(cljs.pprint.t_cljs$pprint22133.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (this$,x){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar pred__22151 \x3d cljs.core._EQ_;\nvar expr__22152 \x3d cljs.core.type(x);\nif(cljs.core.truth_((pred__22151.cljs$core$IFn$_invoke$arity$2 ? pred__22151.cljs$core$IFn$_invoke$arity$2(String,expr__22152) : pred__22151.call(null, String,expr__22152)))){\nvar s \x3d x;\nvar nl \x3d s.lastIndexOf(\x22\\n\x22);\nif((nl \x3c (0))){\ncljs.pprint.set_field(this$__$1,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599),(cljs.pprint.get_field(this$__$1,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599)) + cljs.core.count(s)));\n} else {\ncljs.pprint.set_field(this$__$1,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599),((cljs.core.count(s) - nl) - (1)));\n\ncljs.pprint.set_field(this$__$1,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),(cljs.pprint.get_field(this$__$1,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235)) + cljs.core.count(cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__22117_SHARP_){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(p1__22117_SHARP_,\x22\\n\x22);\n}),s))));\n}\n\nreturn cljs.core._write(cljs.pprint.get_field(this$__$1,new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322)),s);\n} else {\nif(cljs.core.truth_((pred__22151.cljs$core$IFn$_invoke$arity$2 ? pred__22151.cljs$core$IFn$_invoke$arity$2(Number,expr__22152) : pred__22151.call(null, Number,expr__22152)))){\nreturn cljs.pprint.c_write_char(this$__$1,x);\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__22152)].join(\x27\x27)));\n}\n}\n}));\n\n(cljs.pprint.t_cljs$pprint22133.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22writer\x22,\x22writer\x22,1362963291,null),new cljs.core.Symbol(null,\x22max-columns\x22,\x22max-columns\x22,-912112507,null),new cljs.core.Symbol(null,\x22fields\x22,\x22fields\x22,-291534703,null),new cljs.core.Symbol(null,\x22meta22134\x22,\x22meta22134\x22,-1816874053,null)], null);\n}));\n\n(cljs.pprint.t_cljs$pprint22133.cljs$lang$type \x3d true);\n\n(cljs.pprint.t_cljs$pprint22133.cljs$lang$ctorStr \x3d \x22cljs.pprint/t_cljs$pprint22133\x22);\n\n(cljs.pprint.t_cljs$pprint22133.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.pprint/t_cljs$pprint22133\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/t_cljs$pprint22133.\n */\ncljs.pprint.__GT_t_cljs$pprint22133 \x3d (function cljs$pprint$__GT_t_cljs$pprint22133(writer,max_columns,fields,meta22134){\nreturn (new cljs.pprint.t_cljs$pprint22133(writer,max_columns,fields,meta22134));\n});\n\n\ncljs.pprint.column_writer \x3d (function cljs$pprint$column_writer(var_args){\nvar G__22127 \x3d arguments.length;\nswitch (G__22127) {\ncase 1:\nreturn cljs.pprint.column_writer.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.pprint.column_writer.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.pprint.column_writer.cljs$core$IFn$_invoke$arity$1 \x3d (function (writer){\nreturn cljs.pprint.column_writer.cljs$core$IFn$_invoke$arity$2(writer,cljs.pprint._STAR_default_page_width_STAR_);\n}));\n\n(cljs.pprint.column_writer.cljs$core$IFn$_invoke$arity$2 \x3d (function (writer,max_columns){\nvar fields \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22max\x22,\x22max\x22,61366548),max_columns,new cljs.core.Keyword(null,\x22cur\x22,\x22cur\x22,1153190599),(0),new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),(0),new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322),writer], null));\nreturn (new cljs.pprint.t_cljs$pprint22133(writer,max_columns,fields,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(cljs.pprint.column_writer.cljs$lang$maxFixedArity \x3d 2);\n\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.logical_block \x3d (function (parent,section,start_col,indent,done_nl,intra_block_nl,prefix,per_line_prefix,suffix,logical_block_callback,__meta,__extmap,__hash){\nthis.parent \x3d parent;\nthis.section \x3d section;\nthis.start_col \x3d start_col;\nthis.indent \x3d indent;\nthis.done_nl \x3d done_nl;\nthis.intra_block_nl \x3d intra_block_nl;\nthis.prefix \x3d prefix;\nthis.per_line_prefix \x3d per_line_prefix;\nthis.suffix \x3d suffix;\nthis.logical_block_callback \x3d logical_block_callback;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.logical_block.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k22201,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__22276 \x3d k22201;\nvar G__22276__$1 \x3d (((G__22276 instanceof cljs.core.Keyword))?G__22276.fqn:null);\nswitch (G__22276__$1) {\ncase \x22parent\x22:\nreturn self__.parent;\n\nbreak;\ncase \x22section\x22:\nreturn self__.section;\n\nbreak;\ncase \x22start-col\x22:\nreturn self__.start_col;\n\nbreak;\ncase \x22indent\x22:\nreturn self__.indent;\n\nbreak;\ncase \x22done-nl\x22:\nreturn self__.done_nl;\n\nbreak;\ncase \x22intra-block-nl\x22:\nreturn self__.intra_block_nl;\n\nbreak;\ncase \x22prefix\x22:\nreturn self__.prefix;\n\nbreak;\ncase \x22per-line-prefix\x22:\nreturn self__.per_line_prefix;\n\nbreak;\ncase \x22suffix\x22:\nreturn self__.suffix;\n\nbreak;\ncase \x22logical-block-callback\x22:\nreturn self__.logical_block_callback;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k22201,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__22287){\nvar vec__22289 \x3d p__22287;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22289,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22289,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.logical-block{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 10, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),self__.parent],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),self__.section],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143),self__.start_col],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125),self__.indent],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340),self__.done_nl],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875),self__.intra_block_nl],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465),self__.prefix],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813),self__.per_line_prefix],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057),self__.suffix],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194),self__.logical_block_callback],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__22200){\nvar self__ \x3d this;\nvar G__22200__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__22200__$1,10,new cljs.core.PersistentVector(null, 10, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143),new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125),new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340),new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875),new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465),new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813),new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057),new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (10 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (1977012399 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this22202,other22203){\nvar self__ \x3d this;\nvar this22202__$1 \x3d this;\nreturn (((!((other22203 \x3d\x3d null)))) \x26\x26 ((((this22202__$1.constructor \x3d\x3d\x3d other22203.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.parent,other22203.parent)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.section,other22203.section)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.start_col,other22203.start_col)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.indent,other22203.indent)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.done_nl,other22203.done_nl)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.intra_block_nl,other22203.intra_block_nl)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.prefix,other22203.prefix)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.per_line_prefix,other22203.per_line_prefix)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.suffix,other22203.suffix)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.logical_block_callback,other22203.logical_block_callback)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22202__$1.__extmap,other22203.__extmap)))))))))))))))))))))))));\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 10, [new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057),null,new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125),null,new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),null,new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),null,new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340),null,new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143),null,new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465),null,new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813),null,new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194),null,new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k22201){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__22363 \x3d k22201;\nvar G__22363__$1 \x3d (((G__22363 instanceof cljs.core.Keyword))?G__22363.fqn:null);\nswitch (G__22363__$1) {\ncase \x22parent\x22:\ncase \x22section\x22:\ncase \x22start-col\x22:\ncase \x22indent\x22:\ncase \x22done-nl\x22:\ncase \x22intra-block-nl\x22:\ncase \x22prefix\x22:\ncase \x22per-line-prefix\x22:\ncase \x22suffix\x22:\ncase \x22logical-block-callback\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k22201);\n\n}\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__22200){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__22365 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__22366 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),expr__22366)))){\nreturn (new cljs.pprint.logical_block(G__22200,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,G__22200,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,G__22200,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,G__22200,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,G__22200,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,G__22200,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,G__22200,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,G__22200,self__.suffix,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,G__22200,self__.logical_block_callback,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22365.cljs$core$IFn$_invoke$arity$2 ? pred__22365.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194),expr__22366) : pred__22365.call(null, new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194),expr__22366)))){\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,G__22200,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__22200),null));\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 10, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),self__.parent,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),self__.section,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143),self__.start_col,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125),self__.indent,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340),self__.done_nl,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875),self__.intra_block_nl,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465),self__.prefix,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813),self__.per_line_prefix,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057),self__.suffix,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194),self__.logical_block_callback,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__22200){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.logical_block(self__.parent,self__.section,self__.start_col,self__.indent,self__.done_nl,self__.intra_block_nl,self__.prefix,self__.per_line_prefix,self__.suffix,self__.logical_block_callback,G__22200,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.logical_block.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.logical_block.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 10, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22parent\x22,\x22parent\x22,761652748,null),new cljs.core.Symbol(null,\x22section\x22,\x22section\x22,1340390001,null),new cljs.core.Symbol(null,\x22start-col\x22,\x22start-col\x22,-1986355626,null),new cljs.core.Symbol(null,\x22indent\x22,\x22indent\x22,1492331402,null),new cljs.core.Symbol(null,\x22done-nl\x22,\x22done-nl\x22,1259507187,null),new cljs.core.Symbol(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,-845608894,null),new cljs.core.Symbol(null,\x22prefix\x22,\x22prefix\x22,1374623062,null),new cljs.core.Symbol(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,-1807493956,null),new cljs.core.Symbol(null,\x22suffix\x22,\x22suffix\x22,2007904584,null),new cljs.core.Symbol(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,-1041744575,null)], null);\n}));\n\n(cljs.pprint.logical_block.cljs$lang$type \x3d true);\n\n(cljs.pprint.logical_block.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/logical-block\x22,null,(1),null));\n}));\n\n(cljs.pprint.logical_block.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/logical-block\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/logical-block.\n */\ncljs.pprint.__GT_logical_block \x3d (function cljs$pprint$__GT_logical_block(parent,section,start_col,indent,done_nl,intra_block_nl,prefix,per_line_prefix,suffix,logical_block_callback){\nreturn (new cljs.pprint.logical_block(parent,section,start_col,indent,done_nl,intra_block_nl,prefix,per_line_prefix,suffix,logical_block_callback,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/logical-block, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_logical_block \x3d (function cljs$pprint$map__GT_logical_block(G__22245){\nvar extmap__5342__auto__ \x3d (function (){var G__22392 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__22245,new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143),new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125),new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340),new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875),new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465),new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813),new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057),new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194)], 0));\nif(cljs.core.record_QMARK_(G__22245)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__22392);\n} else {\nreturn G__22392;\n}\n})();\nreturn (new cljs.pprint.logical_block(new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057).cljs$core$IFn$_invoke$arity$1(G__22245),new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194).cljs$core$IFn$_invoke$arity$1(G__22245),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\ncljs.pprint.ancestor_QMARK_ \x3d (function cljs$pprint$ancestor_QMARK_(parent,child){\nvar child__$1 \x3d new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(child);\nwhile(true){\nif((child__$1 \x3d\x3d null)){\nreturn false;\n} else {\nif((parent \x3d\x3d\x3d child__$1)){\nreturn true;\n} else {\nvar G__27938 \x3d new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(child__$1);\nchild__$1 \x3d G__27938;\ncontinue;\n\n}\n}\nbreak;\n}\n});\ncljs.pprint.buffer_length \x3d (function cljs$pprint$buffer_length(l){\nvar l__$1 \x3d cljs.core.seq(l);\nif(l__$1){\nreturn (new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926).cljs$core$IFn$_invoke$arity$1(cljs.core.last(l__$1)) - new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086).cljs$core$IFn$_invoke$arity$1(cljs.core.first(l__$1)));\n} else {\nreturn (0);\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.buffer_blob \x3d (function (type_tag,data,trailing_white_space,start_pos,end_pos,__meta,__extmap,__hash){\nthis.type_tag \x3d type_tag;\nthis.data \x3d data;\nthis.trailing_white_space \x3d trailing_white_space;\nthis.start_pos \x3d start_pos;\nthis.end_pos \x3d end_pos;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.buffer_blob.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k22411,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__22425 \x3d k22411;\nvar G__22425__$1 \x3d (((G__22425 instanceof cljs.core.Keyword))?G__22425.fqn:null);\nswitch (G__22425__$1) {\ncase \x22type-tag\x22:\nreturn self__.type_tag;\n\nbreak;\ncase \x22data\x22:\nreturn self__.data;\n\nbreak;\ncase \x22trailing-white-space\x22:\nreturn self__.trailing_white_space;\n\nbreak;\ncase \x22start-pos\x22:\nreturn self__.start_pos;\n\nbreak;\ncase \x22end-pos\x22:\nreturn self__.end_pos;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k22411,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__22433){\nvar vec__22434 \x3d p__22433;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22434,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22434,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.buffer-blob{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),self__.data],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),self__.trailing_white_space],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__22410){\nvar self__ \x3d this;\nvar G__22410__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__22410__$1,5,new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,self__.data,self__.trailing_white_space,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (5 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (1809113693 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this22412,other22413){\nvar self__ \x3d this;\nvar this22412__$1 \x3d this;\nreturn (((!((other22413 \x3d\x3d null)))) \x26\x26 ((((this22412__$1.constructor \x3d\x3d\x3d other22413.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22412__$1.type_tag,other22413.type_tag)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22412__$1.data,other22413.data)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22412__$1.trailing_white_space,other22413.trailing_white_space)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22412__$1.start_pos,other22413.start_pos)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22412__$1.end_pos,other22413.end_pos)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22412__$1.__extmap,other22413.__extmap)))))))))))))));\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),null,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),null,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),null,new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),null,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,self__.data,self__.trailing_white_space,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k22411){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__22567 \x3d k22411;\nvar G__22567__$1 \x3d (((G__22567 instanceof cljs.core.Keyword))?G__22567.fqn:null);\nswitch (G__22567__$1) {\ncase \x22type-tag\x22:\ncase \x22data\x22:\ncase \x22trailing-white-space\x22:\ncase \x22start-pos\x22:\ncase \x22end-pos\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k22411);\n\n}\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__22410){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__22575 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__22576 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__22575.cljs$core$IFn$_invoke$arity$2 ? pred__22575.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__22576) : pred__22575.call(null, new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__22576)))){\nreturn (new cljs.pprint.buffer_blob(G__22410,self__.data,self__.trailing_white_space,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22575.cljs$core$IFn$_invoke$arity$2 ? pred__22575.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),expr__22576) : pred__22575.call(null, new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),expr__22576)))){\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,G__22410,self__.trailing_white_space,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22575.cljs$core$IFn$_invoke$arity$2 ? pred__22575.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),expr__22576) : pred__22575.call(null, new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),expr__22576)))){\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,self__.data,G__22410,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22575.cljs$core$IFn$_invoke$arity$2 ? pred__22575.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__22576) : pred__22575.call(null, new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__22576)))){\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,self__.data,self__.trailing_white_space,G__22410,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22575.cljs$core$IFn$_invoke$arity$2 ? pred__22575.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__22576) : pred__22575.call(null, new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__22576)))){\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,self__.data,self__.trailing_white_space,self__.start_pos,G__22410,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,self__.data,self__.trailing_white_space,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__22410),null));\n}\n}\n}\n}\n}\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),self__.data,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),self__.trailing_white_space,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__22410){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.buffer_blob(self__.type_tag,self__.data,self__.trailing_white_space,self__.start_pos,self__.end_pos,G__22410,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.buffer_blob.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.buffer_blob.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22type-tag\x22,\x22type-tag\x22,-233331740,null),new cljs.core.Symbol(null,\x22data\x22,\x22data\x22,1407862150,null),new cljs.core.Symbol(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,-1158428773,null),new cljs.core.Symbol(null,\x22start-pos\x22,\x22start-pos\x22,-1985646683,null),new cljs.core.Symbol(null,\x22end-pos\x22,\x22end-pos\x22,-3352399,null)], null);\n}));\n\n(cljs.pprint.buffer_blob.cljs$lang$type \x3d true);\n\n(cljs.pprint.buffer_blob.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/buffer-blob\x22,null,(1),null));\n}));\n\n(cljs.pprint.buffer_blob.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/buffer-blob\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/buffer-blob.\n */\ncljs.pprint.__GT_buffer_blob \x3d (function cljs$pprint$__GT_buffer_blob(type_tag,data,trailing_white_space,start_pos,end_pos){\nreturn (new cljs.pprint.buffer_blob(type_tag,data,trailing_white_space,start_pos,end_pos,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/buffer-blob, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_buffer_blob \x3d (function cljs$pprint$map__GT_buffer_blob(G__22417){\nvar extmap__5342__auto__ \x3d (function (){var G__22646 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__22417,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], 0));\nif(cljs.core.record_QMARK_(G__22417)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__22646);\n} else {\nreturn G__22646;\n}\n})();\nreturn (new cljs.pprint.buffer_blob(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(G__22417),new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377).cljs$core$IFn$_invoke$arity$1(G__22417),new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(G__22417),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086).cljs$core$IFn$_invoke$arity$1(G__22417),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926).cljs$core$IFn$_invoke$arity$1(G__22417),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\n\ncljs.pprint.make_buffer_blob \x3d (function cljs$pprint$make_buffer_blob(data,trailing_white_space,start_pos,end_pos){\nreturn (new cljs.pprint.buffer_blob(new cljs.core.Keyword(null,\x22buffer-blob\x22,\x22buffer-blob\x22,-1830112173),data,trailing_white_space,start_pos,end_pos,null,null,null));\n});\n\ncljs.pprint.buffer_blob_QMARK_ \x3d (function cljs$pprint$buffer_blob_QMARK_(x__21635__auto__){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(x__21635__auto__),new cljs.core.Keyword(null,\x22buffer-blob\x22,\x22buffer-blob\x22,-1830112173));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.nl_t \x3d (function (type_tag,type,logical_block,start_pos,end_pos,__meta,__extmap,__hash){\nthis.type_tag \x3d type_tag;\nthis.type \x3d type;\nthis.logical_block \x3d logical_block;\nthis.start_pos \x3d start_pos;\nthis.end_pos \x3d end_pos;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.nl_t.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k22677,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__22707 \x3d k22677;\nvar G__22707__$1 \x3d (((G__22707 instanceof cljs.core.Keyword))?G__22707.fqn:null);\nswitch (G__22707__$1) {\ncase \x22type-tag\x22:\nreturn self__.type_tag;\n\nbreak;\ncase \x22type\x22:\nreturn self__.type;\n\nbreak;\ncase \x22logical-block\x22:\nreturn self__.logical_block;\n\nbreak;\ncase \x22start-pos\x22:\nreturn self__.start_pos;\n\nbreak;\ncase \x22end-pos\x22:\nreturn self__.end_pos;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k22677,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__22723){\nvar vec__22724 \x3d p__22723;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22724,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22724,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.nl-t{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),self__.type],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__22676){\nvar self__ \x3d this;\nvar G__22676__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__22676__$1,5,new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.nl_t(self__.type_tag,self__.type,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (5 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (-1640656800 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this22678,other22679){\nvar self__ \x3d this;\nvar this22678__$1 \x3d this;\nreturn (((!((other22679 \x3d\x3d null)))) \x26\x26 ((((this22678__$1.constructor \x3d\x3d\x3d other22679.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22678__$1.type_tag,other22679.type_tag)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22678__$1.type,other22679.type)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22678__$1.logical_block,other22679.logical_block)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22678__$1.start_pos,other22679.start_pos)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22678__$1.end_pos,other22679.end_pos)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22678__$1.__extmap,other22679.__extmap)))))))))))))));\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),null,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),null,new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),null,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),null,new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.nl_t(self__.type_tag,self__.type,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k22677){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__22754 \x3d k22677;\nvar G__22754__$1 \x3d (((G__22754 instanceof cljs.core.Keyword))?G__22754.fqn:null);\nswitch (G__22754__$1) {\ncase \x22type-tag\x22:\ncase \x22type\x22:\ncase \x22logical-block\x22:\ncase \x22start-pos\x22:\ncase \x22end-pos\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k22677);\n\n}\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__22676){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__22759 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__22760 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__22759.cljs$core$IFn$_invoke$arity$2 ? pred__22759.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__22760) : pred__22759.call(null, new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__22760)))){\nreturn (new cljs.pprint.nl_t(G__22676,self__.type,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22759.cljs$core$IFn$_invoke$arity$2 ? pred__22759.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),expr__22760) : pred__22759.call(null, new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),expr__22760)))){\nreturn (new cljs.pprint.nl_t(self__.type_tag,G__22676,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22759.cljs$core$IFn$_invoke$arity$2 ? pred__22759.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__22760) : pred__22759.call(null, new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__22760)))){\nreturn (new cljs.pprint.nl_t(self__.type_tag,self__.type,G__22676,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22759.cljs$core$IFn$_invoke$arity$2 ? pred__22759.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__22760) : pred__22759.call(null, new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__22760)))){\nreturn (new cljs.pprint.nl_t(self__.type_tag,self__.type,self__.logical_block,G__22676,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22759.cljs$core$IFn$_invoke$arity$2 ? pred__22759.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__22760) : pred__22759.call(null, new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__22760)))){\nreturn (new cljs.pprint.nl_t(self__.type_tag,self__.type,self__.logical_block,self__.start_pos,G__22676,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.nl_t(self__.type_tag,self__.type,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__22676),null));\n}\n}\n}\n}\n}\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),self__.type,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__22676){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.nl_t(self__.type_tag,self__.type,self__.logical_block,self__.start_pos,self__.end_pos,G__22676,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.nl_t.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.nl_t.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22type-tag\x22,\x22type-tag\x22,-233331740,null),new cljs.core.Symbol(null,\x22type\x22,\x22type\x22,-1480165421,null),new cljs.core.Symbol(null,\x22logical-block\x22,\x22logical-block\x22,1059508963,null),new cljs.core.Symbol(null,\x22start-pos\x22,\x22start-pos\x22,-1985646683,null),new cljs.core.Symbol(null,\x22end-pos\x22,\x22end-pos\x22,-3352399,null)], null);\n}));\n\n(cljs.pprint.nl_t.cljs$lang$type \x3d true);\n\n(cljs.pprint.nl_t.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/nl-t\x22,null,(1),null));\n}));\n\n(cljs.pprint.nl_t.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/nl-t\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/nl-t.\n */\ncljs.pprint.__GT_nl_t \x3d (function cljs$pprint$__GT_nl_t(type_tag,type,logical_block,start_pos,end_pos){\nreturn (new cljs.pprint.nl_t(type_tag,type,logical_block,start_pos,end_pos,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/nl-t, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_nl_t \x3d (function cljs$pprint$map__GT_nl_t(G__22683){\nvar extmap__5342__auto__ \x3d (function (){var G__22774 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__22683,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], 0));\nif(cljs.core.record_QMARK_(G__22683)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__22774);\n} else {\nreturn G__22774;\n}\n})();\nreturn (new cljs.pprint.nl_t(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(G__22683),new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348).cljs$core$IFn$_invoke$arity$1(G__22683),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(G__22683),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086).cljs$core$IFn$_invoke$arity$1(G__22683),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926).cljs$core$IFn$_invoke$arity$1(G__22683),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\n\ncljs.pprint.make_nl_t \x3d (function cljs$pprint$make_nl_t(type,logical_block,start_pos,end_pos){\nreturn (new cljs.pprint.nl_t(new cljs.core.Keyword(null,\x22nl-t\x22,\x22nl-t\x22,-1608382114),type,logical_block,start_pos,end_pos,null,null,null));\n});\n\ncljs.pprint.nl_t_QMARK_ \x3d (function cljs$pprint$nl_t_QMARK_(x__21635__auto__){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(x__21635__auto__),new cljs.core.Keyword(null,\x22nl-t\x22,\x22nl-t\x22,-1608382114));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.start_block_t \x3d (function (type_tag,logical_block,start_pos,end_pos,__meta,__extmap,__hash){\nthis.type_tag \x3d type_tag;\nthis.logical_block \x3d logical_block;\nthis.start_pos \x3d start_pos;\nthis.end_pos \x3d end_pos;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.start_block_t.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k22781,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__22789 \x3d k22781;\nvar G__22789__$1 \x3d (((G__22789 instanceof cljs.core.Keyword))?G__22789.fqn:null);\nswitch (G__22789__$1) {\ncase \x22type-tag\x22:\nreturn self__.type_tag;\n\nbreak;\ncase \x22logical-block\x22:\nreturn self__.logical_block;\n\nbreak;\ncase \x22start-pos\x22:\nreturn self__.start_pos;\n\nbreak;\ncase \x22end-pos\x22:\nreturn self__.end_pos;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k22781,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__22795){\nvar vec__22797 \x3d p__22795;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22797,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22797,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.start-block-t{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__22780){\nvar self__ \x3d this;\nvar G__22780__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__22780__$1,4,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.start_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (4 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (-414877272 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this22782,other22783){\nvar self__ \x3d this;\nvar this22782__$1 \x3d this;\nreturn (((!((other22783 \x3d\x3d null)))) \x26\x26 ((((this22782__$1.constructor \x3d\x3d\x3d other22783.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22782__$1.type_tag,other22783.type_tag)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22782__$1.logical_block,other22783.logical_block)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22782__$1.start_pos,other22783.start_pos)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22782__$1.end_pos,other22783.end_pos)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22782__$1.__extmap,other22783.__extmap)))))))))))));\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),null,new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),null,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),null,new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.start_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k22781){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__22850 \x3d k22781;\nvar G__22850__$1 \x3d (((G__22850 instanceof cljs.core.Keyword))?G__22850.fqn:null);\nswitch (G__22850__$1) {\ncase \x22type-tag\x22:\ncase \x22logical-block\x22:\ncase \x22start-pos\x22:\ncase \x22end-pos\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k22781);\n\n}\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__22780){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__22854 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__22855 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__22854.cljs$core$IFn$_invoke$arity$2 ? pred__22854.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__22855) : pred__22854.call(null, new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__22855)))){\nreturn (new cljs.pprint.start_block_t(G__22780,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22854.cljs$core$IFn$_invoke$arity$2 ? pred__22854.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__22855) : pred__22854.call(null, new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__22855)))){\nreturn (new cljs.pprint.start_block_t(self__.type_tag,G__22780,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22854.cljs$core$IFn$_invoke$arity$2 ? pred__22854.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__22855) : pred__22854.call(null, new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__22855)))){\nreturn (new cljs.pprint.start_block_t(self__.type_tag,self__.logical_block,G__22780,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__22854.cljs$core$IFn$_invoke$arity$2 ? pred__22854.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__22855) : pred__22854.call(null, new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__22855)))){\nreturn (new cljs.pprint.start_block_t(self__.type_tag,self__.logical_block,self__.start_pos,G__22780,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.start_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__22780),null));\n}\n}\n}\n}\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__22780){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.start_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,G__22780,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.start_block_t.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.start_block_t.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22type-tag\x22,\x22type-tag\x22,-233331740,null),new cljs.core.Symbol(null,\x22logical-block\x22,\x22logical-block\x22,1059508963,null),new cljs.core.Symbol(null,\x22start-pos\x22,\x22start-pos\x22,-1985646683,null),new cljs.core.Symbol(null,\x22end-pos\x22,\x22end-pos\x22,-3352399,null)], null);\n}));\n\n(cljs.pprint.start_block_t.cljs$lang$type \x3d true);\n\n(cljs.pprint.start_block_t.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/start-block-t\x22,null,(1),null));\n}));\n\n(cljs.pprint.start_block_t.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/start-block-t\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/start-block-t.\n */\ncljs.pprint.__GT_start_block_t \x3d (function cljs$pprint$__GT_start_block_t(type_tag,logical_block,start_pos,end_pos){\nreturn (new cljs.pprint.start_block_t(type_tag,logical_block,start_pos,end_pos,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/start-block-t, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_start_block_t \x3d (function cljs$pprint$map__GT_start_block_t(G__22788){\nvar extmap__5342__auto__ \x3d (function (){var G__22895 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__22788,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], 0));\nif(cljs.core.record_QMARK_(G__22788)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__22895);\n} else {\nreturn G__22895;\n}\n})();\nreturn (new cljs.pprint.start_block_t(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(G__22788),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(G__22788),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086).cljs$core$IFn$_invoke$arity$1(G__22788),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926).cljs$core$IFn$_invoke$arity$1(G__22788),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\n\ncljs.pprint.make_start_block_t \x3d (function cljs$pprint$make_start_block_t(logical_block,start_pos,end_pos){\nreturn (new cljs.pprint.start_block_t(new cljs.core.Keyword(null,\x22start-block-t\x22,\x22start-block-t\x22,-373430594),logical_block,start_pos,end_pos,null,null,null));\n});\n\ncljs.pprint.start_block_t_QMARK_ \x3d (function cljs$pprint$start_block_t_QMARK_(x__21635__auto__){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(x__21635__auto__),new cljs.core.Keyword(null,\x22start-block-t\x22,\x22start-block-t\x22,-373430594));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.end_block_t \x3d (function (type_tag,logical_block,start_pos,end_pos,__meta,__extmap,__hash){\nthis.type_tag \x3d type_tag;\nthis.logical_block \x3d logical_block;\nthis.start_pos \x3d start_pos;\nthis.end_pos \x3d end_pos;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.end_block_t.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k22915,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__22938 \x3d k22915;\nvar G__22938__$1 \x3d (((G__22938 instanceof cljs.core.Keyword))?G__22938.fqn:null);\nswitch (G__22938__$1) {\ncase \x22type-tag\x22:\nreturn self__.type_tag;\n\nbreak;\ncase \x22logical-block\x22:\nreturn self__.logical_block;\n\nbreak;\ncase \x22start-pos\x22:\nreturn self__.start_pos;\n\nbreak;\ncase \x22end-pos\x22:\nreturn self__.end_pos;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k22915,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__22943){\nvar vec__22944 \x3d p__22943;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22944,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__22944,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.end-block-t{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__22914){\nvar self__ \x3d this;\nvar G__22914__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__22914__$1,4,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.end_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (4 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (1365867980 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this22916,other22917){\nvar self__ \x3d this;\nvar this22916__$1 \x3d this;\nreturn (((!((other22917 \x3d\x3d null)))) \x26\x26 ((((this22916__$1.constructor \x3d\x3d\x3d other22917.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22916__$1.type_tag,other22917.type_tag)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22916__$1.logical_block,other22917.logical_block)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22916__$1.start_pos,other22917.start_pos)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22916__$1.end_pos,other22917.end_pos)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this22916__$1.__extmap,other22917.__extmap)))))))))))));\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),null,new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),null,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),null,new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.end_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k22915){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__23011 \x3d k22915;\nvar G__23011__$1 \x3d (((G__23011 instanceof cljs.core.Keyword))?G__23011.fqn:null);\nswitch (G__23011__$1) {\ncase \x22type-tag\x22:\ncase \x22logical-block\x22:\ncase \x22start-pos\x22:\ncase \x22end-pos\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k22915);\n\n}\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__22914){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__23015 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__23016 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__23015.cljs$core$IFn$_invoke$arity$2 ? pred__23015.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__23016) : pred__23015.call(null, new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__23016)))){\nreturn (new cljs.pprint.end_block_t(G__22914,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23015.cljs$core$IFn$_invoke$arity$2 ? pred__23015.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__23016) : pred__23015.call(null, new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__23016)))){\nreturn (new cljs.pprint.end_block_t(self__.type_tag,G__22914,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23015.cljs$core$IFn$_invoke$arity$2 ? pred__23015.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__23016) : pred__23015.call(null, new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__23016)))){\nreturn (new cljs.pprint.end_block_t(self__.type_tag,self__.logical_block,G__22914,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23015.cljs$core$IFn$_invoke$arity$2 ? pred__23015.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__23016) : pred__23015.call(null, new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__23016)))){\nreturn (new cljs.pprint.end_block_t(self__.type_tag,self__.logical_block,self__.start_pos,G__22914,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.end_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__22914),null));\n}\n}\n}\n}\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__22914){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.end_block_t(self__.type_tag,self__.logical_block,self__.start_pos,self__.end_pos,G__22914,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.end_block_t.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.end_block_t.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22type-tag\x22,\x22type-tag\x22,-233331740,null),new cljs.core.Symbol(null,\x22logical-block\x22,\x22logical-block\x22,1059508963,null),new cljs.core.Symbol(null,\x22start-pos\x22,\x22start-pos\x22,-1985646683,null),new cljs.core.Symbol(null,\x22end-pos\x22,\x22end-pos\x22,-3352399,null)], null);\n}));\n\n(cljs.pprint.end_block_t.cljs$lang$type \x3d true);\n\n(cljs.pprint.end_block_t.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/end-block-t\x22,null,(1),null));\n}));\n\n(cljs.pprint.end_block_t.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/end-block-t\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/end-block-t.\n */\ncljs.pprint.__GT_end_block_t \x3d (function cljs$pprint$__GT_end_block_t(type_tag,logical_block,start_pos,end_pos){\nreturn (new cljs.pprint.end_block_t(type_tag,logical_block,start_pos,end_pos,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/end-block-t, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_end_block_t \x3d (function cljs$pprint$map__GT_end_block_t(G__22925){\nvar extmap__5342__auto__ \x3d (function (){var G__23045 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__22925,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], 0));\nif(cljs.core.record_QMARK_(G__22925)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__23045);\n} else {\nreturn G__23045;\n}\n})();\nreturn (new cljs.pprint.end_block_t(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(G__22925),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(G__22925),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086).cljs$core$IFn$_invoke$arity$1(G__22925),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926).cljs$core$IFn$_invoke$arity$1(G__22925),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\n\ncljs.pprint.make_end_block_t \x3d (function cljs$pprint$make_end_block_t(logical_block,start_pos,end_pos){\nreturn (new cljs.pprint.end_block_t(new cljs.core.Keyword(null,\x22end-block-t\x22,\x22end-block-t\x22,1544648735),logical_block,start_pos,end_pos,null,null,null));\n});\n\ncljs.pprint.end_block_t_QMARK_ \x3d (function cljs$pprint$end_block_t_QMARK_(x__21635__auto__){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(x__21635__auto__),new cljs.core.Keyword(null,\x22end-block-t\x22,\x22end-block-t\x22,1544648735));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.indent_t \x3d (function (type_tag,logical_block,relative_to,offset,start_pos,end_pos,__meta,__extmap,__hash){\nthis.type_tag \x3d type_tag;\nthis.logical_block \x3d logical_block;\nthis.relative_to \x3d relative_to;\nthis.offset \x3d offset;\nthis.start_pos \x3d start_pos;\nthis.end_pos \x3d end_pos;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.indent_t.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k23069,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__23099 \x3d k23069;\nvar G__23099__$1 \x3d (((G__23099 instanceof cljs.core.Keyword))?G__23099.fqn:null);\nswitch (G__23099__$1) {\ncase \x22type-tag\x22:\nreturn self__.type_tag;\n\nbreak;\ncase \x22logical-block\x22:\nreturn self__.logical_block;\n\nbreak;\ncase \x22relative-to\x22:\nreturn self__.relative_to;\n\nbreak;\ncase \x22offset\x22:\nreturn self__.offset;\n\nbreak;\ncase \x22start-pos\x22:\nreturn self__.start_pos;\n\nbreak;\ncase \x22end-pos\x22:\nreturn self__.end_pos;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k23069,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__23118){\nvar vec__23121 \x3d p__23118;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23121,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23121,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.indent-t{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051),self__.relative_to],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),self__.offset],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__23068){\nvar self__ \x3d this;\nvar G__23068__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__23068__$1,6,new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,self__.relative_to,self__.offset,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (6 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (-1602780238 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this23070,other23071){\nvar self__ \x3d this;\nvar this23070__$1 \x3d this;\nreturn (((!((other23071 \x3d\x3d null)))) \x26\x26 ((((this23070__$1.constructor \x3d\x3d\x3d other23071.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this23070__$1.type_tag,other23071.type_tag)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this23070__$1.logical_block,other23071.logical_block)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this23070__$1.relative_to,other23071.relative_to)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this23070__$1.offset,other23071.offset)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this23070__$1.start_pos,other23071.start_pos)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this23070__$1.end_pos,other23071.end_pos)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this23070__$1.__extmap,other23071.__extmap)))))))))))))))));\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),null,new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),null,new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051),null,new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),null,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),null,new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,self__.relative_to,self__.offset,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k23069){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__23221 \x3d k23069;\nvar G__23221__$1 \x3d (((G__23221 instanceof cljs.core.Keyword))?G__23221.fqn:null);\nswitch (G__23221__$1) {\ncase \x22type-tag\x22:\ncase \x22logical-block\x22:\ncase \x22relative-to\x22:\ncase \x22offset\x22:\ncase \x22start-pos\x22:\ncase \x22end-pos\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k23069);\n\n}\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__23068){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__23239 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__23240 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__23239.cljs$core$IFn$_invoke$arity$2 ? pred__23239.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__23240) : pred__23239.call(null, new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),expr__23240)))){\nreturn (new cljs.pprint.indent_t(G__23068,self__.logical_block,self__.relative_to,self__.offset,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23239.cljs$core$IFn$_invoke$arity$2 ? pred__23239.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__23240) : pred__23239.call(null, new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),expr__23240)))){\nreturn (new cljs.pprint.indent_t(self__.type_tag,G__23068,self__.relative_to,self__.offset,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23239.cljs$core$IFn$_invoke$arity$2 ? pred__23239.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051),expr__23240) : pred__23239.call(null, new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051),expr__23240)))){\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,G__23068,self__.offset,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23239.cljs$core$IFn$_invoke$arity$2 ? pred__23239.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),expr__23240) : pred__23239.call(null, new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),expr__23240)))){\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,self__.relative_to,G__23068,self__.start_pos,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23239.cljs$core$IFn$_invoke$arity$2 ? pred__23239.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__23240) : pred__23239.call(null, new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),expr__23240)))){\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,self__.relative_to,self__.offset,G__23068,self__.end_pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__23239.cljs$core$IFn$_invoke$arity$2 ? pred__23239.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__23240) : pred__23239.call(null, new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),expr__23240)))){\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,self__.relative_to,self__.offset,self__.start_pos,G__23068,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,self__.relative_to,self__.offset,self__.start_pos,self__.end_pos,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__23068),null));\n}\n}\n}\n}\n}\n}\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),self__.type_tag,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),self__.logical_block,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051),self__.relative_to,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),self__.offset,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),self__.start_pos,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926),self__.end_pos,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__23068){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.indent_t(self__.type_tag,self__.logical_block,self__.relative_to,self__.offset,self__.start_pos,self__.end_pos,G__23068,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.indent_t.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.indent_t.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22type-tag\x22,\x22type-tag\x22,-233331740,null),new cljs.core.Symbol(null,\x22logical-block\x22,\x22logical-block\x22,1059508963,null),new cljs.core.Symbol(null,\x22relative-to\x22,\x22relative-to\x22,1170431476,null),new cljs.core.Symbol(null,\x22offset\x22,\x22offset\x22,1937029838,null),new cljs.core.Symbol(null,\x22start-pos\x22,\x22start-pos\x22,-1985646683,null),new cljs.core.Symbol(null,\x22end-pos\x22,\x22end-pos\x22,-3352399,null)], null);\n}));\n\n(cljs.pprint.indent_t.cljs$lang$type \x3d true);\n\n(cljs.pprint.indent_t.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/indent-t\x22,null,(1),null));\n}));\n\n(cljs.pprint.indent_t.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/indent-t\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/indent-t.\n */\ncljs.pprint.__GT_indent_t \x3d (function cljs$pprint$__GT_indent_t(type_tag,logical_block,relative_to,offset,start_pos,end_pos){\nreturn (new cljs.pprint.indent_t(type_tag,logical_block,relative_to,offset,start_pos,end_pos,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/indent-t, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_indent_t \x3d (function cljs$pprint$map__GT_indent_t(G__23084){\nvar extmap__5342__auto__ \x3d (function (){var G__23295 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__23084,new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564),new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926)], 0));\nif(cljs.core.record_QMARK_(G__23084)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__23295);\n} else {\nreturn G__23295;\n}\n})();\nreturn (new cljs.pprint.indent_t(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(G__23084),new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(G__23084),new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051).cljs$core$IFn$_invoke$arity$1(G__23084),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311).cljs$core$IFn$_invoke$arity$1(G__23084),new cljs.core.Keyword(null,\x22start-pos\x22,\x22start-pos\x22,668789086).cljs$core$IFn$_invoke$arity$1(G__23084),new cljs.core.Keyword(null,\x22end-pos\x22,\x22end-pos\x22,-1643883926).cljs$core$IFn$_invoke$arity$1(G__23084),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\n\ncljs.pprint.make_indent_t \x3d (function cljs$pprint$make_indent_t(logical_block,relative_to,offset,start_pos,end_pos){\nreturn (new cljs.pprint.indent_t(new cljs.core.Keyword(null,\x22indent-t\x22,\x22indent-t\x22,528318969),logical_block,relative_to,offset,start_pos,end_pos,null,null,null));\n});\n\ncljs.pprint.indent_t_QMARK_ \x3d (function cljs$pprint$indent_t_QMARK_(x__21635__auto__){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(x__21635__auto__),new cljs.core.Keyword(null,\x22indent-t\x22,\x22indent-t\x22,528318969));\n});\ncljs.pprint.pp_newline \x3d (function cljs$pprint$pp_newline(){\nreturn \x22\\n\x22;\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint.write_token !\x3d\x3d \x27undefined\x27)){\n} else {\ncljs.pprint.write_token \x3d (function (){var method_table__5599__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar prefer_table__5600__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar method_cache__5601__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar cached_hierarchy__5602__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar hierarchy__5603__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22hierarchy\x22,\x22hierarchy\x22,-1053470341),(function (){var fexpr__23329 \x3d cljs.core.get_global_hierarchy;\nreturn (fexpr__23329.cljs$core$IFn$_invoke$arity$0 ? fexpr__23329.cljs$core$IFn$_invoke$arity$0() : fexpr__23329.call(null, ));\n})());\nreturn (new cljs.core.MultiFn(cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(\x22cljs.pprint\x22,\x22write-token\x22),(function (p1__23323_SHARP_,p2__23322_SHARP_){\nreturn new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(p2__23322_SHARP_);\n}),new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),hierarchy__5603__auto__,method_table__5599__auto__,prefer_table__5600__auto__,method_cache__5601__auto__,cached_hierarchy__5602__auto__));\n})();\n}\ncljs.pprint.write_token.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22start-block-t\x22,\x22start-block-t\x22,-373430594),(function (this$,token){\nvar temp__5804__auto___28168 \x3d new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5804__auto___28168)){\nvar cb_28172 \x3d temp__5804__auto___28168;\n(cb_28172.cljs$core$IFn$_invoke$arity$1 ? cb_28172.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22start\x22,\x22start\x22,-355208981)) : cb_28172.call(null, new cljs.core.Keyword(null,\x22start\x22,\x22start\x22,-355208981)));\n} else {\n}\n\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(token);\nvar temp__5804__auto___28174 \x3d new cljs.core.Keyword(null,\x22prefix\x22,\x22prefix\x22,-265908465).cljs$core$IFn$_invoke$arity$1(lb);\nif(cljs.core.truth_(temp__5804__auto___28174)){\nvar prefix_28175 \x3d temp__5804__auto___28174;\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),prefix_28175);\n} else {\n}\n\nvar col \x3d cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))));\ncljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143).cljs$core$IFn$_invoke$arity$1(lb),col);\n\nreturn cljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125).cljs$core$IFn$_invoke$arity$1(lb),col);\n}));\ncljs.pprint.write_token.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22end-block-t\x22,\x22end-block-t\x22,1544648735),(function (this$,token){\nvar temp__5804__auto___28177 \x3d new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5804__auto___28177)){\nvar cb_28179 \x3d temp__5804__auto___28177;\n(cb_28179.cljs$core$IFn$_invoke$arity$1 ? cb_28179.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22end\x22,\x22end\x22,-268185958)) : cb_28179.call(null, new cljs.core.Keyword(null,\x22end\x22,\x22end\x22,-268185958)));\n} else {\n}\n\nvar temp__5804__auto__ \x3d new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(token));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar suffix \x3d temp__5804__auto__;\nreturn cljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),suffix);\n} else {\nreturn null;\n}\n}));\ncljs.pprint.write_token.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22indent-t\x22,\x22indent-t\x22,528318969),(function (this$,token){\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(token);\nreturn cljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125).cljs$core$IFn$_invoke$arity$1(lb),(new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311).cljs$core$IFn$_invoke$arity$1(token) + (function (){var pred__23363 \x3d cljs.core._EQ_;\nvar expr__23364 \x3d new cljs.core.Keyword(null,\x22relative-to\x22,\x22relative-to\x22,-470100051).cljs$core$IFn$_invoke$arity$1(token);\nif(cljs.core.truth_((pred__23363.cljs$core$IFn$_invoke$arity$2 ? pred__23363.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),expr__23364) : pred__23363.call(null, new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),expr__23364)))){\nreturn cljs.core.deref(new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143).cljs$core$IFn$_invoke$arity$1(lb));\n} else {\nif(cljs.core.truth_((pred__23363.cljs$core$IFn$_invoke$arity$2 ? pred__23363.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22current\x22,\x22current\x22,-1088038603),expr__23364) : pred__23363.call(null, new cljs.core.Keyword(null,\x22current\x22,\x22current\x22,-1088038603),expr__23364)))){\nreturn cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__23364)].join(\x27\x27)));\n}\n}\n})()));\n}));\ncljs.pprint.write_token.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22buffer-blob\x22,\x22buffer-blob\x22,-1830112173),(function (this$,token){\nreturn cljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377).cljs$core$IFn$_invoke$arity$1(token));\n}));\ncljs.pprint.write_token.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22nl-t\x22,\x22nl-t\x22,-1608382114),(function (this$,token){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348).cljs$core$IFn$_invoke$arity$1(token),new cljs.core.Keyword(null,\x22mandatory\x22,\x22mandatory\x22,542802336));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d (!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348).cljs$core$IFn$_invoke$arity$1(token),new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889))));\nif(and__5000__auto__){\nreturn cljs.core.deref(new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(token)));\n} else {\nreturn and__5000__auto__;\n}\n}\n})())){\n(cljs.pprint.emit_nl.cljs$core$IFn$_invoke$arity$2 ? cljs.pprint.emit_nl.cljs$core$IFn$_invoke$arity$2(this$,token) : cljs.pprint.emit_nl.call(null, this$,token));\n} else {\nvar temp__5802__auto___28194 \x3d new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5802__auto___28194)){\nvar tws_28195 \x3d temp__5802__auto___28194;\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),tws_28195);\n} else {\n}\n}\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),null);\n}));\ncljs.pprint.write_tokens \x3d (function cljs$pprint$write_tokens(this$,tokens,force_trailing_whitespace){\nvar seq__23411 \x3d cljs.core.seq(tokens);\nvar chunk__23412 \x3d null;\nvar count__23413 \x3d (0);\nvar i__23414 \x3d (0);\nwhile(true){\nif((i__23414 \x3c count__23413)){\nvar token \x3d chunk__23412.cljs$core$IIndexed$_nth$arity$2(null, i__23414);\nif((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(token),new cljs.core.Keyword(null,\x22nl-t\x22,\x22nl-t\x22,-1608382114))))){\nvar temp__5802__auto___28200 \x3d new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5802__auto___28200)){\nvar tws_28203 \x3d temp__5802__auto___28200;\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),tws_28203);\n} else {\n}\n} else {\n}\n\ncljs.pprint.write_token.cljs$core$IFn$_invoke$arity$2(this$,token);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(token));\n\nvar tws_28211 \x3d new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d force_trailing_whitespace;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn tws_28211;\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),tws_28211);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),null);\n} else {\n}\n\n\nvar G__28221 \x3d seq__23411;\nvar G__28222 \x3d chunk__23412;\nvar G__28223 \x3d count__23413;\nvar G__28224 \x3d (i__23414 + (1));\nseq__23411 \x3d G__28221;\nchunk__23412 \x3d G__28222;\ncount__23413 \x3d G__28223;\ni__23414 \x3d G__28224;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__23411);\nif(temp__5804__auto__){\nvar seq__23411__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__23411__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__23411__$1);\nvar G__28229 \x3d cljs.core.chunk_rest(seq__23411__$1);\nvar G__28230 \x3d c__5525__auto__;\nvar G__28231 \x3d cljs.core.count(c__5525__auto__);\nvar G__28232 \x3d (0);\nseq__23411 \x3d G__28229;\nchunk__23412 \x3d G__28230;\ncount__23413 \x3d G__28231;\ni__23414 \x3d G__28232;\ncontinue;\n} else {\nvar token \x3d cljs.core.first(seq__23411__$1);\nif((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22type-tag\x22,\x22type-tag\x22,-1873863267).cljs$core$IFn$_invoke$arity$1(token),new cljs.core.Keyword(null,\x22nl-t\x22,\x22nl-t\x22,-1608382114))))){\nvar temp__5802__auto___28234 \x3d new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5802__auto___28234)){\nvar tws_28235 \x3d temp__5802__auto___28234;\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),tws_28235);\n} else {\n}\n} else {\n}\n\ncljs.pprint.write_token.cljs$core$IFn$_invoke$arity$2(this$,token);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(token));\n\nvar tws_28236 \x3d new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d force_trailing_whitespace;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn tws_28236;\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),tws_28236);\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),null);\n} else {\n}\n\n\nvar G__28238 \x3d cljs.core.next(seq__23411__$1);\nvar G__28239 \x3d null;\nvar G__28240 \x3d (0);\nvar G__28241 \x3d (0);\nseq__23411 \x3d G__28238;\nchunk__23412 \x3d G__28239;\ncount__23413 \x3d G__28240;\ni__23414 \x3d G__28241;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\ncljs.pprint.tokens_fit_QMARK_ \x3d (function cljs$pprint$tokens_fit_QMARK_(this$,tokens){\nvar maxcol \x3d cljs.pprint.get_max_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))));\nreturn (((maxcol \x3d\x3d null)) || (((cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)))) + cljs.pprint.buffer_length(tokens)) \x3c maxcol)));\n});\ncljs.pprint.linear_nl_QMARK_ \x3d (function cljs$pprint$linear_nl_QMARK_(this$,lb,section){\nvar or__5002__auto__ \x3d cljs.core.deref(new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340).cljs$core$IFn$_invoke$arity$1(lb));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (!(cljs.pprint.tokens_fit_QMARK_(this$,section)));\n}\n});\ncljs.pprint.miser_nl_QMARK_ \x3d (function cljs$pprint$miser_nl_QMARK_(this$,lb,section){\nvar miser_width \x3d cljs.pprint.get_miser_width(this$);\nvar maxcol \x3d cljs.pprint.get_max_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))));\nvar and__5000__auto__ \x3d miser_width;\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d maxcol;\nif(cljs.core.truth_(and__5000__auto____$1)){\nvar and__5000__auto____$2 \x3d (cljs.core.deref(new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143).cljs$core$IFn$_invoke$arity$1(lb)) \x3e\x3d (maxcol - miser_width));\nif(and__5000__auto____$2){\nreturn cljs.pprint.linear_nl_QMARK_(this$,lb,section);\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint.emit_nl_QMARK_ !\x3d\x3d \x27undefined\x27)){\n} else {\ncljs.pprint.emit_nl_QMARK_ \x3d (function (){var method_table__5599__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar prefer_table__5600__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar method_cache__5601__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar cached_hierarchy__5602__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar hierarchy__5603__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22hierarchy\x22,\x22hierarchy\x22,-1053470341),(function (){var fexpr__23539 \x3d cljs.core.get_global_hierarchy;\nreturn (fexpr__23539.cljs$core$IFn$_invoke$arity$0 ? fexpr__23539.cljs$core$IFn$_invoke$arity$0() : fexpr__23539.call(null, ));\n})());\nreturn (new cljs.core.MultiFn(cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(\x22cljs.pprint\x22,\x22emit-nl?\x22),(function (t,_,___$1,___$2){\nreturn new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348).cljs$core$IFn$_invoke$arity$1(t);\n}),new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),hierarchy__5603__auto__,method_table__5599__auto__,prefer_table__5600__auto__,method_cache__5601__auto__,cached_hierarchy__5602__auto__));\n})();\n}\ncljs.pprint.emit_nl_QMARK_.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697),(function (newl,this$,section,_){\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(newl);\nreturn cljs.pprint.linear_nl_QMARK_(this$,lb,section);\n}));\ncljs.pprint.emit_nl_QMARK_.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22miser\x22,\x22miser\x22,-556060186),(function (newl,this$,section,_){\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(newl);\nreturn cljs.pprint.miser_nl_QMARK_(this$,lb,section);\n}));\ncljs.pprint.emit_nl_QMARK_.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),(function (newl,this$,section,subsection){\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(newl);\nvar or__5002__auto__ \x3d cljs.core.deref(new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875).cljs$core$IFn$_invoke$arity$1(lb));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (!(cljs.pprint.tokens_fit_QMARK_(this$,subsection)));\nif(or__5002__auto____$1){\nreturn or__5002__auto____$1;\n} else {\nreturn cljs.pprint.miser_nl_QMARK_(this$,lb,section);\n}\n}\n}));\ncljs.pprint.emit_nl_QMARK_.cljs$core$IMultiFn$_add_method$arity$3(null, new cljs.core.Keyword(null,\x22mandatory\x22,\x22mandatory\x22,542802336),(function (_,___$1,___$2,___$3){\nreturn true;\n}));\ncljs.pprint.get_section \x3d (function cljs$pprint$get_section(buffer){\nvar nl \x3d cljs.core.first(buffer);\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(nl);\nvar section \x3d cljs.core.seq(cljs.core.take_while.cljs$core$IFn$_invoke$arity$2((function (p1__23600_SHARP_){\nreturn (!(((cljs.pprint.nl_t_QMARK_(p1__23600_SHARP_)) \x26\x26 (cljs.pprint.ancestor_QMARK_(new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(p1__23600_SHARP_),lb)))));\n}),cljs.core.next(buffer)));\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [section,cljs.core.seq(cljs.core.drop.cljs$core$IFn$_invoke$arity$2((cljs.core.count(section) + (1)),buffer))], null);\n});\ncljs.pprint.get_sub_section \x3d (function cljs$pprint$get_sub_section(buffer){\nvar nl \x3d cljs.core.first(buffer);\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(nl);\nvar section \x3d cljs.core.seq(cljs.core.take_while.cljs$core$IFn$_invoke$arity$2((function (p1__23629_SHARP_){\nvar nl_lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(p1__23629_SHARP_);\nreturn (!(((cljs.pprint.nl_t_QMARK_(p1__23629_SHARP_)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(nl_lb,lb)) || (cljs.pprint.ancestor_QMARK_(nl_lb,lb)))))));\n}),cljs.core.next(buffer)));\nreturn section;\n});\ncljs.pprint.update_nl_state \x3d (function cljs$pprint$update_nl_state(lb){\ncljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875).cljs$core$IFn$_invoke$arity$1(lb),true);\n\ncljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340).cljs$core$IFn$_invoke$arity$1(lb),true);\n\nvar lb__$1 \x3d new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(lb);\nwhile(true){\nif(cljs.core.truth_(lb__$1)){\ncljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22done-nl\x22,\x22done-nl\x22,-381024340).cljs$core$IFn$_invoke$arity$1(lb__$1),true);\n\ncljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22intra-block-nl\x22,\x22intra-block-nl\x22,1808826875).cljs$core$IFn$_invoke$arity$1(lb__$1),true);\n\nvar G__28297 \x3d new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(lb__$1);\nlb__$1 \x3d G__28297;\ncontinue;\n} else {\nreturn null;\n}\nbreak;\n}\n});\ncljs.pprint.emit_nl \x3d (function cljs$pprint$emit_nl(this$,nl){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),cljs.pprint.pp_newline());\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),null);\n\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-block\x22,\x22logical-block\x22,-581022564).cljs$core$IFn$_invoke$arity$1(nl);\nvar prefix \x3d new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813).cljs$core$IFn$_invoke$arity$1(lb);\nif(cljs.core.truth_(prefix)){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),prefix);\n} else {\n}\n\nvar istr_28307 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((cljs.core.deref(new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125).cljs$core$IFn$_invoke$arity$1(lb)) - cljs.core.count(prefix)),\x22 \x22));\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),istr_28307);\n\nreturn cljs.pprint.update_nl_state(lb);\n});\ncljs.pprint.split_at_newline \x3d (function cljs$pprint$split_at_newline(tokens){\nvar pre \x3d cljs.core.seq(cljs.core.take_while.cljs$core$IFn$_invoke$arity$2((function (p1__23708_SHARP_){\nreturn (!(cljs.pprint.nl_t_QMARK_(p1__23708_SHARP_)));\n}),tokens));\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [pre,cljs.core.seq(cljs.core.drop.cljs$core$IFn$_invoke$arity$2(cljs.core.count(pre),tokens))], null);\n});\ncljs.pprint.write_token_string \x3d (function cljs$pprint$write_token_string(this$,tokens){\nvar vec__23727 \x3d cljs.pprint.split_at_newline(tokens);\nvar a \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23727,(0),null);\nvar b \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23727,(1),null);\nif(cljs.core.truth_(a)){\ncljs.pprint.write_tokens(this$,a,false);\n} else {\n}\n\nif(cljs.core.truth_(b)){\nvar vec__23732 \x3d cljs.pprint.get_section(b);\nvar section \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23732,(0),null);\nvar remainder \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23732,(1),null);\nvar newl \x3d cljs.core.first(b);\nvar do_nl \x3d cljs.pprint.emit_nl_QMARK_.cljs$core$IFn$_invoke$arity$4(newl,this$,section,cljs.pprint.get_sub_section(b));\nvar result \x3d (cljs.core.truth_(do_nl)?(function (){\ncljs.pprint.emit_nl(this$,newl);\n\nreturn cljs.core.next(b);\n})()\n:b);\nvar long_section \x3d (!(cljs.pprint.tokens_fit_QMARK_(this$,result)));\nvar result__$1 \x3d ((long_section)?(function (){var rem2 \x3d (cljs.pprint.write_token_string.cljs$core$IFn$_invoke$arity$2 ? cljs.pprint.write_token_string.cljs$core$IFn$_invoke$arity$2(this$,section) : cljs.pprint.write_token_string.call(null, this$,section));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(rem2,section)){\ncljs.pprint.write_tokens(this$,section,false);\n\nreturn remainder;\n} else {\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(rem2,remainder));\n}\n})():result);\nreturn result__$1;\n} else {\nreturn null;\n}\n});\ncljs.pprint.write_line \x3d (function cljs$pprint$write_line(this$){\nvar buffer \x3d new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nwhile(true){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198),cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,buffer));\n\nif((!(cljs.pprint.tokens_fit_QMARK_(this$,buffer)))){\nvar new_buffer \x3d cljs.pprint.write_token_string(this$,buffer);\nif((!((buffer \x3d\x3d\x3d new_buffer)))){\nvar G__28330 \x3d new_buffer;\nbuffer \x3d G__28330;\ncontinue;\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});\ncljs.pprint.add_to_buffer \x3d (function cljs$pprint$add_to_buffer(this$,token){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),token));\n\nif((!(cljs.pprint.tokens_fit_QMARK_(this$,new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))))))){\nreturn cljs.pprint.write_line(this$);\n} else {\nreturn null;\n}\n});\ncljs.pprint.write_buffered_output \x3d (function cljs$pprint$write_buffered_output(this$){\ncljs.pprint.write_line(this$);\n\nvar temp__5802__auto__ \x3d new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar buf \x3d temp__5802__auto__;\ncljs.pprint.write_tokens(this$,buf,true);\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198),cljs.core.PersistentVector.EMPTY);\n} else {\nreturn null;\n}\n});\ncljs.pprint.write_white_space \x3d (function cljs$pprint$write_white_space(this$){\nvar temp__5804__auto__ \x3d new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar tws \x3d temp__5804__auto__;\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),tws);\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),null);\n} else {\nreturn null;\n}\n});\ncljs.pprint.write_initial_lines \x3d (function cljs$pprint$write_initial_lines(this$,s){\nvar lines \x3d clojure.string.split.cljs$core$IFn$_invoke$arity$3(s,\x22\\n\x22,(-1));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(lines),(1))){\nreturn s;\n} else {\nvar prefix \x3d new cljs.core.Keyword(null,\x22per-line-prefix\x22,\x22per-line-prefix\x22,846941813).cljs$core$IFn$_invoke$arity$1(cljs.core.first(new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)))));\nvar l \x3d cljs.core.first(lines);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22buffering\x22,\x22buffering\x22,-876713613),new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))))){\nvar oldpos_28349 \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nvar newpos_28350 \x3d (oldpos_28349 + cljs.core.count(l));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),newpos_28350);\n\ncljs.pprint.add_to_buffer(this$,cljs.pprint.make_buffer_blob(l,null,oldpos_28349,newpos_28350));\n\ncljs.pprint.write_buffered_output(this$);\n} else {\ncljs.pprint.write_white_space(this$);\n\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),l);\n}\n\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),\x22\\n\x22);\n\nvar seq__23905_28352 \x3d cljs.core.seq(cljs.core.next(cljs.core.butlast(lines)));\nvar chunk__23906_28353 \x3d null;\nvar count__23907_28354 \x3d (0);\nvar i__23908_28355 \x3d (0);\nwhile(true){\nif((i__23908_28355 \x3c count__23907_28354)){\nvar l_28357__$1 \x3d chunk__23906_28353.cljs$core$IIndexed$_nth$arity$2(null, i__23908_28355);\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),l_28357__$1);\n\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),cljs.pprint.pp_newline());\n\nif(cljs.core.truth_(prefix)){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),prefix);\n} else {\n}\n\n\nvar G__28358 \x3d seq__23905_28352;\nvar G__28359 \x3d chunk__23906_28353;\nvar G__28360 \x3d count__23907_28354;\nvar G__28361 \x3d (i__23908_28355 + (1));\nseq__23905_28352 \x3d G__28358;\nchunk__23906_28353 \x3d G__28359;\ncount__23907_28354 \x3d G__28360;\ni__23908_28355 \x3d G__28361;\ncontinue;\n} else {\nvar temp__5804__auto___28362 \x3d cljs.core.seq(seq__23905_28352);\nif(temp__5804__auto___28362){\nvar seq__23905_28363__$1 \x3d temp__5804__auto___28362;\nif(cljs.core.chunked_seq_QMARK_(seq__23905_28363__$1)){\nvar c__5525__auto___28364 \x3d cljs.core.chunk_first(seq__23905_28363__$1);\nvar G__28365 \x3d cljs.core.chunk_rest(seq__23905_28363__$1);\nvar G__28366 \x3d c__5525__auto___28364;\nvar G__28367 \x3d cljs.core.count(c__5525__auto___28364);\nvar G__28368 \x3d (0);\nseq__23905_28352 \x3d G__28365;\nchunk__23906_28353 \x3d G__28366;\ncount__23907_28354 \x3d G__28367;\ni__23908_28355 \x3d G__28368;\ncontinue;\n} else {\nvar l_28369__$1 \x3d cljs.core.first(seq__23905_28363__$1);\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),l_28369__$1);\n\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),cljs.pprint.pp_newline());\n\nif(cljs.core.truth_(prefix)){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),prefix);\n} else {\n}\n\n\nvar G__28370 \x3d cljs.core.next(seq__23905_28363__$1);\nvar G__28371 \x3d null;\nvar G__28372 \x3d (0);\nvar G__28373 \x3d (0);\nseq__23905_28352 \x3d G__28370;\nchunk__23906_28353 \x3d G__28371;\ncount__23907_28354 \x3d G__28372;\ni__23908_28355 \x3d G__28373;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22buffering\x22,\x22buffering\x22,-876713613),new cljs.core.Keyword(null,\x22writing\x22,\x22writing\x22,-1486865108));\n\nreturn cljs.core.last(lines);\n}\n});\ncljs.pprint.p_write_char \x3d (function cljs$pprint$p_write_char(this$,c){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),new cljs.core.Keyword(null,\x22writing\x22,\x22writing\x22,-1486865108))){\ncljs.pprint.write_white_space(this$);\n\nreturn cljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),c);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(c,\x22\\n\x22)){\nreturn cljs.pprint.write_initial_lines(this$,\x22\\n\x22);\n} else {\nvar oldpos \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nvar newpos \x3d (oldpos + (1));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),newpos);\n\nreturn cljs.pprint.add_to_buffer(this$,cljs.pprint.make_buffer_blob(cljs.core.char$(c),null,oldpos,newpos));\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IDeref}\n * @implements {cljs.pprint.IPrettyFlush}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.pprint.t_cljs$pprint24023 \x3d (function (writer,max_columns,miser_width,lb,fields,meta24024){\nthis.writer \x3d writer;\nthis.max_columns \x3d max_columns;\nthis.miser_width \x3d miser_width;\nthis.lb \x3d lb;\nthis.fields \x3d fields;\nthis.meta24024 \x3d meta24024;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1074167808;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.pprint.t_cljs$pprint24023.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24025,meta24024__$1){\nvar self__ \x3d this;\nvar _24025__$1 \x3d this;\nreturn (new cljs.pprint.t_cljs$pprint24023(self__.writer,self__.max_columns,self__.miser_width,self__.lb,self__.fields,meta24024__$1));\n}));\n\n(cljs.pprint.t_cljs$pprint24023.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24025){\nvar self__ \x3d this;\nvar _24025__$1 \x3d this;\nreturn self__.meta24024;\n}));\n\n(cljs.pprint.t_cljs$pprint24023.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.fields;\n}));\n\n(cljs.pprint.t_cljs$pprint24023.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (this$,x){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar pred__24041 \x3d cljs.core._EQ_;\nvar expr__24042 \x3d cljs.core.type(x);\nif(cljs.core.truth_((pred__24041.cljs$core$IFn$_invoke$arity$2 ? pred__24041.cljs$core$IFn$_invoke$arity$2(String,expr__24042) : pred__24041.call(null, String,expr__24042)))){\nvar s0 \x3d cljs.pprint.write_initial_lines(this$__$1,x);\nvar s \x3d clojure.string.replace_first(s0,/\\s+$/,\x22\x22);\nvar white_space \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s0,((s).length));\nvar mode \x3d new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$__$1)));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(mode,new cljs.core.Keyword(null,\x22writing\x22,\x22writing\x22,-1486865108))){\ncljs.pprint.write_white_space(this$__$1);\n\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$__$1))),s);\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$__$1),cljs.core.assoc,new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),white_space);\n} else {\nvar oldpos \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$__$1)));\nvar newpos \x3d (oldpos + cljs.core.count(s0));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$__$1),cljs.core.assoc,new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),newpos);\n\nreturn cljs.pprint.add_to_buffer(this$__$1,cljs.pprint.make_buffer_blob(s,white_space,oldpos,newpos));\n}\n} else {\nif(cljs.core.truth_((pred__24041.cljs$core$IFn$_invoke$arity$2 ? pred__24041.cljs$core$IFn$_invoke$arity$2(Number,expr__24042) : pred__24041.call(null, Number,expr__24042)))){\nreturn cljs.pprint.p_write_char(this$__$1,x);\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__24042)].join(\x27\x27)));\n}\n}\n}));\n\n(cljs.pprint.t_cljs$pprint24023.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nthis$__$1.cljs$pprint$IPrettyFlush$_ppflush$arity$1(null, );\n\nreturn cljs.core._flush(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$__$1))));\n}));\n\n(cljs.pprint.t_cljs$pprint24023.prototype.cljs$pprint$IPrettyFlush$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.pprint.t_cljs$pprint24023.prototype.cljs$pprint$IPrettyFlush$_ppflush$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$__$1))),new cljs.core.Keyword(null,\x22buffering\x22,\x22buffering\x22,-876713613))){\ncljs.pprint.write_tokens(this$__$1,new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$__$1))),true);\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$__$1),cljs.core.assoc,new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198),cljs.core.PersistentVector.EMPTY);\n} else {\nreturn cljs.pprint.write_white_space(this$__$1);\n}\n}));\n\n(cljs.pprint.t_cljs$pprint24023.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22writer\x22,\x22writer\x22,1362963291,null),new cljs.core.Symbol(null,\x22max-columns\x22,\x22max-columns\x22,-912112507,null),new cljs.core.Symbol(null,\x22miser-width\x22,\x22miser-width\x22,330482090,null),new cljs.core.Symbol(null,\x22lb\x22,\x22lb\x22,950310490,null),new cljs.core.Symbol(null,\x22fields\x22,\x22fields\x22,-291534703,null),new cljs.core.Symbol(null,\x22meta24024\x22,\x22meta24024\x22,580292127,null)], null);\n}));\n\n(cljs.pprint.t_cljs$pprint24023.cljs$lang$type \x3d true);\n\n(cljs.pprint.t_cljs$pprint24023.cljs$lang$ctorStr \x3d \x22cljs.pprint/t_cljs$pprint24023\x22);\n\n(cljs.pprint.t_cljs$pprint24023.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.pprint/t_cljs$pprint24023\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/t_cljs$pprint24023.\n */\ncljs.pprint.__GT_t_cljs$pprint24023 \x3d (function cljs$pprint$__GT_t_cljs$pprint24023(writer,max_columns,miser_width,lb,fields,meta24024){\nreturn (new cljs.pprint.t_cljs$pprint24023(writer,max_columns,miser_width,lb,fields,meta24024));\n});\n\n\ncljs.pprint.pretty_writer \x3d (function cljs$pprint$pretty_writer(writer,max_columns,miser_width){\nvar lb \x3d (new cljs.pprint.logical_block(null,null,cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0)),cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0)),cljs.core.atom.cljs$core$IFn$_invoke$arity$1(false),cljs.core.atom.cljs$core$IFn$_invoke$arity$1(false),null,null,null,null,null,null,null));\nvar fields \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentHashMap.fromArrays([new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776),new cljs.core.Keyword(null,\x22miser-width\x22,\x22miser-width\x22,-1310049437),new cljs.core.Keyword(null,\x22buffer-block\x22,\x22buffer-block\x22,-10937307),new cljs.core.Keyword(null,\x22pretty-writer\x22,\x22pretty-writer\x22,-1222834267),new cljs.core.Keyword(null,\x22sections\x22,\x22sections\x22,-886710106),new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691),new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),new cljs.core.Keyword(null,\x22trailing-white-space\x22,\x22trailing-white-space\x22,1496006996),new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322),new cljs.core.Keyword(null,\x22buffer-level\x22,\x22buffer-level\x22,928864731),new cljs.core.Keyword(null,\x22buffer\x22,\x22buffer\x22,617295198)],[lb,miser_width,lb,true,null,new cljs.core.Keyword(null,\x22writing\x22,\x22writing\x22,-1486865108),(0),null,cljs.pprint.column_writer.cljs$core$IFn$_invoke$arity$2(writer,max_columns),(1),cljs.core.PersistentVector.EMPTY]));\nreturn (new cljs.pprint.t_cljs$pprint24023(writer,max_columns,miser_width,lb,fields,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.pprint.start_block \x3d (function cljs$pprint$start_block(this$,prefix,per_line_prefix,suffix){\nvar lb \x3d (new cljs.pprint.logical_block(new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),null,cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0)),cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0)),cljs.core.atom.cljs$core$IFn$_invoke$arity$1(false),cljs.core.atom.cljs$core$IFn$_invoke$arity$1(false),prefix,per_line_prefix,suffix,null,null,null,null));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776),lb);\n\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),new cljs.core.Keyword(null,\x22writing\x22,\x22writing\x22,-1486865108))){\ncljs.pprint.write_white_space(this$);\n\nvar temp__5804__auto___28378 \x3d new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5804__auto___28378)){\nvar cb_28379 \x3d temp__5804__auto___28378;\n(cb_28379.cljs$core$IFn$_invoke$arity$1 ? cb_28379.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22start\x22,\x22start\x22,-355208981)) : cb_28379.call(null, new cljs.core.Keyword(null,\x22start\x22,\x22start\x22,-355208981)));\n} else {\n}\n\nif(cljs.core.truth_(prefix)){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),prefix);\n} else {\n}\n\nvar col \x3d cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))));\ncljs.core.reset_BANG_(lb.start_col,col);\n\nreturn cljs.core.reset_BANG_(lb.indent,col);\n} else {\nvar oldpos \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nvar newpos \x3d (oldpos + (cljs.core.truth_(prefix)?cljs.core.count(prefix):(0)));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),newpos);\n\nreturn cljs.pprint.add_to_buffer(this$,cljs.pprint.make_start_block_t(lb,oldpos,newpos));\n}\n});\ncljs.pprint.end_block \x3d (function cljs$pprint$end_block(this$){\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nvar suffix \x3d new cljs.core.Keyword(null,\x22suffix\x22,\x22suffix\x22,367373057).cljs$core$IFn$_invoke$arity$1(lb);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),new cljs.core.Keyword(null,\x22writing\x22,\x22writing\x22,-1486865108))){\ncljs.pprint.write_white_space(this$);\n\nif(cljs.core.truth_(suffix)){\ncljs.core._write(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),suffix);\n} else {\n}\n\nvar temp__5804__auto___28381 \x3d new cljs.core.Keyword(null,\x22logical-block-callback\x22,\x22logical-block-callback\x22,1612691194).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core.truth_(temp__5804__auto___28381)){\nvar cb_28385 \x3d temp__5804__auto___28381;\n(cb_28385.cljs$core$IFn$_invoke$arity$1 ? cb_28385.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22end\x22,\x22end\x22,-268185958)) : cb_28385.call(null, new cljs.core.Keyword(null,\x22end\x22,\x22end\x22,-268185958)));\n} else {\n}\n} else {\nvar oldpos_28386 \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nvar newpos_28387 \x3d (oldpos_28386 + (cljs.core.truth_(suffix)?cljs.core.count(suffix):(0)));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),newpos_28387);\n\ncljs.pprint.add_to_buffer(this$,cljs.pprint.make_end_block_t(lb,oldpos_28386,newpos_28387));\n}\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776),new cljs.core.Keyword(null,\x22parent\x22,\x22parent\x22,-878878779).cljs$core$IFn$_invoke$arity$1(lb));\n});\ncljs.pprint.nl \x3d (function cljs$pprint$nl(this$,type){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.deref(this$),cljs.core.assoc,new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691),new cljs.core.Keyword(null,\x22buffering\x22,\x22buffering\x22,-876713613));\n\nvar pos \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nreturn cljs.pprint.add_to_buffer(this$,cljs.pprint.make_nl_t(type,new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),pos,pos));\n});\ncljs.pprint.indent \x3d (function cljs$pprint$indent(this$,relative_to,offset){\nvar lb \x3d new cljs.core.Keyword(null,\x22logical-blocks\x22,\x22logical-blocks\x22,-1466339776).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22mode\x22,\x22mode\x22,654403691).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))),new cljs.core.Keyword(null,\x22writing\x22,\x22writing\x22,-1486865108))){\ncljs.pprint.write_white_space(this$);\n\nreturn cljs.core.reset_BANG_(new cljs.core.Keyword(null,\x22indent\x22,\x22indent\x22,-148200125).cljs$core$IFn$_invoke$arity$1(lb),(offset + (function (){var pred__24149 \x3d cljs.core._EQ_;\nvar expr__24150 \x3d relative_to;\nif(cljs.core.truth_((pred__24149.cljs$core$IFn$_invoke$arity$2 ? pred__24149.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),expr__24150) : pred__24149.call(null, new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),expr__24150)))){\nreturn cljs.core.deref(new cljs.core.Keyword(null,\x22start-col\x22,\x22start-col\x22,668080143).cljs$core$IFn$_invoke$arity$1(lb));\n} else {\nif(cljs.core.truth_((pred__24149.cljs$core$IFn$_invoke$arity$2 ? pred__24149.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22current\x22,\x22current\x22,-1088038603),expr__24150) : pred__24149.call(null, new cljs.core.Keyword(null,\x22current\x22,\x22current\x22,-1088038603),expr__24150)))){\nreturn cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$))));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__24150)].join(\x27\x27)));\n}\n}\n})()));\n} else {\nvar pos \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\nreturn cljs.pprint.add_to_buffer(this$,cljs.pprint.make_indent_t(lb,relative_to,offset,pos,pos));\n}\n});\ncljs.pprint.get_miser_width \x3d (function cljs$pprint$get_miser_width(this$){\nreturn new cljs.core.Keyword(null,\x22miser-width\x22,\x22miser-width\x22,-1310049437).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(this$)));\n});\n/**\n * Bind to true if you want write to use pretty printing\n */\ncljs.pprint._STAR_print_pretty_STAR_ \x3d true;\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint._STAR_print_pprint_dispatch_STAR_ !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * The pretty print dispatch function. Use with-pprint-dispatch or\n * set-pprint-dispatch to modify.\n */\ncljs.pprint._STAR_print_pprint_dispatch_STAR_ \x3d null;\n}\n/**\n * Pretty printing will try to avoid anything going beyond this column.\n * Set it to nil to have pprint let the line be arbitrarily long. This will ignore all\n * non-mandatory newlines.\n */\ncljs.pprint._STAR_print_right_margin_STAR_ \x3d (72);\n/**\n * The column at which to enter miser style. Depending on the dispatch table,\n * miser style add newlines in more places to try to keep lines short allowing for further\n * levels of nesting.\n */\ncljs.pprint._STAR_print_miser_width_STAR_ \x3d (40);\n/**\n * Maximum number of lines to print in a pretty print instance (N.B. This is not yet used)\n */\ncljs.pprint._STAR_print_lines_STAR_ \x3d null;\n/**\n * Mark circular structures (N.B. This is not yet used)\n */\ncljs.pprint._STAR_print_circle_STAR_ \x3d null;\n/**\n * Mark repeated structures rather than repeat them (N.B. This is not yet used)\n */\ncljs.pprint._STAR_print_shared_STAR_ \x3d null;\n/**\n * Don\x27t print namespaces with symbols. This is particularly useful when\n * pretty printing the results of macro expansions\n */\ncljs.pprint._STAR_print_suppress_namespaces_STAR_ \x3d null;\n/**\n * Print a radix specifier in front of integers and rationals. If *print-base* is 2, 8,\n * or 16, then the radix specifier used is #b, #o, or #x, respectively. Otherwise the\n * radix specifier is in the form #XXr where XX is the decimal value of *print-base* \n */\ncljs.pprint._STAR_print_radix_STAR_ \x3d null;\n/**\n * The base to use for printing integers and rationals.\n */\ncljs.pprint._STAR_print_base_STAR_ \x3d (10);\ncljs.pprint._STAR_current_level_STAR_ \x3d (0);\ncljs.pprint._STAR_current_length_STAR_ \x3d null;\ncljs.pprint.table_ize \x3d (function cljs$pprint$table_ize(t,m){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic((function (p1__24183_SHARP_){\nvar temp__5804__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(t,cljs.core.key(p1__24183_SHARP_));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar v \x3d temp__5804__auto__;\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [v,cljs.core.val(p1__24183_SHARP_)], null);\n} else {\nreturn null;\n}\n}),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([m], 0)));\n});\n/**\n * Return true iff x is a PrettyWriter\n */\ncljs.pprint.pretty_writer_QMARK_ \x3d (function cljs$pprint$pretty_writer_QMARK_(x){\nvar and__5000__auto__ \x3d (((!((x \x3d\x3d null))))?(((((x.cljs$lang$protocol_mask$partition0$ \x26 (32768))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$core$IDeref$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IDeref,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IDeref,x));\nif(and__5000__auto__){\nreturn new cljs.core.Keyword(null,\x22pretty-writer\x22,\x22pretty-writer\x22,-1222834267).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(x)));\n} else {\nreturn and__5000__auto__;\n}\n});\n/**\n * Wrap base-writer in a PrettyWriter with the specified right-margin and miser-width\n */\ncljs.pprint.make_pretty_writer \x3d (function cljs$pprint$make_pretty_writer(base_writer,right_margin,miser_width){\nreturn cljs.pprint.pretty_writer(base_writer,right_margin,miser_width);\n});\n/**\n * Write an object to *out* subject to the current bindings of the printer control\n * variables. Use the kw-args argument to override individual variables for this call (and\n * any recursive calls).\n * \n * *out* must be a PrettyWriter if pretty printing is enabled. This is the responsibility\n * of the caller.\n * \n * This method is primarily intended for use by pretty print dispatch functions that\n * already know that the pretty printer will have set up their environment appropriately.\n * Normal library clients should use the standard \x22write\x22 interface. \n */\ncljs.pprint.write_out \x3d (function cljs$pprint$write_out(object){\nvar length_reached \x3d (function (){var and__5000__auto__ \x3d cljs.pprint._STAR_current_length_STAR_;\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d cljs.core._STAR_print_length_STAR_;\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn (cljs.pprint._STAR_current_length_STAR_ \x3e\x3d cljs.core._STAR_print_length_STAR_);\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.not(cljs.pprint._STAR_print_pretty_STAR_)){\ncljs.pprint.pr.call(null, object);\n} else {\nif(cljs.core.truth_(length_reached)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n} else {\nif(cljs.core.truth_(cljs.pprint._STAR_current_length_STAR_)){\n(cljs.pprint._STAR_current_length_STAR_ \x3d (cljs.pprint._STAR_current_length_STAR_ + (1)));\n} else {\n}\n\ncljs.pprint._STAR_print_pprint_dispatch_STAR_.call(null, object);\n}\n}\n\nreturn length_reached;\n});\n/**\n * Write an object subject to the current bindings of the printer control variables.\n * Use the kw-args argument to override individual variables for this call (and any\n * recursive calls). Returns the string result if :stream is nil or nil otherwise.\n * \n * The following keyword arguments can be passed with values:\n *   Keyword              Meaning                              Default value\n *   :stream              Writer for output or nil             true (indicates *out*)\n *   :base                Base to use for writing rationals    Current value of *print-base*\n *   :circle*             If true, mark circular structures    Current value of *print-circle*\n *   :length              Maximum elements to show in sublists Current value of *print-length*\n *   :level               Maximum depth                        Current value of *print-level*\n *   :lines*              Maximum lines of output              Current value of *print-lines*\n *   :miser-width         Width to enter miser mode            Current value of *print-miser-width*\n *   :dispatch            The pretty print dispatch function   Current value of *print-pprint-dispatch*\n *   :pretty              If true, do pretty printing          Current value of *print-pretty*\n *   :radix               If true, prepend a radix specifier   Current value of *print-radix*\n *   :readably*           If true, print readably              Current value of *print-readably*\n *   :right-margin        The column for the right margin      Current value of *print-right-margin*\n *   :suppress-namespaces If true, no namespaces in symbols    Current value of *print-suppress-namespaces*\n * \n *   * \x3d not yet supported\n */\ncljs.pprint.write \x3d (function cljs$pprint$write(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28390 \x3d arguments.length;\nvar i__5727__auto___28391 \x3d (0);\nwhile(true){\nif((i__5727__auto___28391 \x3c len__5726__auto___28390)){\nargs__5732__auto__.push((arguments[i__5727__auto___28391]));\n\nvar G__28392 \x3d (i__5727__auto___28391 + (1));\ni__5727__auto___28391 \x3d G__28392;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn cljs.pprint.write.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(cljs.pprint.write.cljs$core$IFn$_invoke$arity$variadic \x3d (function (object,kw_args){\nvar options \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22stream\x22,\x22stream\x22,1534941648),true], null),cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,kw_args)], 0));\nvar _STAR_print_base_STAR__orig_val__24372 \x3d cljs.pprint._STAR_print_base_STAR_;\nvar _STAR_print_circle_STAR__orig_val__24373 \x3d cljs.pprint._STAR_print_circle_STAR_;\nvar _STAR_print_length_STAR__orig_val__24374 \x3d cljs.core._STAR_print_length_STAR_;\nvar _STAR_print_level_STAR__orig_val__24375 \x3d cljs.core._STAR_print_level_STAR_;\nvar _STAR_print_lines_STAR__orig_val__24376 \x3d cljs.pprint._STAR_print_lines_STAR_;\nvar _STAR_print_miser_width_STAR__orig_val__24377 \x3d cljs.pprint._STAR_print_miser_width_STAR_;\nvar _STAR_print_pprint_dispatch_STAR__orig_val__24378 \x3d cljs.pprint._STAR_print_pprint_dispatch_STAR_;\nvar _STAR_print_pretty_STAR__orig_val__24379 \x3d cljs.pprint._STAR_print_pretty_STAR_;\nvar _STAR_print_radix_STAR__orig_val__24380 \x3d cljs.pprint._STAR_print_radix_STAR_;\nvar _STAR_print_readably_STAR__orig_val__24381 \x3d cljs.core._STAR_print_readably_STAR_;\nvar _STAR_print_right_margin_STAR__orig_val__24382 \x3d cljs.pprint._STAR_print_right_margin_STAR_;\nvar _STAR_print_suppress_namespaces_STAR__orig_val__24383 \x3d cljs.pprint._STAR_print_suppress_namespaces_STAR_;\nvar _STAR_print_base_STAR__temp_val__24384 \x3d new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_base_STAR_);\nvar _STAR_print_circle_STAR__temp_val__24385 \x3d new cljs.core.Keyword(null,\x22circle\x22,\x22circle\x22,1903212362).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_circle_STAR_);\nvar _STAR_print_length_STAR__temp_val__24386 \x3d new cljs.core.Keyword(null,\x22length\x22,\x22length\x22,588987862).cljs$core$IFn$_invoke$arity$2(options,cljs.core._STAR_print_length_STAR_);\nvar _STAR_print_level_STAR__temp_val__24387 \x3d new cljs.core.Keyword(null,\x22level\x22,\x22level\x22,1290497552).cljs$core$IFn$_invoke$arity$2(options,cljs.core._STAR_print_level_STAR_);\nvar _STAR_print_lines_STAR__temp_val__24388 \x3d new cljs.core.Keyword(null,\x22lines\x22,\x22lines\x22,-700165781).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_lines_STAR_);\nvar _STAR_print_miser_width_STAR__temp_val__24390 \x3d new cljs.core.Keyword(null,\x22miser-width\x22,\x22miser-width\x22,-1310049437).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_miser_width_STAR_);\nvar _STAR_print_pprint_dispatch_STAR__temp_val__24391 \x3d new cljs.core.Keyword(null,\x22dispatch\x22,\x22dispatch\x22,1319337009).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_pprint_dispatch_STAR_);\nvar _STAR_print_pretty_STAR__temp_val__24392 \x3d new cljs.core.Keyword(null,\x22pretty\x22,\x22pretty\x22,-1916372486).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_pretty_STAR_);\nvar _STAR_print_radix_STAR__temp_val__24393 \x3d new cljs.core.Keyword(null,\x22radix\x22,\x22radix\x22,857016463).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_radix_STAR_);\nvar _STAR_print_readably_STAR__temp_val__24394 \x3d new cljs.core.Keyword(null,\x22readably\x22,\x22readably\x22,1129599760).cljs$core$IFn$_invoke$arity$2(options,cljs.core._STAR_print_readably_STAR_);\nvar _STAR_print_right_margin_STAR__temp_val__24395 \x3d new cljs.core.Keyword(null,\x22right-margin\x22,\x22right-margin\x22,-810413306).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_right_margin_STAR_);\nvar _STAR_print_suppress_namespaces_STAR__temp_val__24396 \x3d new cljs.core.Keyword(null,\x22suppress-namespaces\x22,\x22suppress-namespaces\x22,2130686956).cljs$core$IFn$_invoke$arity$2(options,cljs.pprint._STAR_print_suppress_namespaces_STAR_);\n(cljs.pprint._STAR_print_base_STAR_ \x3d _STAR_print_base_STAR__temp_val__24384);\n\n(cljs.pprint._STAR_print_circle_STAR_ \x3d _STAR_print_circle_STAR__temp_val__24385);\n\n(cljs.core._STAR_print_length_STAR_ \x3d _STAR_print_length_STAR__temp_val__24386);\n\n(cljs.core._STAR_print_level_STAR_ \x3d _STAR_print_level_STAR__temp_val__24387);\n\n(cljs.pprint._STAR_print_lines_STAR_ \x3d _STAR_print_lines_STAR__temp_val__24388);\n\n(cljs.pprint._STAR_print_miser_width_STAR_ \x3d _STAR_print_miser_width_STAR__temp_val__24390);\n\n(cljs.pprint._STAR_print_pprint_dispatch_STAR_ \x3d _STAR_print_pprint_dispatch_STAR__temp_val__24391);\n\n(cljs.pprint._STAR_print_pretty_STAR_ \x3d _STAR_print_pretty_STAR__temp_val__24392);\n\n(cljs.pprint._STAR_print_radix_STAR_ \x3d _STAR_print_radix_STAR__temp_val__24393);\n\n(cljs.core._STAR_print_readably_STAR_ \x3d _STAR_print_readably_STAR__temp_val__24394);\n\n(cljs.pprint._STAR_print_right_margin_STAR_ \x3d _STAR_print_right_margin_STAR__temp_val__24395);\n\n(cljs.pprint._STAR_print_suppress_namespaces_STAR_ \x3d _STAR_print_suppress_namespaces_STAR__temp_val__24396);\n\ntry{try{var sb \x3d (new goog.string.StringBuffer());\nvar optval \x3d ((cljs.core.contains_QMARK_(options,new cljs.core.Keyword(null,\x22stream\x22,\x22stream\x22,1534941648)))?new cljs.core.Keyword(null,\x22stream\x22,\x22stream\x22,1534941648).cljs$core$IFn$_invoke$arity$1(options):true);\nvar base_writer \x3d ((((optval \x3d\x3d\x3d true) || ((optval \x3d\x3d null))))?(new cljs.core.StringBufferWriter(sb)):optval);\nif(cljs.core.truth_(cljs.pprint._STAR_print_pretty_STAR_)){\nvar base_writer__21599__auto___28395 \x3d base_writer;\nvar new_writer__21600__auto___28396 \x3d cljs.core.not(cljs.pprint.pretty_writer_QMARK_(base_writer__21599__auto___28395));\nvar _STAR_out_STAR__orig_val__24487_28397 \x3d cljs.core._STAR_out_STAR_;\nvar _STAR_out_STAR__temp_val__24489_28398 \x3d ((new_writer__21600__auto___28396)?cljs.pprint.make_pretty_writer(base_writer__21599__auto___28395,cljs.pprint._STAR_print_right_margin_STAR_,cljs.pprint._STAR_print_miser_width_STAR_):base_writer__21599__auto___28395);\n(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__temp_val__24489_28398);\n\ntry{cljs.pprint.write_out(object);\n\ncljs.pprint._ppflush(cljs.core._STAR_out_STAR_);\n}finally {(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__orig_val__24487_28397);\n}} else {\nvar _STAR_out_STAR__orig_val__24499_28399 \x3d cljs.core._STAR_out_STAR_;\nvar _STAR_out_STAR__temp_val__24500_28400 \x3d base_writer;\n(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__temp_val__24500_28400);\n\ntry{cljs.pprint.pr.call(null, object);\n}finally {(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__orig_val__24499_28399);\n}}\n\nif(optval \x3d\x3d\x3d true){\ncljs.core.string_print(cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb));\n} else {\n}\n\nif((optval \x3d\x3d null)){\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb);\n} else {\nreturn null;\n}\n}finally {}}finally {(cljs.pprint._STAR_print_suppress_namespaces_STAR_ \x3d _STAR_print_suppress_namespaces_STAR__orig_val__24383);\n\n(cljs.pprint._STAR_print_right_margin_STAR_ \x3d _STAR_print_right_margin_STAR__orig_val__24382);\n\n(cljs.core._STAR_print_readably_STAR_ \x3d _STAR_print_readably_STAR__orig_val__24381);\n\n(cljs.pprint._STAR_print_radix_STAR_ \x3d _STAR_print_radix_STAR__orig_val__24380);\n\n(cljs.pprint._STAR_print_pretty_STAR_ \x3d _STAR_print_pretty_STAR__orig_val__24379);\n\n(cljs.pprint._STAR_print_pprint_dispatch_STAR_ \x3d _STAR_print_pprint_dispatch_STAR__orig_val__24378);\n\n(cljs.pprint._STAR_print_miser_width_STAR_ \x3d _STAR_print_miser_width_STAR__orig_val__24377);\n\n(cljs.pprint._STAR_print_lines_STAR_ \x3d _STAR_print_lines_STAR__orig_val__24376);\n\n(cljs.core._STAR_print_level_STAR_ \x3d _STAR_print_level_STAR__orig_val__24375);\n\n(cljs.core._STAR_print_length_STAR_ \x3d _STAR_print_length_STAR__orig_val__24374);\n\n(cljs.pprint._STAR_print_circle_STAR_ \x3d _STAR_print_circle_STAR__orig_val__24373);\n\n(cljs.pprint._STAR_print_base_STAR_ \x3d _STAR_print_base_STAR__orig_val__24372);\n}}));\n\n(cljs.pprint.write.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(cljs.pprint.write.cljs$lang$applyTo \x3d (function (seq24294){\nvar G__24295 \x3d cljs.core.first(seq24294);\nvar seq24294__$1 \x3d cljs.core.next(seq24294);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__24295,seq24294__$1);\n}));\n\ncljs.pprint.pprint \x3d (function cljs$pprint$pprint(var_args){\nvar G__24517 \x3d arguments.length;\nswitch (G__24517) {\ncase 1:\nreturn cljs.pprint.pprint.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.pprint.pprint.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.pprint.pprint.cljs$core$IFn$_invoke$arity$1 \x3d (function (object){\nvar sb \x3d (new goog.string.StringBuffer());\nvar _STAR_out_STAR__orig_val__24522 \x3d cljs.core._STAR_out_STAR_;\nvar _STAR_out_STAR__temp_val__24523 \x3d (new cljs.core.StringBufferWriter(sb));\n(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__temp_val__24523);\n\ntry{cljs.pprint.pprint.cljs$core$IFn$_invoke$arity$2(object,cljs.core._STAR_out_STAR_);\n\nreturn cljs.core.string_print(cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb));\n}finally {(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__orig_val__24522);\n}}));\n\n(cljs.pprint.pprint.cljs$core$IFn$_invoke$arity$2 \x3d (function (object,writer){\nvar base_writer__21599__auto__ \x3d writer;\nvar new_writer__21600__auto__ \x3d cljs.core.not(cljs.pprint.pretty_writer_QMARK_(base_writer__21599__auto__));\nvar _STAR_out_STAR__orig_val__24528 \x3d cljs.core._STAR_out_STAR_;\nvar _STAR_out_STAR__temp_val__24529 \x3d ((new_writer__21600__auto__)?cljs.pprint.make_pretty_writer(base_writer__21599__auto__,cljs.pprint._STAR_print_right_margin_STAR_,cljs.pprint._STAR_print_miser_width_STAR_):base_writer__21599__auto__);\n(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__temp_val__24529);\n\ntry{var _STAR_print_pretty_STAR__orig_val__24533_28409 \x3d cljs.pprint._STAR_print_pretty_STAR_;\nvar _STAR_print_pretty_STAR__temp_val__24534_28410 \x3d true;\n(cljs.pprint._STAR_print_pretty_STAR_ \x3d _STAR_print_pretty_STAR__temp_val__24534_28410);\n\ntry{cljs.pprint.write_out(object);\n}finally {(cljs.pprint._STAR_print_pretty_STAR_ \x3d _STAR_print_pretty_STAR__orig_val__24533_28409);\n}\nif((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((0),cljs.pprint.get_column(cljs.core._STAR_out_STAR_))))){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22\\n\x22);\n} else {\n}\n\nreturn cljs.pprint._ppflush(cljs.core._STAR_out_STAR_);\n}finally {(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__orig_val__24528);\n}}));\n\n(cljs.pprint.pprint.cljs$lang$maxFixedArity \x3d 2);\n\ncljs.pprint.set_pprint_dispatch \x3d (function cljs$pprint$set_pprint_dispatch(function$){\n(cljs.pprint._STAR_print_pprint_dispatch_STAR_ \x3d function$);\n\nreturn null;\n});\ncljs.pprint.check_enumerated_arg \x3d (function cljs$pprint$check_enumerated_arg(arg,choices){\nif(cljs.core.not((choices.cljs$core$IFn$_invoke$arity$1 ? choices.cljs$core$IFn$_invoke$arity$1(arg) : choices.call(null, arg)))){\nthrow (new Error([\x22Bad argument: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arg),\x22. It must be one of \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(choices)].join(\x27\x27)));\n} else {\nreturn null;\n}\n});\ncljs.pprint.level_exceeded \x3d (function cljs$pprint$level_exceeded(){\nvar and__5000__auto__ \x3d cljs.core._STAR_print_level_STAR_;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (cljs.pprint._STAR_current_level_STAR_ \x3e\x3d cljs.core._STAR_print_level_STAR_);\n} else {\nreturn and__5000__auto__;\n}\n});\n/**\n * Print a conditional newline to a pretty printing stream. kind specifies if the\n *   newline is :linear, :miser, :fill, or :mandatory.\n * \n *   This function is intended for use when writing custom dispatch functions.\n * \n *   Output is sent to *out* which must be a pretty printing writer.\n */\ncljs.pprint.pprint_newline \x3d (function cljs$pprint$pprint_newline(kind){\ncljs.pprint.check_enumerated_arg(kind,new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22mandatory\x22,\x22mandatory\x22,542802336),null,new cljs.core.Keyword(null,\x22miser\x22,\x22miser\x22,-556060186),null,new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),null,new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697),null], null), null));\n\nreturn cljs.pprint.nl(cljs.core._STAR_out_STAR_,kind);\n});\n/**\n * Create an indent at this point in the pretty printing stream. This defines how\n * following lines are indented. relative-to can be either :block or :current depending\n * whether the indent should be computed relative to the start of the logical block or\n * the current column position. n is an offset.\n * \n * This function is intended for use when writing custom dispatch functions.\n * \n * Output is sent to *out* which must be a pretty printing writer.\n */\ncljs.pprint.pprint_indent \x3d (function cljs$pprint$pprint_indent(relative_to,n){\ncljs.pprint.check_enumerated_arg(relative_to,new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),null,new cljs.core.Keyword(null,\x22current\x22,\x22current\x22,-1088038603),null], null), null));\n\nreturn cljs.pprint.indent(cljs.core._STAR_out_STAR_,relative_to,n);\n});\n/**\n * Tab at this point in the pretty printing stream. kind specifies whether the tab\n * is :line, :section, :line-relative, or :section-relative.\n * \n * Colnum and colinc specify the target column and the increment to move the target\n * forward if the output is already past the original target.\n * \n * This function is intended for use when writing custom dispatch functions.\n * \n * Output is sent to *out* which must be a pretty printing writer.\n * \n * THIS FUNCTION IS NOT YET IMPLEMENTED.\n */\ncljs.pprint.pprint_tab \x3d (function cljs$pprint$pprint_tab(kind,colnum,colinc){\ncljs.pprint.check_enumerated_arg(kind,new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22section\x22,\x22section\x22,-300141526),null,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),null,new cljs.core.Keyword(null,\x22line-relative\x22,\x22line-relative\x22,1149548219),null,new cljs.core.Keyword(null,\x22section-relative\x22,\x22section-relative\x22,-658298724),null], null), null));\n\nthrow (new Error(\x22pprint-tab is not yet implemented\x22));\n});\n/**\n * An implementation of a Common Lisp compatible format function. cl-format formats its\n * arguments to an output stream or string based on the format control string given. It\n * supports sophisticated formatting of structured data.\n * \n * Writer satisfies IWriter, true to output via *print-fn* or nil to output\n * to a string, format-in is the format control string and the remaining arguments\n * are the data to be formatted.\n * \n * The format control string is a string to be output with embedded \x27format directives\x27\n * describing how to format the various arguments passed in.\n * \n * If writer is nil, cl-format returns the formatted result string. Otherwise, cl-format\n * returns nil.\n * \n * For example:\n *  (let [results [46 38 22]]\n *      (cl-format true \x22There ~[are~;is~:;are~]~:* ~d result~:p: ~{~d~^, ~}~%\x22\n *                 (count results) results))\n * \n * Prints via *print-fn*:\n *  There are 3 results: 46, 38, 22\n * \n * Detailed documentation on format control strings is available in the \x22Common Lisp the\n * Language, 2nd edition\x22, Chapter 22 (available online at:\n * http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node200.html#SECTION002633000000000000000)\n * and in the Common Lisp HyperSpec at\n * http://www.lispworks.com/documentation/HyperSpec/Body/22_c.htm\n */\ncljs.pprint.cl_format \x3d (function cljs$pprint$cl_format(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___28420 \x3d arguments.length;\nvar i__5727__auto___28421 \x3d (0);\nwhile(true){\nif((i__5727__auto___28421 \x3c len__5726__auto___28420)){\nargs__5732__auto__.push((arguments[i__5727__auto___28421]));\n\nvar G__28422 \x3d (i__5727__auto___28421 + (1));\ni__5727__auto___28421 \x3d G__28422;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((2) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((2)),(0),null)):null);\nreturn cljs.pprint.cl_format.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5733__auto__);\n});\n\n(cljs.pprint.cl_format.cljs$core$IFn$_invoke$arity$variadic \x3d (function (writer,format_in,args){\nvar compiled_format \x3d ((typeof format_in \x3d\x3d\x3d \x27string\x27)?cljs.pprint.compile_format(format_in):format_in);\nvar navigator__$1 \x3d cljs.pprint.init_navigator(args);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$3(writer,compiled_format,navigator__$1);\n}));\n\n(cljs.pprint.cl_format.cljs$lang$maxFixedArity \x3d (2));\n\n/** @this {Function} */\n(cljs.pprint.cl_format.cljs$lang$applyTo \x3d (function (seq24567){\nvar G__24571 \x3d cljs.core.first(seq24567);\nvar seq24567__$1 \x3d cljs.core.next(seq24567);\nvar G__24572 \x3d cljs.core.first(seq24567__$1);\nvar seq24567__$2 \x3d cljs.core.next(seq24567__$1);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__24571,G__24572,seq24567__$2);\n}));\n\ncljs.pprint._STAR_format_str_STAR_ \x3d null;\ncljs.pprint.format_error \x3d (function cljs$pprint$format_error(message,offset){\nvar full_message \x3d [cljs.core.str.cljs$core$IFn$_invoke$arity$1(message),\x22\\n\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.pprint._STAR_format_str_STAR_),\x22\\n\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(offset,\x22 \x22))),\x22^\x22,\x22\\n\x22].join(\x27\x27);\nthrow Error(full_message);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.arg_navigator \x3d (function (seq,rest,pos,__meta,__extmap,__hash){\nthis.seq \x3d seq;\nthis.rest \x3d rest;\nthis.pos \x3d pos;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.arg_navigator.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k24599,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__24613 \x3d k24599;\nvar G__24613__$1 \x3d (((G__24613 instanceof cljs.core.Keyword))?G__24613.fqn:null);\nswitch (G__24613__$1) {\ncase \x22seq\x22:\nreturn self__.seq;\n\nbreak;\ncase \x22rest\x22:\nreturn self__.rest;\n\nbreak;\ncase \x22pos\x22:\nreturn self__.pos;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k24599,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__24624){\nvar vec__24625 \x3d p__24624;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24625,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24625,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.arg-navigator{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783),self__.seq],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419),self__.rest],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),self__.pos],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__24598){\nvar self__ \x3d this;\nvar G__24598__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__24598__$1,3,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783),new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419),new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.arg_navigator(self__.seq,self__.rest,self__.pos,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (3 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (-402038447 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this24600,other24601){\nvar self__ \x3d this;\nvar this24600__$1 \x3d this;\nreturn (((!((other24601 \x3d\x3d null)))) \x26\x26 ((((this24600__$1.constructor \x3d\x3d\x3d other24601.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24600__$1.seq,other24601.seq)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24600__$1.rest,other24601.rest)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24600__$1.pos,other24601.pos)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24600__$1.__extmap,other24601.__extmap)))))))))));\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),null,new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783),null,new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.arg_navigator(self__.seq,self__.rest,self__.pos,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k24599){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__24660 \x3d k24599;\nvar G__24660__$1 \x3d (((G__24660 instanceof cljs.core.Keyword))?G__24660.fqn:null);\nswitch (G__24660__$1) {\ncase \x22seq\x22:\ncase \x22rest\x22:\ncase \x22pos\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k24599);\n\n}\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__24598){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__24664 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__24665 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__24664.cljs$core$IFn$_invoke$arity$2 ? pred__24664.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783),expr__24665) : pred__24664.call(null, new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783),expr__24665)))){\nreturn (new cljs.pprint.arg_navigator(G__24598,self__.rest,self__.pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__24664.cljs$core$IFn$_invoke$arity$2 ? pred__24664.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419),expr__24665) : pred__24664.call(null, new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419),expr__24665)))){\nreturn (new cljs.pprint.arg_navigator(self__.seq,G__24598,self__.pos,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__24664.cljs$core$IFn$_invoke$arity$2 ? pred__24664.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),expr__24665) : pred__24664.call(null, new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),expr__24665)))){\nreturn (new cljs.pprint.arg_navigator(self__.seq,self__.rest,G__24598,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.arg_navigator(self__.seq,self__.rest,self__.pos,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__24598),null));\n}\n}\n}\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783),self__.seq,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419),self__.rest,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220),self__.pos,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__24598){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.arg_navigator(self__.seq,self__.rest,self__.pos,G__24598,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.arg_navigator.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.arg_navigator.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22seq\x22,\x22seq\x22,-177272256,null),new cljs.core.Symbol(null,\x22rest\x22,\x22rest\x22,398835108,null),new cljs.core.Symbol(null,\x22pos\x22,\x22pos\x22,775924307,null)], null);\n}));\n\n(cljs.pprint.arg_navigator.cljs$lang$type \x3d true);\n\n(cljs.pprint.arg_navigator.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/arg-navigator\x22,null,(1),null));\n}));\n\n(cljs.pprint.arg_navigator.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/arg-navigator\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/arg-navigator.\n */\ncljs.pprint.__GT_arg_navigator \x3d (function cljs$pprint$__GT_arg_navigator(seq,rest,pos){\nreturn (new cljs.pprint.arg_navigator(seq,rest,pos,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/arg-navigator, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_arg_navigator \x3d (function cljs$pprint$map__GT_arg_navigator(G__24605){\nvar extmap__5342__auto__ \x3d (function (){var G__24683 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__24605,new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419),new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220)], 0));\nif(cljs.core.record_QMARK_(G__24605)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__24683);\n} else {\nreturn G__24683;\n}\n})();\nreturn (new cljs.pprint.arg_navigator(new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783).cljs$core$IFn$_invoke$arity$1(G__24605),new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(G__24605),new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(G__24605),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\n/**\n * Create a new arg-navigator from the sequence with the position set to 0\n */\ncljs.pprint.init_navigator \x3d (function cljs$pprint$init_navigator(s){\nvar s__$1 \x3d cljs.core.seq(s);\nreturn (new cljs.pprint.arg_navigator(s__$1,s__$1,(0),null,null,null));\n});\ncljs.pprint.next_arg \x3d (function cljs$pprint$next_arg(navigator){\nvar rst \x3d new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(navigator);\nif(cljs.core.truth_(rst)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(rst),(new cljs.pprint.arg_navigator(new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783).cljs$core$IFn$_invoke$arity$1(navigator),cljs.core.next(rst),(new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(navigator) + (1)),null,null,null))], null);\n} else {\nthrow Error(\x22Not enough arguments for format definition\x22);\n}\n});\ncljs.pprint.next_arg_or_nil \x3d (function cljs$pprint$next_arg_or_nil(navigator){\nvar rst \x3d new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(navigator);\nif(cljs.core.truth_(rst)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(rst),(new cljs.pprint.arg_navigator(new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783).cljs$core$IFn$_invoke$arity$1(navigator),cljs.core.next(rst),(new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(navigator) + (1)),null,null,null))], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,navigator], null);\n}\n});\ncljs.pprint.get_format_arg \x3d (function cljs$pprint$get_format_arg(navigator){\nvar vec__24694 \x3d cljs.pprint.next_arg(navigator);\nvar raw_format \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24694,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24694,(1),null);\nvar compiled_format \x3d ((typeof raw_format \x3d\x3d\x3d \x27string\x27)?cljs.pprint.compile_format(raw_format):raw_format);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [compiled_format,navigator__$1], null);\n});\ncljs.pprint.absolute_reposition \x3d (function cljs$pprint$absolute_reposition(navigator,position){\nif((position \x3e\x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(navigator))){\nvar G__24701 \x3d navigator;\nvar G__24702 \x3d (new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(navigator) - position);\nreturn (cljs.pprint.relative_reposition.cljs$core$IFn$_invoke$arity$2 ? cljs.pprint.relative_reposition.cljs$core$IFn$_invoke$arity$2(G__24701,G__24702) : cljs.pprint.relative_reposition.call(null, G__24701,G__24702));\n} else {\nreturn (new cljs.pprint.arg_navigator(new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783).cljs$core$IFn$_invoke$arity$1(navigator),cljs.core.drop.cljs$core$IFn$_invoke$arity$2(position,new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783).cljs$core$IFn$_invoke$arity$1(navigator)),position,null,null,null));\n}\n});\ncljs.pprint.relative_reposition \x3d (function cljs$pprint$relative_reposition(navigator,position){\nvar newpos \x3d (new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(navigator) + position);\nif((position \x3c (0))){\nreturn cljs.pprint.absolute_reposition(navigator,newpos);\n} else {\nreturn (new cljs.pprint.arg_navigator(new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783).cljs$core$IFn$_invoke$arity$1(navigator),cljs.core.drop.cljs$core$IFn$_invoke$arity$2(position,new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(navigator)),newpos,null,null,null));\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\ncljs.pprint.compiled_directive \x3d (function (func,def,params,offset,__meta,__extmap,__hash){\nthis.func \x3d func;\nthis.def \x3d def;\nthis.params \x3d params;\nthis.offset \x3d offset;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(cljs.pprint.compiled_directive.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k24706,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__24717 \x3d k24706;\nvar G__24717__$1 \x3d (((G__24717 instanceof cljs.core.Keyword))?G__24717.fqn:null);\nswitch (G__24717__$1) {\ncase \x22func\x22:\nreturn self__.func;\n\nbreak;\ncase \x22def\x22:\nreturn self__.def;\n\nbreak;\ncase \x22params\x22:\nreturn self__.params;\n\nbreak;\ncase \x22offset\x22:\nreturn self__.offset;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k24706,else__5303__auto__);\n\n}\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__24718){\nvar vec__24719 \x3d p__24718;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24719,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24719,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#cljs.pprint.compiled-directive{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040),self__.func],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536),self__.def],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),self__.params],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),self__.offset],null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__24705){\nvar self__ \x3d this;\nvar G__24705__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__24705__$1,4,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040),new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536),new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new cljs.pprint.compiled_directive(self__.func,self__.def,self__.params,self__.offset,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (4 + cljs.core.count(self__.__extmap));\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (-829256337 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this24707,other24708){\nvar self__ \x3d this;\nvar this24707__$1 \x3d this;\nreturn (((!((other24708 \x3d\x3d null)))) \x26\x26 ((((this24707__$1.constructor \x3d\x3d\x3d other24708.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24707__$1.func,other24708.func)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24707__$1.def,other24708.def)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24707__$1.params,other24708.params)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24707__$1.offset,other24708.offset)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this24707__$1.__extmap,other24708.__extmap)))))))))))));\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),null,new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040),null,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),null,new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new cljs.pprint.compiled_directive(self__.func,self__.def,self__.params,self__.offset,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k24706){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__24748 \x3d k24706;\nvar G__24748__$1 \x3d (((G__24748 instanceof cljs.core.Keyword))?G__24748.fqn:null);\nswitch (G__24748__$1) {\ncase \x22func\x22:\ncase \x22def\x22:\ncase \x22params\x22:\ncase \x22offset\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k24706);\n\n}\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__24705){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__24751 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__24752 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__24751.cljs$core$IFn$_invoke$arity$2 ? pred__24751.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040),expr__24752) : pred__24751.call(null, new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040),expr__24752)))){\nreturn (new cljs.pprint.compiled_directive(G__24705,self__.def,self__.params,self__.offset,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__24751.cljs$core$IFn$_invoke$arity$2 ? pred__24751.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536),expr__24752) : pred__24751.call(null, new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536),expr__24752)))){\nreturn (new cljs.pprint.compiled_directive(self__.func,G__24705,self__.params,self__.offset,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__24751.cljs$core$IFn$_invoke$arity$2 ? pred__24751.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),expr__24752) : pred__24751.call(null, new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),expr__24752)))){\nreturn (new cljs.pprint.compiled_directive(self__.func,self__.def,G__24705,self__.offset,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__24751.cljs$core$IFn$_invoke$arity$2 ? pred__24751.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),expr__24752) : pred__24751.call(null, new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),expr__24752)))){\nreturn (new cljs.pprint.compiled_directive(self__.func,self__.def,self__.params,G__24705,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new cljs.pprint.compiled_directive(self__.func,self__.def,self__.params,self__.offset,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__24705),null));\n}\n}\n}\n}\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040),self__.func,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536),self__.def,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),self__.params,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311),self__.offset,null))], null),self__.__extmap));\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__24705){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new cljs.pprint.compiled_directive(self__.func,self__.def,self__.params,self__.offset,G__24705,self__.__extmap,self__.__hash));\n}));\n\n(cljs.pprint.compiled_directive.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(cljs.pprint.compiled_directive.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22func\x22,\x22func\x22,1401825487,null),new cljs.core.Symbol(null,\x22def\x22,\x22def\x22,597100991,null),new cljs.core.Symbol(null,\x22params\x22,\x22params\x22,-1943919534,null),new cljs.core.Symbol(null,\x22offset\x22,\x22offset\x22,1937029838,null)], null);\n}));\n\n(cljs.pprint.compiled_directive.cljs$lang$type \x3d true);\n\n(cljs.pprint.compiled_directive.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22cljs.pprint/compiled-directive\x22,null,(1),null));\n}));\n\n(cljs.pprint.compiled_directive.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22cljs.pprint/compiled-directive\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/compiled-directive.\n */\ncljs.pprint.__GT_compiled_directive \x3d (function cljs$pprint$__GT_compiled_directive(func,def,params,offset){\nreturn (new cljs.pprint.compiled_directive(func,def,params,offset,null,null,null));\n});\n\n/**\n * Factory function for cljs.pprint/compiled-directive, taking a map of keywords to field values.\n */\ncljs.pprint.map__GT_compiled_directive \x3d (function cljs$pprint$map__GT_compiled_directive(G__24713){\nvar extmap__5342__auto__ \x3d (function (){var G__24797 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__24713,new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536),new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311)], 0));\nif(cljs.core.record_QMARK_(G__24713)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__24797);\n} else {\nreturn G__24797;\n}\n})();\nreturn (new cljs.pprint.compiled_directive(new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040).cljs$core$IFn$_invoke$arity$1(G__24713),new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(G__24713),new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(G__24713),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311).cljs$core$IFn$_invoke$arity$1(G__24713),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\ncljs.pprint.realize_parameter \x3d (function cljs$pprint$realize_parameter(p__24809,navigator){\nvar vec__24815 \x3d p__24809;\nvar param \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24815,(0),null);\nvar vec__24818 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24815,(1),null);\nvar raw_val \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24818,(0),null);\nvar offset \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24818,(1),null);\nvar vec__24829 \x3d ((cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),param))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [raw_val,navigator], null):((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(raw_val,new cljs.core.Keyword(null,\x22parameter-from-args\x22,\x22parameter-from-args\x22,-758446196)))?cljs.pprint.next_arg(navigator):((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(raw_val,new cljs.core.Keyword(null,\x22remaining-arg-count\x22,\x22remaining-arg-count\x22,-1216589335)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.count(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(navigator)),navigator], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [raw_val,navigator], null)\n)));\nvar real_param \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24829,(0),null);\nvar new_navigator \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24829,(1),null);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [param,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [real_param,offset], null)], null),new_navigator], null);\n});\ncljs.pprint.realize_parameter_list \x3d (function cljs$pprint$realize_parameter_list(parameter_map,navigator){\nvar vec__24883 \x3d cljs.pprint.map_passing_context(cljs.pprint.realize_parameter,navigator,parameter_map);\nvar pairs \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24883,(0),null);\nvar new_navigator \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24883,(1),null);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,pairs),new_navigator], null);\n});\ncljs.pprint.special_radix_markers \x3d new cljs.core.PersistentArrayMap(null, 3, [(2),\x22#b\x22,(8),\x22#o\x22,(16),\x22#x\x22], null);\ncljs.pprint.format_simple_number \x3d (function cljs$pprint$format_simple_number(n){\nif(cljs.core.integer_QMARK_(n)){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.pprint._STAR_print_base_STAR_,(10))){\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),(cljs.core.truth_(cljs.pprint._STAR_print_radix_STAR_)?\x22.\x22:null)].join(\x27\x27);\n} else {\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_(cljs.pprint._STAR_print_radix_STAR_)?(function (){var or__5002__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.pprint.special_radix_markers,cljs.pprint._STAR_print_base_STAR_);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn [\x22#\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.pprint._STAR_print_base_STAR_),\x22r\x22].join(\x27\x27);\n}\n})():null)),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.pprint.opt_base_str(cljs.pprint._STAR_print_base_STAR_,n))].join(\x27\x27);\n}\n} else {\nreturn null;\n\n}\n});\ncljs.pprint.format_ascii \x3d (function cljs$pprint$format_ascii(print_func,params,arg_navigator,offsets){\nvar vec__24899 \x3d cljs.pprint.next_arg(arg_navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24899,(0),null);\nvar arg_navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24899,(1),null);\nvar base_output \x3d (function (){var or__5002__auto__ \x3d cljs.pprint.format_simple_number(arg);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (print_func.cljs$core$IFn$_invoke$arity$1 ? print_func.cljs$core$IFn$_invoke$arity$1(arg) : print_func.call(null, arg));\n}\n})();\nvar base_width \x3d base_output.length;\nvar min_width \x3d (base_width + new cljs.core.Keyword(null,\x22minpad\x22,\x22minpad\x22,323570901).cljs$core$IFn$_invoke$arity$1(params));\nvar width \x3d (((min_width \x3e\x3d new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445).cljs$core$IFn$_invoke$arity$1(params)))?min_width:(min_width + ((cljs.core.quot(((new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445).cljs$core$IFn$_invoke$arity$1(params) - min_width) - (1)),new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385).cljs$core$IFn$_invoke$arity$1(params)) + (1)) * new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385).cljs$core$IFn$_invoke$arity$1(params))));\nvar chars \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((width - base_width),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params)));\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[cljs.core.str.cljs$core$IFn$_invoke$arity$1(chars),cljs.core.str.cljs$core$IFn$_invoke$arity$1(base_output)].join(\x27\x27)], 0));\n} else {\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[cljs.core.str.cljs$core$IFn$_invoke$arity$1(base_output),cljs.core.str.cljs$core$IFn$_invoke$arity$1(chars)].join(\x27\x27)], 0));\n}\n\nreturn arg_navigator__$1;\n});\n/**\n * returns true if a number is actually an integer (that is, has no fractional part)\n */\ncljs.pprint.integral_QMARK_ \x3d (function cljs$pprint$integral_QMARK_(x){\nif(cljs.core.integer_QMARK_(x)){\nreturn true;\n} else {\nif(cljs.pprint.float_QMARK_(x)){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,Math.floor(x));\n} else {\nreturn false;\n\n}\n}\n});\n/**\n * Return the list of remainders (essentially the \x27digits\x27) of val in the given base\n */\ncljs.pprint.remainders \x3d (function cljs$pprint$remainders(base,val){\nreturn cljs.core.reverse(cljs.core.first(cljs.pprint.consume((function (p1__24918_SHARP_){\nif((p1__24918_SHARP_ \x3e (0))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.rem(p1__24918_SHARP_,base),cljs.core.quot(p1__24918_SHARP_,base)], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null], null);\n}\n}),val)));\n});\n/**\n * Return val as a string in the given base\n */\ncljs.pprint.base_str \x3d (function cljs$pprint$base_str(base,val){\nif((val \x3d\x3d\x3d (0))){\nreturn \x220\x22;\n} else {\nvar xlated_val \x3d val\n;\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__24922_SHARP_){\nif((p1__24922_SHARP_ \x3c (10))){\nreturn cljs.core.char$((cljs.pprint.char_code(\x220\x22) + p1__24922_SHARP_));\n} else {\nreturn cljs.core.char$((cljs.pprint.char_code(\x22a\x22) + (p1__24922_SHARP_ - (10))));\n}\n}),cljs.pprint.remainders(base,val)));\n}\n});\ncljs.pprint.javascript_base_formats \x3d new cljs.core.PersistentArrayMap(null, 3, [(8),\x22%o\x22,(10),\x22%d\x22,(16),\x22%x\x22], null);\n/**\n * Return val as a string in the given base. No cljs format, so no improved performance.\n */\ncljs.pprint.opt_base_str \x3d (function cljs$pprint$opt_base_str(base,val){\nreturn cljs.pprint.base_str(base,val);\n});\ncljs.pprint.group_by_STAR_ \x3d (function cljs$pprint$group_by_STAR_(unit,lis){\nreturn cljs.core.reverse(cljs.core.first(cljs.pprint.consume((function (x){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.seq(cljs.core.reverse(cljs.core.take.cljs$core$IFn$_invoke$arity$2(unit,x))),cljs.core.seq(cljs.core.drop.cljs$core$IFn$_invoke$arity$2(unit,x))], null);\n}),cljs.core.reverse(lis))));\n});\ncljs.pprint.format_integer \x3d (function cljs$pprint$format_integer(base,params,arg_navigator,offsets){\nvar vec__24939 \x3d cljs.pprint.next_arg(arg_navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24939,(0),null);\nvar arg_navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24939,(1),null);\nif(cljs.pprint.integral_QMARK_(arg)){\nvar neg_28515 \x3d (arg \x3c (0));\nvar pos_arg_28516 \x3d ((neg_28515)?(- arg):arg);\nvar raw_str_28517 \x3d cljs.pprint.opt_base_str(base,pos_arg_28516);\nvar group_str_28518 \x3d (cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?(function (){var groups \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__24934_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,p1__24934_SHARP_);\n}),cljs.pprint.group_by_STAR_(new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083).cljs$core$IFn$_invoke$arity$1(params),raw_str_28517));\nvar commas \x3d cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(cljs.core.count(groups),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327).cljs$core$IFn$_invoke$arity$1(params));\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.next(cljs.core.interleave.cljs$core$IFn$_invoke$arity$2(commas,groups)));\n})():raw_str_28517);\nvar signed_str_28519 \x3d ((neg_28515)?[\x22-\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(group_str_28518)].join(\x27\x27):(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))?[\x22+\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(group_str_28518)].join(\x27\x27):group_str_28518\n));\nvar padded_str_28520 \x3d (((signed_str_28519.length \x3c new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445).cljs$core$IFn$_invoke$arity$1(params)))?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445).cljs$core$IFn$_invoke$arity$1(params) - signed_str_28519.length),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params)))),cljs.core.str.cljs$core$IFn$_invoke$arity$1(signed_str_28519)].join(\x27\x27):signed_str_28519);\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([padded_str_28520], 0));\n} else {\ncljs.pprint.format_ascii(cljs.core.print_str,new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445).cljs$core$IFn$_invoke$arity$1(params),new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385),(1),new cljs.core.Keyword(null,\x22minpad\x22,\x22minpad\x22,323570901),(0),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params),new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),true], null),cljs.pprint.init_navigator(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [arg], null)),null);\n}\n\nreturn arg_navigator__$1;\n});\ncljs.pprint.english_cardinal_units \x3d new cljs.core.PersistentVector(null, 20, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22zero\x22,\x22one\x22,\x22two\x22,\x22three\x22,\x22four\x22,\x22five\x22,\x22six\x22,\x22seven\x22,\x22eight\x22,\x22nine\x22,\x22ten\x22,\x22eleven\x22,\x22twelve\x22,\x22thirteen\x22,\x22fourteen\x22,\x22fifteen\x22,\x22sixteen\x22,\x22seventeen\x22,\x22eighteen\x22,\x22nineteen\x22], null);\ncljs.pprint.english_ordinal_units \x3d new cljs.core.PersistentVector(null, 20, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22zeroth\x22,\x22first\x22,\x22second\x22,\x22third\x22,\x22fourth\x22,\x22fifth\x22,\x22sixth\x22,\x22seventh\x22,\x22eighth\x22,\x22ninth\x22,\x22tenth\x22,\x22eleventh\x22,\x22twelfth\x22,\x22thirteenth\x22,\x22fourteenth\x22,\x22fifteenth\x22,\x22sixteenth\x22,\x22seventeenth\x22,\x22eighteenth\x22,\x22nineteenth\x22], null);\ncljs.pprint.english_cardinal_tens \x3d new cljs.core.PersistentVector(null, 10, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22\x22,\x22\x22,\x22twenty\x22,\x22thirty\x22,\x22forty\x22,\x22fifty\x22,\x22sixty\x22,\x22seventy\x22,\x22eighty\x22,\x22ninety\x22], null);\ncljs.pprint.english_ordinal_tens \x3d new cljs.core.PersistentVector(null, 10, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22\x22,\x22\x22,\x22twentieth\x22,\x22thirtieth\x22,\x22fortieth\x22,\x22fiftieth\x22,\x22sixtieth\x22,\x22seventieth\x22,\x22eightieth\x22,\x22ninetieth\x22], null);\ncljs.pprint.english_scale_numbers \x3d new cljs.core.PersistentVector(null, 22, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22\x22,\x22thousand\x22,\x22million\x22,\x22billion\x22,\x22trillion\x22,\x22quadrillion\x22,\x22quintillion\x22,\x22sextillion\x22,\x22septillion\x22,\x22octillion\x22,\x22nonillion\x22,\x22decillion\x22,\x22undecillion\x22,\x22duodecillion\x22,\x22tredecillion\x22,\x22quattuordecillion\x22,\x22quindecillion\x22,\x22sexdecillion\x22,\x22septendecillion\x22,\x22octodecillion\x22,\x22novemdecillion\x22,\x22vigintillion\x22], null);\n/**\n * Convert a number less than 1000 to a cardinal english string\n */\ncljs.pprint.format_simple_cardinal \x3d (function cljs$pprint$format_simple_cardinal(num){\nvar hundreds \x3d cljs.core.quot(num,(100));\nvar tens \x3d cljs.core.rem(num,(100));\nreturn [(((hundreds \x3e (0)))?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_cardinal_units,hundreds)),\x22 hundred\x22].join(\x27\x27):null),(((((hundreds \x3e (0))) \x26\x26 ((tens \x3e (0)))))?\x22 \x22:null),cljs.core.str.cljs$core$IFn$_invoke$arity$1((((tens \x3e (0)))?(((tens \x3c (20)))?cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_cardinal_units,tens):(function (){var ten_digit \x3d cljs.core.quot(tens,(10));\nvar unit_digit \x3d cljs.core.rem(tens,(10));\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1((((ten_digit \x3e (0)))?cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_cardinal_tens,ten_digit):null)),(((((ten_digit \x3e (0))) \x26\x26 ((unit_digit \x3e (0)))))?\x22-\x22:null),cljs.core.str.cljs$core$IFn$_invoke$arity$1((((unit_digit \x3e (0)))?cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_cardinal_units,unit_digit):null))].join(\x27\x27);\n})()):null))].join(\x27\x27);\n});\n/**\n * Take a sequence of parts, add scale numbers (e.g., million) and combine into a string\n *   offset is a factor of 10^3 to multiply by\n */\ncljs.pprint.add_english_scales \x3d (function cljs$pprint$add_english_scales(parts,offset){\nvar cnt \x3d cljs.core.count(parts);\nvar acc \x3d cljs.core.PersistentVector.EMPTY;\nvar pos \x3d (cnt - (1));\nvar this$ \x3d cljs.core.first(parts);\nvar remainder \x3d cljs.core.next(parts);\nwhile(true){\nif((remainder \x3d\x3d null)){\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(\x22, \x22,acc))),(((((!(cljs.core.empty_QMARK_(this$)))) \x26\x26 ((!(cljs.core.empty_QMARK_(acc))))))?\x22, \x22:null),cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$),(((((!(cljs.core.empty_QMARK_(this$)))) \x26\x26 (((pos + offset) \x3e (0)))))?[\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_scale_numbers,(pos + offset)))].join(\x27\x27):null)].join(\x27\x27);\n} else {\nvar G__28523 \x3d ((cljs.core.empty_QMARK_(this$))?acc:cljs.core.conj.cljs$core$IFn$_invoke$arity$2(acc,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$),\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_scale_numbers,(pos + offset)))].join(\x27\x27)));\nvar G__28527 \x3d (pos - (1));\nvar G__28528 \x3d cljs.core.first(remainder);\nvar G__28529 \x3d cljs.core.next(remainder);\nacc \x3d G__28523;\npos \x3d G__28527;\nthis$ \x3d G__28528;\nremainder \x3d G__28529;\ncontinue;\n}\nbreak;\n}\n});\ncljs.pprint.format_cardinal_english \x3d (function cljs$pprint$format_cardinal_english(params,navigator,offsets){\nvar vec__24985 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24985,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24985,(1),null);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((0),arg)){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22zero\x22], 0));\n} else {\nvar abs_arg_28530 \x3d (((arg \x3c (0)))?(- arg):arg);\nvar parts_28531 \x3d cljs.pprint.remainders((1000),abs_arg_28530);\nif((cljs.core.count(parts_28531) \x3c\x3d cljs.core.count(cljs.pprint.english_scale_numbers))){\nvar parts_strs_28532 \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.pprint.format_simple_cardinal,parts_28531);\nvar full_str_28533 \x3d cljs.pprint.add_english_scales(parts_strs_28532,(0));\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[(((arg \x3c (0)))?\x22minus \x22:null),full_str_28533].join(\x27\x27)], 0));\n} else {\ncljs.pprint.format_integer((10),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),(0),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),\x22 \x22,new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),\x22,\x22,new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),(3),new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),true], null),cljs.pprint.init_navigator(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [arg], null)),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),(0),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),(0),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),(0),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),(0)], null));\n}\n}\n\nreturn navigator__$1;\n});\n/**\n * Convert a number less than 1000 to a ordinal english string\n *   Note this should only be used for the last one in the sequence\n */\ncljs.pprint.format_simple_ordinal \x3d (function cljs$pprint$format_simple_ordinal(num){\nvar hundreds \x3d cljs.core.quot(num,(100));\nvar tens \x3d cljs.core.rem(num,(100));\nreturn [(((hundreds \x3e (0)))?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_cardinal_units,hundreds)),\x22 hundred\x22].join(\x27\x27):null),(((((hundreds \x3e (0))) \x26\x26 ((tens \x3e (0)))))?\x22 \x22:null),cljs.core.str.cljs$core$IFn$_invoke$arity$1((((tens \x3e (0)))?(((tens \x3c (20)))?cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_ordinal_units,tens):(function (){var ten_digit \x3d cljs.core.quot(tens,(10));\nvar unit_digit \x3d cljs.core.rem(tens,(10));\nif((((ten_digit \x3e (0))) \x26\x26 ((!((unit_digit \x3e (0))))))){\nreturn cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_ordinal_tens,ten_digit);\n} else {\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1((((ten_digit \x3e (0)))?cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_cardinal_tens,ten_digit):null)),(((((ten_digit \x3e (0))) \x26\x26 ((unit_digit \x3e (0)))))?\x22-\x22:null),cljs.core.str.cljs$core$IFn$_invoke$arity$1((((unit_digit \x3e (0)))?cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.pprint.english_ordinal_units,unit_digit):null))].join(\x27\x27);\n}\n})()):(((hundreds \x3e (0)))?\x22th\x22:null)))].join(\x27\x27);\n});\ncljs.pprint.format_ordinal_english \x3d (function cljs$pprint$format_ordinal_english(params,navigator,offsets){\nvar vec__25006 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25006,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25006,(1),null);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((0),arg)){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22zeroth\x22], 0));\n} else {\nvar abs_arg_28534 \x3d (((arg \x3c (0)))?(- arg):arg);\nvar parts_28535 \x3d cljs.pprint.remainders((1000),abs_arg_28534);\nif((cljs.core.count(parts_28535) \x3c\x3d cljs.core.count(cljs.pprint.english_scale_numbers))){\nvar parts_strs_28536 \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.pprint.format_simple_cardinal,cljs.core.drop_last.cljs$core$IFn$_invoke$arity$1(parts_28535));\nvar head_str_28537 \x3d cljs.pprint.add_english_scales(parts_strs_28536,(1));\nvar tail_str_28538 \x3d cljs.pprint.format_simple_ordinal(cljs.core.last(parts_28535));\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[(((arg \x3c (0)))?\x22minus \x22:null),(((((!(cljs.core.empty_QMARK_(head_str_28537)))) \x26\x26 ((!(cljs.core.empty_QMARK_(tail_str_28538))))))?[head_str_28537,\x22, \x22,tail_str_28538].join(\x27\x27):(((!(cljs.core.empty_QMARK_(head_str_28537))))?[head_str_28537,\x22th\x22].join(\x27\x27):tail_str_28538\n))].join(\x27\x27)], 0));\n} else {\ncljs.pprint.format_integer((10),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),(0),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),\x22 \x22,new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),\x22,\x22,new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),(3),new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),true], null),cljs.pprint.init_navigator(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [arg], null)),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),(0),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),(0),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),(0),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),(0)], null));\n\nvar low_two_digits_28539 \x3d cljs.core.rem(arg,(100));\nvar not_teens_28540 \x3d ((((11) \x3c low_two_digits_28539)) || (((19) \x3e low_two_digits_28539)));\nvar low_digit_28541 \x3d cljs.core.rem(low_two_digits_28539,(10));\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(((((low_digit_28541 \x3d\x3d\x3d (1))) \x26\x26 (not_teens_28540)))?\x22st\x22:(((((low_digit_28541 \x3d\x3d\x3d (2))) \x26\x26 (not_teens_28540)))?\x22nd\x22:(((((low_digit_28541 \x3d\x3d\x3d (3))) \x26\x26 (not_teens_28540)))?\x22rd\x22:\x22th\x22\n)))], 0));\n}\n}\n\nreturn navigator__$1;\n});\ncljs.pprint.old_roman_table \x3d new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22I\x22,\x22II\x22,\x22III\x22,\x22IIII\x22,\x22V\x22,\x22VI\x22,\x22VII\x22,\x22VIII\x22,\x22VIIII\x22], null),new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22X\x22,\x22XX\x22,\x22XXX\x22,\x22XXXX\x22,\x22L\x22,\x22LX\x22,\x22LXX\x22,\x22LXXX\x22,\x22LXXXX\x22], null),new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22C\x22,\x22CC\x22,\x22CCC\x22,\x22CCCC\x22,\x22D\x22,\x22DC\x22,\x22DCC\x22,\x22DCCC\x22,\x22DCCCC\x22], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22M\x22,\x22MM\x22,\x22MMM\x22], null)], null);\ncljs.pprint.new_roman_table \x3d new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22I\x22,\x22II\x22,\x22III\x22,\x22IV\x22,\x22V\x22,\x22VI\x22,\x22VII\x22,\x22VIII\x22,\x22IX\x22], null),new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22X\x22,\x22XX\x22,\x22XXX\x22,\x22XL\x22,\x22L\x22,\x22LX\x22,\x22LXX\x22,\x22LXXX\x22,\x22XC\x22], null),new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22C\x22,\x22CC\x22,\x22CCC\x22,\x22CD\x22,\x22D\x22,\x22DC\x22,\x22DCC\x22,\x22DCCC\x22,\x22CM\x22], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22M\x22,\x22MM\x22,\x22MMM\x22], null)], null);\n/**\n * Format a roman numeral using the specified look-up table\n */\ncljs.pprint.format_roman \x3d (function cljs$pprint$format_roman(table,params,navigator,offsets){\nvar vec__25041 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25041,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25041,(1),null);\nif(((typeof arg \x3d\x3d\x3d \x27number\x27) \x26\x26 ((((arg \x3e (0))) \x26\x26 ((arg \x3c (4000))))))){\nvar digits_28542 \x3d cljs.pprint.remainders((10),arg);\nvar acc_28543 \x3d cljs.core.PersistentVector.EMPTY;\nvar pos_28544 \x3d (cljs.core.count(digits_28542) - (1));\nvar digits_28545__$1 \x3d digits_28542;\nwhile(true){\nif(cljs.core.empty_QMARK_(digits_28545__$1)){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,acc_28543)], 0));\n} else {\nvar digit_28549 \x3d cljs.core.first(digits_28545__$1);\nvar G__28550 \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((0),digit_28549))?acc_28543:cljs.core.conj.cljs$core$IFn$_invoke$arity$2(acc_28543,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(table,pos_28544),(digit_28549 - (1)))));\nvar G__28551 \x3d (pos_28544 - (1));\nvar G__28552 \x3d cljs.core.next(digits_28545__$1);\nacc_28543 \x3d G__28550;\npos_28544 \x3d G__28551;\ndigits_28545__$1 \x3d G__28552;\ncontinue;\n}\nbreak;\n}\n} else {\ncljs.pprint.format_integer((10),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),(0),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),\x22 \x22,new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),\x22,\x22,new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),(3),new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),true], null),cljs.pprint.init_navigator(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [arg], null)),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),(0),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),(0),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),(0),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),(0)], null));\n}\n\nreturn navigator__$1;\n});\ncljs.pprint.format_old_roman \x3d (function cljs$pprint$format_old_roman(params,navigator,offsets){\nreturn cljs.pprint.format_roman(cljs.pprint.old_roman_table,params,navigator,offsets);\n});\ncljs.pprint.format_new_roman \x3d (function cljs$pprint$format_new_roman(params,navigator,offsets){\nreturn cljs.pprint.format_roman(cljs.pprint.new_roman_table,params,navigator,offsets);\n});\ncljs.pprint.special_chars \x3d new cljs.core.PersistentArrayMap(null, 5, [(8),\x22Backspace\x22,(9),\x22Tab\x22,(10),\x22Newline\x22,(13),\x22Return\x22,(32),\x22Space\x22], null);\ncljs.pprint.pretty_character \x3d (function cljs$pprint$pretty_character(params,navigator,offsets){\nvar vec__25128 \x3d cljs.pprint.next_arg(navigator);\nvar c \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25128,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25128,(1),null);\nvar as_int \x3d cljs.pprint.char_code(c);\nvar base_char \x3d (as_int \x26 (127));\nvar meta \x3d (as_int \x26 (128));\nvar special \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.pprint.special_chars,base_char);\nif((meta \x3e (0))){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22Meta-\x22], 0));\n} else {\n}\n\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(cljs.core.truth_(special)?special:(((base_char \x3c (32)))?[\x22Control-\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.char$((base_char + (64))))].join(\x27\x27):((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(base_char,(127)))?\x22Control-?\x22:cljs.core.char$(base_char)\n)))], 0));\n\nreturn navigator__$1;\n});\ncljs.pprint.readable_character \x3d (function cljs$pprint$readable_character(params,navigator,offsets){\nvar vec__25139 \x3d cljs.pprint.next_arg(navigator);\nvar c \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25139,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25139,(1),null);\nvar pred__25142_28553 \x3d cljs.core._EQ_;\nvar expr__25143_28554 \x3d new cljs.core.Keyword(null,\x22char-format\x22,\x22char-format\x22,-1016499218).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_((function (){var G__25146 \x3d \x22o\x22;\nvar G__25147 \x3d expr__25143_28554;\nreturn (pred__25142_28553.cljs$core$IFn$_invoke$arity$2 ? pred__25142_28553.cljs$core$IFn$_invoke$arity$2(G__25146,G__25147) : pred__25142_28553.call(null, G__25146,G__25147));\n})())){\ncljs.pprint.cl_format.cljs$core$IFn$_invoke$arity$variadic(true,\x22\\\\o~3,\x270o\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.pprint.char_code(c)], 0));\n} else {\nif(cljs.core.truth_((function (){var G__25148 \x3d \x22u\x22;\nvar G__25149 \x3d expr__25143_28554;\nreturn (pred__25142_28553.cljs$core$IFn$_invoke$arity$2 ? pred__25142_28553.cljs$core$IFn$_invoke$arity$2(G__25148,G__25149) : pred__25142_28553.call(null, G__25148,G__25149));\n})())){\ncljs.pprint.cl_format.cljs$core$IFn$_invoke$arity$variadic(true,\x22\\\\u~4,\x270x\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.pprint.char_code(c)], 0));\n} else {\nif(cljs.core.truth_((pred__25142_28553.cljs$core$IFn$_invoke$arity$2 ? pred__25142_28553.cljs$core$IFn$_invoke$arity$2(null,expr__25143_28554) : pred__25142_28553.call(null, null,expr__25143_28554)))){\ncljs.pprint.print_char(c);\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__25143_28554)].join(\x27\x27)));\n}\n}\n}\n\nreturn navigator__$1;\n});\ncljs.pprint.plain_character \x3d (function cljs$pprint$plain_character(params,navigator,offsets){\nvar vec__25152 \x3d cljs.pprint.next_arg(navigator);\nvar char$ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25152,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25152,(1),null);\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([char$], 0));\n\nreturn navigator__$1;\n});\ncljs.pprint.abort_QMARK_ \x3d (function cljs$pprint$abort_QMARK_(context){\nvar token \x3d cljs.core.first(context);\nreturn ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22up-arrow\x22,\x22up-arrow\x22,1705310333),token)) || (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22colon-up-arrow\x22,\x22colon-up-arrow\x22,244853007),token)));\n});\ncljs.pprint.execute_sub_format \x3d (function cljs$pprint$execute_sub_format(format,args,base_args){\nreturn cljs.core.second(cljs.pprint.map_passing_context((function (element,context){\nif(cljs.pprint.abort_QMARK_(context)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,context], null);\n} else {\nvar vec__25176 \x3d cljs.pprint.realize_parameter_list(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(element),context);\nvar params \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25176,(0),null);\nvar args__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25176,(1),null);\nvar vec__25179 \x3d cljs.pprint.unzip_map(params);\nvar params__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25179,(0),null);\nvar offsets \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25179,(1),null);\nvar params__$2 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(params__$1,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822),base_args);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040).cljs$core$IFn$_invoke$arity$1(element),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [params__$2,args__$1,offsets], null))], null);\n}\n}),args,format));\n});\n/**\n * Produce string parts for the mantissa (normalize 1-9) and exponent\n */\ncljs.pprint.float_parts_base \x3d (function cljs$pprint$float_parts_base(f){\nvar s \x3d clojure.string.lower_case(cljs.core.str.cljs$core$IFn$_invoke$arity$1(f));\nvar exploc \x3d s.indexOf(\x22e\x22);\nvar dotloc \x3d s.indexOf(\x22.\x22);\nif((exploc \x3c (0))){\nif((dotloc \x3c (0))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [s,cljs.core.str.cljs$core$IFn$_invoke$arity$1((((s).length) - (1)))], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [[cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),dotloc),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(dotloc + (1)))].join(\x27\x27),cljs.core.str.cljs$core$IFn$_invoke$arity$1((dotloc - (1)))], null);\n}\n} else {\nif((dotloc \x3c (0))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),exploc),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(exploc + (1)))], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [[cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),(1)),cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(2),exploc)].join(\x27\x27),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(exploc + (1)))], null);\n}\n}\n});\n/**\n * Take care of leading and trailing zeros in decomposed floats\n */\ncljs.pprint.float_parts \x3d (function cljs$pprint$float_parts(f){\nvar vec__25196 \x3d cljs.pprint.float_parts_base(f);\nvar m \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25196,(0),null);\nvar e \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25196,(1),null);\nvar m1 \x3d cljs.pprint.rtrim(m,\x220\x22);\nvar m2 \x3d cljs.pprint.ltrim(m1,\x220\x22);\nvar delta \x3d (cljs.core.count(m1) - cljs.core.count(m2));\nvar e__$1 \x3d (((((cljs.core.count(e) \x3e (0))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(e,(0)),\x22+\x22))))?cljs.core.subs.cljs$core$IFn$_invoke$arity$2(e,(1)):e);\nif(cljs.core.empty_QMARK_(m2)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x220\x22,(0)], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [m2,(parseInt(e__$1,(10)) - delta)], null);\n}\n});\n/**\n * Assumption: The input string consists of one or more decimal digits,\n *   and no other characters. Return a string containing one or more\n *   decimal digits containing a decimal number one larger than the input\n *   string. The output string will always be the same length as the input\n *   string, or one character longer.\n */\ncljs.pprint.inc_s \x3d (function cljs$pprint$inc_s(s){\nvar len_1 \x3d (cljs.core.count(s) - (1));\nvar i \x3d (len_1 | (0));\nwhile(true){\nif((i \x3c (0))){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.str,\x221\x22,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((len_1 + (1)),\x220\x22));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x229\x22,s.charAt(i))){\nvar G__28555 \x3d (i - (1));\ni \x3d G__28555;\ncontinue;\n} else {\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core.str,cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),i),cljs.core.char$((cljs.pprint.char_code(s.charAt(i)) + (1))),cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((len_1 - i),\x220\x22));\n\n}\n}\nbreak;\n}\n});\ncljs.pprint.round_str \x3d (function cljs$pprint$round_str(m,e,d,w){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d d;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn w;\n}\n})())){\nvar len \x3d cljs.core.count(m);\nvar w__$1 \x3d (cljs.core.truth_(w)?(function (){var x__5087__auto__ \x3d (2);\nvar y__5088__auto__ \x3d w;\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})():(0));\nvar round_pos \x3d (cljs.core.truth_(d)?((e + d) + (1)):(((e \x3e\x3d (0)))?(function (){var x__5087__auto__ \x3d (e + (1));\nvar y__5088__auto__ \x3d (w__$1 - (1));\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})():(w__$1 + e)\n));\nvar vec__25244 \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(round_pos,(0)))?new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [[\x220\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(m)].join(\x27\x27),(e + (1)),(1),(len + (1))], null):new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,e,round_pos,len], null));\nvar m1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25244,(0),null);\nvar e1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25244,(1),null);\nvar round_pos__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25244,(2),null);\nvar len__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25244,(3),null);\nif(cljs.core.truth_(round_pos__$1)){\nif((round_pos__$1 \x3c (0))){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x220\x22,(0),false], null);\n} else {\nif((len__$1 \x3e round_pos__$1)){\nvar round_char \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(m1,round_pos__$1);\nvar result \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$3(m1,(0),round_pos__$1);\nif((cljs.pprint.char_code(round_char) \x3e\x3d cljs.pprint.char_code(\x225\x22))){\nvar round_up_result \x3d cljs.pprint.inc_s(result);\nvar expanded \x3d (cljs.core.count(round_up_result) \x3e ((result).length));\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [((expanded)?cljs.core.subs.cljs$core$IFn$_invoke$arity$3(round_up_result,(0),(cljs.core.count(round_up_result) - (1))):round_up_result),e1,expanded], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [result,e1,false], null);\n}\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,e,false], null);\n}\n}\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,e,false], null);\n}\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,e,false], null);\n}\n});\ncljs.pprint.expand_fixed \x3d (function cljs$pprint$expand_fixed(m,e,d){\nvar vec__25269 \x3d (((e \x3c (0)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [[cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(((- e) - (1)),\x220\x22))),cljs.core.str.cljs$core$IFn$_invoke$arity$1(m)].join(\x27\x27),(-1)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,e], null));\nvar m1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25269,(0),null);\nvar e1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25269,(1),null);\nvar len \x3d cljs.core.count(m1);\nvar target_len \x3d (cljs.core.truth_(d)?((e1 + d) + (1)):(e1 + (1)));\nif((len \x3c target_len)){\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(m1),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((target_len - len),\x220\x22)))].join(\x27\x27);\n} else {\nreturn m1;\n}\n});\n/**\n * Insert the decimal point at the right spot in the number to match an exponent\n */\ncljs.pprint.insert_decimal \x3d (function cljs$pprint$insert_decimal(m,e){\nif((e \x3c (0))){\nreturn [\x22.\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(m)].join(\x27\x27);\n} else {\nvar loc \x3d (e + (1));\nreturn [cljs.core.subs.cljs$core$IFn$_invoke$arity$3(m,(0),loc),\x22.\x22,cljs.core.subs.cljs$core$IFn$_invoke$arity$2(m,loc)].join(\x27\x27);\n}\n});\ncljs.pprint.get_fixed \x3d (function cljs$pprint$get_fixed(m,e,d){\nreturn cljs.pprint.insert_decimal(cljs.pprint.expand_fixed(m,e,d),e);\n});\n/**\n * Insert the decimal point at the right spot in the number to match an exponent\n */\ncljs.pprint.insert_scaled_decimal \x3d (function cljs$pprint$insert_scaled_decimal(m,k){\nif((k \x3c (0))){\nreturn [\x22.\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(m)].join(\x27\x27);\n} else {\nreturn [cljs.core.subs.cljs$core$IFn$_invoke$arity$3(m,(0),k),\x22.\x22,cljs.core.subs.cljs$core$IFn$_invoke$arity$2(m,k)].join(\x27\x27);\n}\n});\ncljs.pprint.convert_ratio \x3d (function cljs$pprint$convert_ratio(x){\nreturn x;\n});\ncljs.pprint.fixed_float \x3d (function cljs$pprint$fixed_float(params,navigator,offsets){\nvar w \x3d new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001).cljs$core$IFn$_invoke$arity$1(params);\nvar d \x3d new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424).cljs$core$IFn$_invoke$arity$1(params);\nvar vec__25289 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25289,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25289,(1),null);\nvar vec__25292 \x3d (((arg \x3c (0)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22-\x22,(- arg)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22+\x22,arg], null));\nvar sign \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25292,(0),null);\nvar abs \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25292,(1),null);\nvar abs__$1 \x3d cljs.pprint.convert_ratio(abs);\nvar vec__25295 \x3d cljs.pprint.float_parts(abs__$1);\nvar mantissa \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25295,(0),null);\nvar exp \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25295,(1),null);\nvar scaled_exp \x3d (exp + new cljs.core.Keyword(null,\x22k\x22,\x22k\x22,-2146297393).cljs$core$IFn$_invoke$arity$1(params));\nvar add_sign \x3d (function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (arg \x3c (0));\n}\n})();\nvar append_zero \x3d ((cljs.core.not(d)) \x26\x26 (((cljs.core.count(mantissa) - (1)) \x3c\x3d scaled_exp)));\nvar vec__25298 \x3d cljs.pprint.round_str(mantissa,scaled_exp,d,(cljs.core.truth_(w)?(w - (cljs.core.truth_(add_sign)?(1):(0))):null));\nvar rounded_mantissa \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25298,(0),null);\nvar scaled_exp__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25298,(1),null);\nvar expanded \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25298,(2),null);\nvar fixed_repr \x3d cljs.pprint.get_fixed(rounded_mantissa,(cljs.core.truth_(expanded)?(scaled_exp__$1 + (1)):scaled_exp__$1),d);\nvar fixed_repr__$1 \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d w;\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d d;\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn (((d \x3e\x3d (1))) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(fixed_repr.charAt((0)),\x220\x22)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(fixed_repr.charAt((1)),\x22.\x22)) \x26\x26 ((((fixed_repr).length) \x3e (w - (cljs.core.truth_(add_sign)?(1):(0))))))))));\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())?cljs.core.subs.cljs$core$IFn$_invoke$arity$2(fixed_repr,(1)):fixed_repr);\nvar prepend_zero \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.first(fixed_repr__$1),\x22.\x22);\nif(cljs.core.truth_(w)){\nvar len_28560 \x3d ((fixed_repr__$1).length);\nvar signed_len_28561 \x3d (cljs.core.truth_(add_sign)?(len_28560 + (1)):len_28560);\nvar prepend_zero_28562__$1 \x3d ((prepend_zero) \x26\x26 ((!((signed_len_28561 \x3e\x3d w)))));\nvar append_zero_28563__$1 \x3d ((append_zero) \x26\x26 ((!((signed_len_28561 \x3e\x3d w)))));\nvar full_len_28564 \x3d ((((prepend_zero_28562__$1) || (append_zero_28563__$1)))?(signed_len_28561 + (1)):signed_len_28561);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d (full_len_28564 \x3e w);\nif(and__5000__auto__){\nreturn new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106).cljs$core$IFn$_invoke$arity$1(params);\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(w,new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106).cljs$core$IFn$_invoke$arity$1(params)))], 0));\n} else {\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((w - full_len_28564),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params)))),cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_(add_sign)?sign:null)),((prepend_zero_28562__$1)?\x220\x22:null),fixed_repr__$1,((append_zero_28563__$1)?\x220\x22:null)].join(\x27\x27)], 0));\n}\n} else {\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_(add_sign)?sign:null)),((prepend_zero)?\x220\x22:null),fixed_repr__$1,((append_zero)?\x220\x22:null)].join(\x27\x27)], 0));\n}\n\nreturn navigator__$1;\n});\ncljs.pprint.exponential_float \x3d (function cljs$pprint$exponential_float(params,navigator,offset){\nvar vec__25328 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25328,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25328,(1),null);\nvar arg__$1 \x3d cljs.pprint.convert_ratio(arg);\nvar G__25334_28565 \x3d cljs.pprint.float_parts((((arg__$1 \x3c (0)))?(- arg__$1):arg__$1));\nvar vec__25335_28566 \x3d G__25334_28565;\nvar mantissa_28567 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25335_28566,(0),null);\nvar exp_28568 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25335_28566,(1),null);\nvar G__25334_28569__$1 \x3d G__25334_28565;\nwhile(true){\nvar vec__25338_28570 \x3d G__25334_28569__$1;\nvar mantissa_28571__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25338_28570,(0),null);\nvar exp_28572__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25338_28570,(1),null);\nvar w_28573 \x3d new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001).cljs$core$IFn$_invoke$arity$1(params);\nvar d_28574 \x3d new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424).cljs$core$IFn$_invoke$arity$1(params);\nvar e_28575 \x3d new cljs.core.Keyword(null,\x22e\x22,\x22e\x22,1381269198).cljs$core$IFn$_invoke$arity$1(params);\nvar k_28576 \x3d new cljs.core.Keyword(null,\x22k\x22,\x22k\x22,-2146297393).cljs$core$IFn$_invoke$arity$1(params);\nvar expchar_28577 \x3d (function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22exponentchar\x22,\x22exponentchar\x22,1986664222).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn \x22E\x22;\n}\n})();\nvar add_sign_28578 \x3d (function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (arg__$1 \x3c (0));\n}\n})();\nvar prepend_zero_28579 \x3d (k_28576 \x3c\x3d (0));\nvar scaled_exp_28580 \x3d (exp_28572__$1 - (k_28576 - (1)));\nvar scaled_exp_str_28581 \x3d cljs.core.str.cljs$core$IFn$_invoke$arity$1(Math.abs(scaled_exp_28580));\nvar scaled_exp_str_28582__$1 \x3d [cljs.core.str.cljs$core$IFn$_invoke$arity$1(expchar_28577),(((scaled_exp_28580 \x3c (0)))?\x22-\x22:\x22+\x22),cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_(e_28575)?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((e_28575 - ((scaled_exp_str_28581).length)),\x220\x22)):null)),scaled_exp_str_28581].join(\x27\x27);\nvar exp_width_28583 \x3d ((scaled_exp_str_28582__$1).length);\nvar base_mantissa_width_28584 \x3d cljs.core.count(mantissa_28571__$1);\nvar scaled_mantissa_28585 \x3d [cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((- k_28576),\x220\x22))),cljs.core.str.cljs$core$IFn$_invoke$arity$1(mantissa_28571__$1),cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_(d_28574)?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(((d_28574 - (base_mantissa_width_28584 - (1))) - (((k_28576 \x3c (0)))?(- k_28576):(0))),\x220\x22)):null))].join(\x27\x27);\nvar w_mantissa_28586 \x3d (cljs.core.truth_(w_28573)?(w_28573 - exp_width_28583):null);\nvar vec__25349_28587 \x3d cljs.pprint.round_str(scaled_mantissa_28585,(0),((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(k_28576,(0)))?(d_28574 - (1)):(((k_28576 \x3e (0)))?d_28574:(((k_28576 \x3c (0)))?(d_28574 - (1)):null))),(cljs.core.truth_(w_mantissa_28586)?(w_mantissa_28586 - (cljs.core.truth_(add_sign_28578)?(1):(0))):null));\nvar rounded_mantissa_28588 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25349_28587,(0),null);\nvar __28589 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25349_28587,(1),null);\nvar incr_exp_28590 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25349_28587,(2),null);\nvar full_mantissa_28591 \x3d cljs.pprint.insert_scaled_decimal(rounded_mantissa_28588,k_28576);\nvar append_zero_28592 \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(k_28576,cljs.core.count(rounded_mantissa_28588))) \x26\x26 ((d_28574 \x3d\x3d null)));\nif(cljs.core.not(incr_exp_28590)){\nif(cljs.core.truth_(w_28573)){\nvar len_28595 \x3d (((full_mantissa_28591).length) + exp_width_28583);\nvar signed_len_28596 \x3d (cljs.core.truth_(add_sign_28578)?(len_28595 + (1)):len_28595);\nvar prepend_zero_28597__$1 \x3d ((prepend_zero_28579) \x26\x26 ((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(signed_len_28596,w_28573)))));\nvar full_len_28598 \x3d ((prepend_zero_28597__$1)?(signed_len_28596 + (1)):signed_len_28596);\nvar append_zero_28599__$1 \x3d ((append_zero_28592) \x26\x26 ((full_len_28598 \x3c w_28573)));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d (function (){var or__5002__auto__ \x3d (full_len_28598 \x3e w_28573);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d e_28575;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn ((exp_width_28583 - (2)) \x3e e_28575);\n} else {\nreturn and__5000__auto__;\n}\n}\n})();\nif(cljs.core.truth_(and__5000__auto__)){\nreturn new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106).cljs$core$IFn$_invoke$arity$1(params);\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(w_28573,new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106).cljs$core$IFn$_invoke$arity$1(params)))], 0));\n} else {\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(((w_28573 - full_len_28598) - ((append_zero_28599__$1)?(1):(0))),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params)))),(cljs.core.truth_(add_sign_28578)?(((arg__$1 \x3c (0)))?\x22-\x22:\x22+\x22):null),((prepend_zero_28597__$1)?\x220\x22:null),full_mantissa_28591,((append_zero_28599__$1)?\x220\x22:null),scaled_exp_str_28582__$1].join(\x27\x27)], 0));\n}\n} else {\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[(cljs.core.truth_(add_sign_28578)?(((arg__$1 \x3c (0)))?\x22-\x22:\x22+\x22):null),((prepend_zero_28579)?\x220\x22:null),full_mantissa_28591,((append_zero_28592)?\x220\x22:null),scaled_exp_str_28582__$1].join(\x27\x27)], 0));\n}\n} else {\nvar G__28600 \x3d new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [rounded_mantissa_28588,(exp_28572__$1 + (1))], null);\nG__25334_28569__$1 \x3d G__28600;\ncontinue;\n}\nbreak;\n}\n\nreturn navigator__$1;\n});\ncljs.pprint.general_float \x3d (function cljs$pprint$general_float(params,navigator,offsets){\nvar vec__25432 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25432,(0),null);\nvar _ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25432,(1),null);\nvar arg__$1 \x3d cljs.pprint.convert_ratio(arg);\nvar vec__25435 \x3d cljs.pprint.float_parts((((arg__$1 \x3c (0)))?(- arg__$1):arg__$1));\nvar mantissa \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25435,(0),null);\nvar exp \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25435,(1),null);\nvar w \x3d new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001).cljs$core$IFn$_invoke$arity$1(params);\nvar d \x3d new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424).cljs$core$IFn$_invoke$arity$1(params);\nvar e \x3d new cljs.core.Keyword(null,\x22e\x22,\x22e\x22,1381269198).cljs$core$IFn$_invoke$arity$1(params);\nvar n \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(arg__$1,0.0))?(0):(exp + (1)));\nvar ee \x3d (cljs.core.truth_(e)?(e + (2)):(4));\nvar ww \x3d (cljs.core.truth_(w)?(w - ee):null);\nvar d__$1 \x3d (cljs.core.truth_(d)?d:(function (){var x__5087__auto__ \x3d cljs.core.count(mantissa);\nvar y__5088__auto__ \x3d (function (){var x__5090__auto__ \x3d n;\nvar y__5091__auto__ \x3d (7);\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})();\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})());\nvar dd \x3d (d__$1 - n);\nif(((((0) \x3c\x3d dd)) \x26\x26 ((dd \x3c\x3d d__$1)))){\nvar navigator__$1 \x3d cljs.pprint.fixed_float(new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),ww,new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424),dd,new cljs.core.Keyword(null,\x22k\x22,\x22k\x22,-2146297393),(0),new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106),new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106).cljs$core$IFn$_invoke$arity$1(params),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params),new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params)], null),navigator,offsets);\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(ee,\x22 \x22))], 0));\n\nreturn navigator__$1;\n} else {\nreturn cljs.pprint.exponential_float(params,navigator,offsets);\n}\n});\ncljs.pprint.dollar_float \x3d (function cljs$pprint$dollar_float(params,navigator,offsets){\nvar vec__25458 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25458,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25458,(1),null);\nvar vec__25461 \x3d cljs.pprint.float_parts(Math.abs(arg));\nvar mantissa \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25461,(0),null);\nvar exp \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25461,(1),null);\nvar d \x3d new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424).cljs$core$IFn$_invoke$arity$1(params);\nvar n \x3d new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025).cljs$core$IFn$_invoke$arity$1(params);\nvar w \x3d new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001).cljs$core$IFn$_invoke$arity$1(params);\nvar add_sign \x3d (function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (arg \x3c (0));\n}\n})();\nvar vec__25464 \x3d cljs.pprint.round_str(mantissa,exp,d,null);\nvar rounded_mantissa \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25464,(0),null);\nvar scaled_exp \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25464,(1),null);\nvar expanded \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25464,(2),null);\nvar fixed_repr \x3d cljs.pprint.get_fixed(rounded_mantissa,(cljs.core.truth_(expanded)?(scaled_exp + (1)):scaled_exp),d);\nvar full_repr \x3d [cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((n - fixed_repr.indexOf(\x22.\x22)),\x220\x22))),fixed_repr].join(\x27\x27);\nvar full_len \x3d (((full_repr).length) + (cljs.core.truth_(add_sign)?(1):(0)));\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[(cljs.core.truth_((function (){var and__5000__auto__ \x3d new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn add_sign;\n} else {\nreturn and__5000__auto__;\n}\n})())?(((arg \x3c (0)))?\x22-\x22:\x22+\x22):null),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((w - full_len),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params)))),(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params));\nif(and__5000__auto__){\nreturn add_sign;\n} else {\nreturn and__5000__auto__;\n}\n})())?(((arg \x3c (0)))?\x22-\x22:\x22+\x22):null),full_repr].join(\x27\x27)], 0));\n\nreturn navigator__$1;\n});\ncljs.pprint.choice_conditional \x3d (function cljs$pprint$choice_conditional(params,arg_navigator,offsets){\nvar arg \x3d new cljs.core.Keyword(null,\x22selector\x22,\x22selector\x22,762528866).cljs$core$IFn$_invoke$arity$1(params);\nvar vec__25489 \x3d (cljs.core.truth_(arg)?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [arg,arg_navigator], null):cljs.pprint.next_arg(arg_navigator));\nvar arg__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25489,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25489,(1),null);\nvar clauses \x3d new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params);\nvar clause \x3d (((((arg__$1 \x3c (0))) || ((arg__$1 \x3e\x3d cljs.core.count(clauses)))))?cljs.core.first(new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146).cljs$core$IFn$_invoke$arity$1(params)):cljs.core.nth.cljs$core$IFn$_invoke$arity$2(clauses,arg__$1));\nif(cljs.core.truth_(clause)){\nreturn cljs.pprint.execute_sub_format(clause,navigator__$1,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\n} else {\nreturn navigator__$1;\n}\n});\ncljs.pprint.boolean_conditional \x3d (function cljs$pprint$boolean_conditional(params,arg_navigator,offsets){\nvar vec__25495 \x3d cljs.pprint.next_arg(arg_navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25495,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25495,(1),null);\nvar clauses \x3d new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params);\nvar clause \x3d (cljs.core.truth_(arg)?cljs.core.second(clauses):cljs.core.first(clauses));\nif(cljs.core.truth_(clause)){\nreturn cljs.pprint.execute_sub_format(clause,navigator__$1,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\n} else {\nreturn navigator__$1;\n}\n});\ncljs.pprint.check_arg_conditional \x3d (function cljs$pprint$check_arg_conditional(params,arg_navigator,offsets){\nvar vec__25509 \x3d cljs.pprint.next_arg(arg_navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25509,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25509,(1),null);\nvar clauses \x3d new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params);\nvar clause \x3d (cljs.core.truth_(arg)?cljs.core.first(clauses):null);\nif(cljs.core.truth_(arg)){\nif(cljs.core.truth_(clause)){\nreturn cljs.pprint.execute_sub_format(clause,arg_navigator,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\n} else {\nreturn arg_navigator;\n}\n} else {\nreturn navigator__$1;\n}\n});\ncljs.pprint.iterate_sublist \x3d (function cljs$pprint$iterate_sublist(params,navigator,offsets){\nvar max_count \x3d new cljs.core.Keyword(null,\x22max-iterations\x22,\x22max-iterations\x22,2021275563).cljs$core$IFn$_invoke$arity$1(params);\nvar param_clause \x3d cljs.core.first(new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params));\nvar vec__25523 \x3d ((cljs.core.empty_QMARK_(param_clause))?cljs.pprint.get_format_arg(navigator):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [param_clause,navigator], null));\nvar clause \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25523,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25523,(1),null);\nvar vec__25526 \x3d cljs.pprint.next_arg(navigator__$1);\nvar arg_list \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25526,(0),null);\nvar navigator__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25526,(1),null);\nvar args \x3d cljs.pprint.init_navigator(arg_list);\nvar count \x3d (0);\nvar args__$1 \x3d args;\nvar last_pos \x3d ((-1) | (0));\nwhile(true){\nif(((cljs.core.not(max_count)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(args__$1),last_pos)) \x26\x26 ((count \x3e (1))))))){\nthrow Error(\x22%{ construct not consuming any arguments: Infinite loop!\x22);\n} else {\n}\n\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d ((cljs.core.empty_QMARK_(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(args__$1))) \x26\x26 (((cljs.core.not(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22right-params\x22,\x22right-params\x22,-1790676237).cljs$core$IFn$_invoke$arity$1(params)))) || ((count \x3e (0))))));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d max_count;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (count \x3e\x3d max_count);\n} else {\nreturn and__5000__auto__;\n}\n}\n})())){\nreturn navigator__$2;\n} else {\nvar iter_result \x3d cljs.pprint.execute_sub_format(clause,args__$1,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22up-arrow\x22,\x22up-arrow\x22,1705310333),cljs.core.first(iter_result))){\nreturn navigator__$2;\n} else {\nvar G__28609 \x3d (count + (1));\nvar G__28610 \x3d iter_result;\nvar G__28611 \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(args__$1);\ncount \x3d G__28609;\nargs__$1 \x3d G__28610;\nlast_pos \x3d G__28611;\ncontinue;\n}\n}\nbreak;\n}\n});\ncljs.pprint.iterate_list_of_sublists \x3d (function cljs$pprint$iterate_list_of_sublists(params,navigator,offsets){\nvar max_count \x3d new cljs.core.Keyword(null,\x22max-iterations\x22,\x22max-iterations\x22,2021275563).cljs$core$IFn$_invoke$arity$1(params);\nvar param_clause \x3d cljs.core.first(new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params));\nvar vec__25569 \x3d ((cljs.core.empty_QMARK_(param_clause))?cljs.pprint.get_format_arg(navigator):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [param_clause,navigator], null));\nvar clause \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25569,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25569,(1),null);\nvar vec__25572 \x3d cljs.pprint.next_arg(navigator__$1);\nvar arg_list \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25572,(0),null);\nvar navigator__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25572,(1),null);\nvar count \x3d (0);\nvar arg_list__$1 \x3d arg_list;\nwhile(true){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d ((cljs.core.empty_QMARK_(arg_list__$1)) \x26\x26 (((cljs.core.not(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22right-params\x22,\x22right-params\x22,-1790676237).cljs$core$IFn$_invoke$arity$1(params)))) || ((count \x3e (0))))));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d max_count;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (count \x3e\x3d max_count);\n} else {\nreturn and__5000__auto__;\n}\n}\n})())){\nreturn navigator__$2;\n} else {\nvar iter_result \x3d cljs.pprint.execute_sub_format(clause,cljs.pprint.init_navigator(cljs.core.first(arg_list__$1)),cljs.pprint.init_navigator(cljs.core.next(arg_list__$1)));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22colon-up-arrow\x22,\x22colon-up-arrow\x22,244853007),cljs.core.first(iter_result))){\nreturn navigator__$2;\n} else {\nvar G__28612 \x3d (count + (1));\nvar G__28613 \x3d cljs.core.next(arg_list__$1);\ncount \x3d G__28612;\narg_list__$1 \x3d G__28613;\ncontinue;\n}\n}\nbreak;\n}\n});\ncljs.pprint.iterate_main_list \x3d (function cljs$pprint$iterate_main_list(params,navigator,offsets){\nvar max_count \x3d new cljs.core.Keyword(null,\x22max-iterations\x22,\x22max-iterations\x22,2021275563).cljs$core$IFn$_invoke$arity$1(params);\nvar param_clause \x3d cljs.core.first(new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params));\nvar vec__25600 \x3d ((cljs.core.empty_QMARK_(param_clause))?cljs.pprint.get_format_arg(navigator):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [param_clause,navigator], null));\nvar clause \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25600,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25600,(1),null);\nvar count \x3d (0);\nvar navigator__$2 \x3d navigator__$1;\nvar last_pos \x3d ((-1) | (0));\nwhile(true){\nif(((cljs.core.not(max_count)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(navigator__$2),last_pos)) \x26\x26 ((count \x3e (1))))))){\nthrow Error(\x22%@{ construct not consuming any arguments: Infinite loop!\x22);\n} else {\n}\n\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d ((cljs.core.empty_QMARK_(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(navigator__$2))) \x26\x26 (((cljs.core.not(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22right-params\x22,\x22right-params\x22,-1790676237).cljs$core$IFn$_invoke$arity$1(params)))) || ((count \x3e (0))))));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d max_count;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (count \x3e\x3d max_count);\n} else {\nreturn and__5000__auto__;\n}\n}\n})())){\nreturn navigator__$2;\n} else {\nvar iter_result \x3d cljs.pprint.execute_sub_format(clause,navigator__$2,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22up-arrow\x22,\x22up-arrow\x22,1705310333),cljs.core.first(iter_result))){\nreturn cljs.core.second(iter_result);\n} else {\nvar G__28618 \x3d (count + (1));\nvar G__28619 \x3d iter_result;\nvar G__28620 \x3d new cljs.core.Keyword(null,\x22pos\x22,\x22pos\x22,-864607220).cljs$core$IFn$_invoke$arity$1(navigator__$2);\ncount \x3d G__28618;\nnavigator__$2 \x3d G__28619;\nlast_pos \x3d G__28620;\ncontinue;\n}\n}\nbreak;\n}\n});\ncljs.pprint.iterate_main_sublists \x3d (function cljs$pprint$iterate_main_sublists(params,navigator,offsets){\nvar max_count \x3d new cljs.core.Keyword(null,\x22max-iterations\x22,\x22max-iterations\x22,2021275563).cljs$core$IFn$_invoke$arity$1(params);\nvar param_clause \x3d cljs.core.first(new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params));\nvar vec__25640 \x3d ((cljs.core.empty_QMARK_(param_clause))?cljs.pprint.get_format_arg(navigator):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [param_clause,navigator], null));\nvar clause \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25640,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25640,(1),null);\nvar count \x3d (0);\nvar navigator__$2 \x3d navigator__$1;\nwhile(true){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d ((cljs.core.empty_QMARK_(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(navigator__$2))) \x26\x26 (((cljs.core.not(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22right-params\x22,\x22right-params\x22,-1790676237).cljs$core$IFn$_invoke$arity$1(params)))) || ((count \x3e (0))))));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d max_count;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (count \x3e\x3d max_count);\n} else {\nreturn and__5000__auto__;\n}\n}\n})())){\nreturn navigator__$2;\n} else {\nvar vec__25665 \x3d cljs.pprint.next_arg_or_nil(navigator__$2);\nvar sublist \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25665,(0),null);\nvar navigator__$3 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25665,(1),null);\nvar iter_result \x3d cljs.pprint.execute_sub_format(clause,cljs.pprint.init_navigator(sublist),navigator__$3);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22colon-up-arrow\x22,\x22colon-up-arrow\x22,244853007),cljs.core.first(iter_result))){\nreturn navigator__$3;\n} else {\nvar G__28624 \x3d (count + (1));\nvar G__28625 \x3d navigator__$3;\ncount \x3d G__28624;\nnavigator__$2 \x3d G__28625;\ncontinue;\n}\n}\nbreak;\n}\n});\ncljs.pprint.logical_block_or_justify \x3d (function cljs$pprint$logical_block_or_justify(params,navigator,offsets){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22right-params\x22,\x22right-params\x22,-1790676237).cljs$core$IFn$_invoke$arity$1(params)))){\nreturn cljs.pprint.format_logical_block(params,navigator,offsets);\n} else {\nreturn cljs.pprint.justify_clauses(params,navigator,offsets);\n}\n});\ncljs.pprint.render_clauses \x3d (function cljs$pprint$render_clauses(clauses,navigator,base_navigator){\nvar clauses__$1 \x3d clauses;\nvar acc \x3d cljs.core.PersistentVector.EMPTY;\nvar navigator__$1 \x3d navigator;\nwhile(true){\nif(cljs.core.empty_QMARK_(clauses__$1)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [acc,navigator__$1], null);\n} else {\nvar clause \x3d cljs.core.first(clauses__$1);\nvar vec__25712 \x3d (function (){var sb \x3d (new goog.string.StringBuffer());\nvar _STAR_out_STAR__orig_val__25718 \x3d cljs.core._STAR_out_STAR_;\nvar _STAR_out_STAR__temp_val__25720 \x3d (new cljs.core.StringBufferWriter(sb));\n(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__temp_val__25720);\n\ntry{return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.pprint.execute_sub_format(clause,navigator__$1,base_navigator),cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb)], null);\n}finally {(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__orig_val__25718);\n}})();\nvar iter_result \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25712,(0),null);\nvar result_str \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25712,(1),null);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22up-arrow\x22,\x22up-arrow\x22,1705310333),cljs.core.first(iter_result))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [acc,cljs.core.second(iter_result)], null);\n} else {\nvar G__28629 \x3d cljs.core.next(clauses__$1);\nvar G__28630 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(acc,result_str);\nvar G__28631 \x3d iter_result;\nclauses__$1 \x3d G__28629;\nacc \x3d G__28630;\nnavigator__$1 \x3d G__28631;\ncontinue;\n}\n}\nbreak;\n}\n});\ncljs.pprint.justify_clauses \x3d (function cljs$pprint$justify_clauses(params,navigator,offsets){\nvar vec__25733 \x3d (function (){var temp__5804__auto__ \x3d new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar else$ \x3d temp__5804__auto__;\nreturn cljs.pprint.render_clauses(else$,navigator,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\n} else {\nreturn null;\n}\n})();\nvar vec__25736 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25733,(0),null);\nvar eol_str \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25736,(0),null);\nvar new_navigator \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25733,(1),null);\nvar navigator__$1 \x3d (function (){var or__5002__auto__ \x3d new_navigator;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn navigator;\n}\n})();\nvar vec__25739 \x3d (function (){var temp__5804__auto__ \x3d new cljs.core.Keyword(null,\x22else-params\x22,\x22else-params\x22,-832171646).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar p \x3d temp__5804__auto__;\nreturn cljs.pprint.realize_parameter_list(p,navigator__$1);\n} else {\nreturn null;\n}\n})();\nvar else_params \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25739,(0),null);\nvar new_navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25739,(1),null);\nvar navigator__$2 \x3d (function (){var or__5002__auto__ \x3d new_navigator__$1;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn navigator__$1;\n}\n})();\nvar min_remaining \x3d (function (){var or__5002__auto__ \x3d cljs.core.first(new cljs.core.Keyword(null,\x22min-remaining\x22,\x22min-remaining\x22,962687677).cljs$core$IFn$_invoke$arity$1(else_params));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (0);\n}\n})();\nvar max_columns \x3d (function (){var or__5002__auto__ \x3d cljs.core.first(new cljs.core.Keyword(null,\x22max-columns\x22,\x22max-columns\x22,1742323262).cljs$core$IFn$_invoke$arity$1(else_params));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.pprint.get_max_column(cljs.core._STAR_out_STAR_);\n}\n})();\nvar clauses \x3d new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params);\nvar vec__25742 \x3d cljs.pprint.render_clauses(clauses,navigator__$2,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\nvar strs \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25742,(0),null);\nvar navigator__$3 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25742,(1),null);\nvar slots \x3d (function (){var x__5087__auto__ \x3d (1);\nvar y__5088__auto__ \x3d (((cljs.core.count(strs) - (1)) + (cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?(1):(0))) + (cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))?(1):(0)));\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})();\nvar chars \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$2(cljs.core._PLUS_,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.count,strs));\nvar mincol \x3d new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445).cljs$core$IFn$_invoke$arity$1(params);\nvar minpad \x3d new cljs.core.Keyword(null,\x22minpad\x22,\x22minpad\x22,323570901).cljs$core$IFn$_invoke$arity$1(params);\nvar colinc \x3d new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385).cljs$core$IFn$_invoke$arity$1(params);\nvar minout \x3d (chars + (slots * minpad));\nvar result_columns \x3d (((minout \x3c\x3d mincol))?mincol:(mincol + (colinc * ((1) + cljs.core.quot(((minout - mincol) - (1)),colinc)))));\nvar total_pad \x3d (result_columns - chars);\nvar pad \x3d (function (){var x__5087__auto__ \x3d minpad;\nvar y__5088__auto__ \x3d cljs.core.quot(total_pad,slots);\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})();\nvar extra_pad \x3d (total_pad - (pad * slots));\nvar pad_str \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(pad,new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params)));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d eol_str;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (((cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(cljs.core._STAR_out_STAR_)))) + min_remaining) + result_columns) \x3e max_columns);\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([eol_str], 0));\n} else {\n}\n\nvar slots_28637__$1 \x3d slots;\nvar extra_pad_28638__$1 \x3d extra_pad;\nvar strs_28639__$1 \x3d strs;\nvar pad_only_28640 \x3d (function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(strs_28639__$1),(1))) \x26\x26 (cljs.core.not(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))));\n}\n})();\nwhile(true){\nif(cljs.core.seq(strs_28639__$1)){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[cljs.core.str.cljs$core$IFn$_invoke$arity$1(((cljs.core.not(pad_only_28640))?cljs.core.first(strs_28639__$1):null)),cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_((function (){var or__5002__auto__ \x3d pad_only_28640;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d cljs.core.next(strs_28639__$1);\nif(or__5002__auto____$1){\nreturn or__5002__auto____$1;\n} else {\nreturn new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\n}\n}\n})())?pad_str:null)),cljs.core.str.cljs$core$IFn$_invoke$arity$1((((extra_pad_28638__$1 \x3e (0)))?new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530).cljs$core$IFn$_invoke$arity$1(params):null))].join(\x27\x27)], 0));\n\nvar G__28644 \x3d (slots_28637__$1 - (1));\nvar G__28645 \x3d (extra_pad_28638__$1 - (1));\nvar G__28646 \x3d (cljs.core.truth_(pad_only_28640)?strs_28639__$1:cljs.core.next(strs_28639__$1));\nvar G__28647 \x3d false;\nslots_28637__$1 \x3d G__28644;\nextra_pad_28638__$1 \x3d G__28645;\nstrs_28639__$1 \x3d G__28646;\npad_only_28640 \x3d G__28647;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn navigator__$3;\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.pprint.t_cljs$pprint25777 \x3d (function (writer,meta25778){\nthis.writer \x3d writer;\nthis.meta25778 \x3d meta25778;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1074135040;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.pprint.t_cljs$pprint25777.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25779,meta25778__$1){\nvar self__ \x3d this;\nvar _25779__$1 \x3d this;\nreturn (new cljs.pprint.t_cljs$pprint25777(self__.writer,meta25778__$1));\n}));\n\n(cljs.pprint.t_cljs$pprint25777.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25779){\nvar self__ \x3d this;\nvar _25779__$1 \x3d this;\nreturn self__.meta25778;\n}));\n\n(cljs.pprint.t_cljs$pprint25777.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core._flush(self__.writer);\n}));\n\n(cljs.pprint.t_cljs$pprint25777.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (this$,x){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar pred__25783 \x3d cljs.core._EQ_;\nvar expr__25784 \x3d cljs.core.type(x);\nif(cljs.core.truth_((pred__25783.cljs$core$IFn$_invoke$arity$2 ? pred__25783.cljs$core$IFn$_invoke$arity$2(String,expr__25784) : pred__25783.call(null, String,expr__25784)))){\nvar s \x3d x;\nreturn cljs.core._write(self__.writer,clojure.string.lower_case(s));\n} else {\nif(cljs.core.truth_((pred__25783.cljs$core$IFn$_invoke$arity$2 ? pred__25783.cljs$core$IFn$_invoke$arity$2(Number,expr__25784) : pred__25783.call(null, Number,expr__25784)))){\nvar c \x3d x;\nreturn cljs.core._write(self__.writer,clojure.string.lower_case(cljs.core.char$(c)));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__25784)].join(\x27\x27)));\n}\n}\n}));\n\n(cljs.pprint.t_cljs$pprint25777.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22writer\x22,\x22writer\x22,1362963291,null),new cljs.core.Symbol(null,\x22meta25778\x22,\x22meta25778\x22,-268283268,null)], null);\n}));\n\n(cljs.pprint.t_cljs$pprint25777.cljs$lang$type \x3d true);\n\n(cljs.pprint.t_cljs$pprint25777.cljs$lang$ctorStr \x3d \x22cljs.pprint/t_cljs$pprint25777\x22);\n\n(cljs.pprint.t_cljs$pprint25777.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.pprint/t_cljs$pprint25777\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/t_cljs$pprint25777.\n */\ncljs.pprint.__GT_t_cljs$pprint25777 \x3d (function cljs$pprint$__GT_t_cljs$pprint25777(writer,meta25778){\nreturn (new cljs.pprint.t_cljs$pprint25777(writer,meta25778));\n});\n\n\n/**\n * Returns a proxy that wraps writer, converting all characters to lower case\n */\ncljs.pprint.downcase_writer \x3d (function cljs$pprint$downcase_writer(writer){\nreturn (new cljs.pprint.t_cljs$pprint25777(writer,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.pprint.t_cljs$pprint25789 \x3d (function (writer,meta25790){\nthis.writer \x3d writer;\nthis.meta25790 \x3d meta25790;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1074135040;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.pprint.t_cljs$pprint25789.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25791,meta25790__$1){\nvar self__ \x3d this;\nvar _25791__$1 \x3d this;\nreturn (new cljs.pprint.t_cljs$pprint25789(self__.writer,meta25790__$1));\n}));\n\n(cljs.pprint.t_cljs$pprint25789.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25791){\nvar self__ \x3d this;\nvar _25791__$1 \x3d this;\nreturn self__.meta25790;\n}));\n\n(cljs.pprint.t_cljs$pprint25789.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core._flush(self__.writer);\n}));\n\n(cljs.pprint.t_cljs$pprint25789.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (this$,x){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar pred__25795 \x3d cljs.core._EQ_;\nvar expr__25796 \x3d cljs.core.type(x);\nif(cljs.core.truth_((pred__25795.cljs$core$IFn$_invoke$arity$2 ? pred__25795.cljs$core$IFn$_invoke$arity$2(String,expr__25796) : pred__25795.call(null, String,expr__25796)))){\nvar s \x3d x;\nreturn cljs.core._write(self__.writer,clojure.string.upper_case(s));\n} else {\nif(cljs.core.truth_((pred__25795.cljs$core$IFn$_invoke$arity$2 ? pred__25795.cljs$core$IFn$_invoke$arity$2(Number,expr__25796) : pred__25795.call(null, Number,expr__25796)))){\nvar c \x3d x;\nreturn cljs.core._write(self__.writer,clojure.string.upper_case(cljs.core.char$(c)));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__25796)].join(\x27\x27)));\n}\n}\n}));\n\n(cljs.pprint.t_cljs$pprint25789.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22writer\x22,\x22writer\x22,1362963291,null),new cljs.core.Symbol(null,\x22meta25790\x22,\x22meta25790\x22,1080124211,null)], null);\n}));\n\n(cljs.pprint.t_cljs$pprint25789.cljs$lang$type \x3d true);\n\n(cljs.pprint.t_cljs$pprint25789.cljs$lang$ctorStr \x3d \x22cljs.pprint/t_cljs$pprint25789\x22);\n\n(cljs.pprint.t_cljs$pprint25789.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.pprint/t_cljs$pprint25789\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/t_cljs$pprint25789.\n */\ncljs.pprint.__GT_t_cljs$pprint25789 \x3d (function cljs$pprint$__GT_t_cljs$pprint25789(writer,meta25790){\nreturn (new cljs.pprint.t_cljs$pprint25789(writer,meta25790));\n});\n\n\n/**\n * Returns a proxy that wraps writer, converting all characters to upper case\n */\ncljs.pprint.upcase_writer \x3d (function cljs$pprint$upcase_writer(writer){\nreturn (new cljs.pprint.t_cljs$pprint25789(writer,cljs.core.PersistentArrayMap.EMPTY));\n});\n/**\n * Capitalizes the words in a string. If first? is false, don\x27t capitalize the\n *                                    first character of the string even if it\x27s a letter.\n */\ncljs.pprint.capitalize_string \x3d (function cljs$pprint$capitalize_string(s,first_QMARK_){\nvar f \x3d cljs.core.first(s);\nvar s__$1 \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d first_QMARK_;\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d f;\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn goog.string.isUnicodeChar(f);\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())?[clojure.string.upper_case(f),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(1))].join(\x27\x27):s);\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.first(cljs.pprint.consume((function (s__$2){\nif(cljs.core.empty_QMARK_(s__$2)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null], null);\n} else {\nvar m \x3d RegExp(\x22\\\\W\\\\w\x22,\x22g\x22).exec(s__$2);\nvar offset \x3d (function (){var and__5000__auto__ \x3d m;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (m.index + (1));\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.truth_(offset)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [[cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s__$2,(0),offset),clojure.string.upper_case(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(s__$2,offset))].join(\x27\x27),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s__$2,(offset + (1)))], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [s__$2,null], null);\n}\n}\n}),s__$1)));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.pprint.t_cljs$pprint25809 \x3d (function (writer,last_was_whitespace_QMARK_,meta25810){\nthis.writer \x3d writer;\nthis.last_was_whitespace_QMARK_ \x3d last_was_whitespace_QMARK_;\nthis.meta25810 \x3d meta25810;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1074135040;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.pprint.t_cljs$pprint25809.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25811,meta25810__$1){\nvar self__ \x3d this;\nvar _25811__$1 \x3d this;\nreturn (new cljs.pprint.t_cljs$pprint25809(self__.writer,self__.last_was_whitespace_QMARK_,meta25810__$1));\n}));\n\n(cljs.pprint.t_cljs$pprint25809.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25811){\nvar self__ \x3d this;\nvar _25811__$1 \x3d this;\nreturn self__.meta25810;\n}));\n\n(cljs.pprint.t_cljs$pprint25809.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core._flush(self__.writer);\n}));\n\n(cljs.pprint.t_cljs$pprint25809.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (this$,x){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar pred__25820 \x3d cljs.core._EQ_;\nvar expr__25821 \x3d cljs.core.type(x);\nif(cljs.core.truth_((pred__25820.cljs$core$IFn$_invoke$arity$2 ? pred__25820.cljs$core$IFn$_invoke$arity$2(String,expr__25821) : pred__25820.call(null, String,expr__25821)))){\nvar s \x3d x;\ncljs.core._write(self__.writer,cljs.pprint.capitalize_string(s.toLowerCase(),cljs.core.deref(self__.last_was_whitespace_QMARK_)));\n\nif((s.length \x3e (0))){\nreturn cljs.core.reset_BANG_(self__.last_was_whitespace_QMARK_,goog.string.isEmptyOrWhitespace(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(s,(cljs.core.count(s) - (1)))));\n} else {\nreturn null;\n}\n} else {\nif(cljs.core.truth_((pred__25820.cljs$core$IFn$_invoke$arity$2 ? pred__25820.cljs$core$IFn$_invoke$arity$2(Number,expr__25821) : pred__25820.call(null, Number,expr__25821)))){\nvar c \x3d cljs.core.char$(x);\nvar mod_c \x3d (cljs.core.truth_(cljs.core.deref(self__.last_was_whitespace_QMARK_))?clojure.string.upper_case(c):c);\ncljs.core._write(self__.writer,mod_c);\n\nreturn cljs.core.reset_BANG_(self__.last_was_whitespace_QMARK_,goog.string.isEmptyOrWhitespace(c));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__25821)].join(\x27\x27)));\n}\n}\n}));\n\n(cljs.pprint.t_cljs$pprint25809.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22writer\x22,\x22writer\x22,1362963291,null),new cljs.core.Symbol(null,\x22last-was-whitespace?\x22,\x22last-was-whitespace?\x22,-1073928093,null),new cljs.core.Symbol(null,\x22meta25810\x22,\x22meta25810\x22,209680451,null)], null);\n}));\n\n(cljs.pprint.t_cljs$pprint25809.cljs$lang$type \x3d true);\n\n(cljs.pprint.t_cljs$pprint25809.cljs$lang$ctorStr \x3d \x22cljs.pprint/t_cljs$pprint25809\x22);\n\n(cljs.pprint.t_cljs$pprint25809.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.pprint/t_cljs$pprint25809\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/t_cljs$pprint25809.\n */\ncljs.pprint.__GT_t_cljs$pprint25809 \x3d (function cljs$pprint$__GT_t_cljs$pprint25809(writer,last_was_whitespace_QMARK_,meta25810){\nreturn (new cljs.pprint.t_cljs$pprint25809(writer,last_was_whitespace_QMARK_,meta25810));\n});\n\n\n/**\n * Returns a proxy that wraps writer, capitalizing all words\n */\ncljs.pprint.capitalize_word_writer \x3d (function cljs$pprint$capitalize_word_writer(writer){\nvar last_was_whitespace_QMARK_ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(true);\nreturn (new cljs.pprint.t_cljs$pprint25809(writer,last_was_whitespace_QMARK_,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.pprint.t_cljs$pprint25830 \x3d (function (writer,capped,meta25831){\nthis.writer \x3d writer;\nthis.capped \x3d capped;\nthis.meta25831 \x3d meta25831;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1074135040;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.pprint.t_cljs$pprint25830.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25832,meta25831__$1){\nvar self__ \x3d this;\nvar _25832__$1 \x3d this;\nreturn (new cljs.pprint.t_cljs$pprint25830(self__.writer,self__.capped,meta25831__$1));\n}));\n\n(cljs.pprint.t_cljs$pprint25830.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25832){\nvar self__ \x3d this;\nvar _25832__$1 \x3d this;\nreturn self__.meta25831;\n}));\n\n(cljs.pprint.t_cljs$pprint25830.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core._flush(self__.writer);\n}));\n\n(cljs.pprint.t_cljs$pprint25830.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (this$,x){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar pred__25842 \x3d cljs.core._EQ_;\nvar expr__25843 \x3d cljs.core.type(x);\nif(cljs.core.truth_((pred__25842.cljs$core$IFn$_invoke$arity$2 ? pred__25842.cljs$core$IFn$_invoke$arity$2(String,expr__25843) : pred__25842.call(null, String,expr__25843)))){\nvar s \x3d clojure.string.lower_case(x);\nif(cljs.core.not(cljs.core.deref(self__.capped))){\nvar m \x3d RegExp(\x22\\\\S\x22,\x22g\x22).exec(s);\nvar offset \x3d (function (){var and__5000__auto__ \x3d m;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn m.index;\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.truth_(offset)){\ncljs.core._write(self__.writer,[cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),offset),clojure.string.upper_case(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(s,offset)),clojure.string.lower_case(cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(offset + (1))))].join(\x27\x27));\n\nreturn cljs.core.reset_BANG_(self__.capped,true);\n} else {\nreturn cljs.core._write(self__.writer,s);\n}\n} else {\nreturn cljs.core._write(self__.writer,clojure.string.lower_case(s));\n}\n} else {\nif(cljs.core.truth_((pred__25842.cljs$core$IFn$_invoke$arity$2 ? pred__25842.cljs$core$IFn$_invoke$arity$2(Number,expr__25843) : pred__25842.call(null, Number,expr__25843)))){\nvar c \x3d cljs.core.char$(x);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(cljs.core.deref(self__.capped));\nif(and__5000__auto__){\nreturn goog.string.isUnicodeChar(c);\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.core.reset_BANG_(self__.capped,true);\n\nreturn cljs.core._write(self__.writer,clojure.string.upper_case(c));\n} else {\nreturn cljs.core._write(self__.writer,clojure.string.lower_case(c));\n}\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(expr__25843)].join(\x27\x27)));\n}\n}\n}));\n\n(cljs.pprint.t_cljs$pprint25830.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22writer\x22,\x22writer\x22,1362963291,null),new cljs.core.Symbol(null,\x22capped\x22,\x22capped\x22,-1650988402,null),new cljs.core.Symbol(null,\x22meta25831\x22,\x22meta25831\x22,331567079,null)], null);\n}));\n\n(cljs.pprint.t_cljs$pprint25830.cljs$lang$type \x3d true);\n\n(cljs.pprint.t_cljs$pprint25830.cljs$lang$ctorStr \x3d \x22cljs.pprint/t_cljs$pprint25830\x22);\n\n(cljs.pprint.t_cljs$pprint25830.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.pprint/t_cljs$pprint25830\x22);\n}));\n\n/**\n * Positional factory function for cljs.pprint/t_cljs$pprint25830.\n */\ncljs.pprint.__GT_t_cljs$pprint25830 \x3d (function cljs$pprint$__GT_t_cljs$pprint25830(writer,capped,meta25831){\nreturn (new cljs.pprint.t_cljs$pprint25830(writer,capped,meta25831));\n});\n\n\n/**\n * Returns a proxy that wraps writer, capitalizing the first word\n */\ncljs.pprint.init_cap_writer \x3d (function cljs$pprint$init_cap_writer(writer){\nvar capped \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(false);\nreturn (new cljs.pprint.t_cljs$pprint25830(writer,capped,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.pprint.modify_case \x3d (function cljs$pprint$modify_case(make_writer,params,navigator,offsets){\nvar clause \x3d cljs.core.first(new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params));\nvar _STAR_out_STAR__orig_val__25912 \x3d cljs.core._STAR_out_STAR_;\nvar _STAR_out_STAR__temp_val__25913 \x3d (make_writer.cljs$core$IFn$_invoke$arity$1 ? make_writer.cljs$core$IFn$_invoke$arity$1(cljs.core._STAR_out_STAR_) : make_writer.call(null, cljs.core._STAR_out_STAR_));\n(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__temp_val__25913);\n\ntry{return cljs.pprint.execute_sub_format(clause,navigator,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\n}finally {(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__orig_val__25912);\n}});\n/**\n * Returns the IWriter passed in wrapped in a pretty writer proxy, unless it\x27s\n * already a pretty writer. Generally, it is unnecessary to call this function, since pprint,\n * write, and cl-format all call it if they need to. However if you want the state to be\n * preserved across calls, you will want to wrap them with this.\n * \n * For example, when you want to generate column-aware output with multiple calls to cl-format,\n * do it like in this example:\n * \n *  (defn print-table [aseq column-width]\n *    (binding [*out* (get-pretty-writer *out*)]\n *      (doseq [row aseq]\n *        (doseq [col row]\n *          (cl-format true \x22~4D~7,vT\x22 col column-width))\n *        (prn))))\n * \n * Now when you run:\n * \n *  user\x3e (print-table (map #(vector % (* % %) (* % % %)) (range 1 11)) 8)\n * \n * It prints a table of squares and cubes for the numbers from 1 to 10:\n * \n *     1      1       1\n *     2      4       8\n *     3      9      27\n *     4     16      64\n *     5     25     125\n *     6     36     216\n *     7     49     343\n *     8     64     512\n *     9     81     729\n *    10    100    1000\n */\ncljs.pprint.get_pretty_writer \x3d (function cljs$pprint$get_pretty_writer(writer){\nif(cljs.core.truth_(cljs.pprint.pretty_writer_QMARK_(writer))){\nreturn writer;\n} else {\nreturn cljs.pprint.pretty_writer(writer,cljs.pprint._STAR_print_right_margin_STAR_,cljs.pprint._STAR_print_miser_width_STAR_);\n}\n});\n/**\n * Make a newline if *out* is not already at the beginning of the line. If *out* is\n * not a pretty writer (which keeps track of columns), this function always outputs a newline.\n */\ncljs.pprint.fresh_line \x3d (function cljs$pprint$fresh_line(){\nif((((!((cljs.core._STAR_out_STAR_ \x3d\x3d null))))?(((((cljs.core._STAR_out_STAR_.cljs$lang$protocol_mask$partition0$ \x26 (32768))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d cljs.core._STAR_out_STAR_.cljs$core$IDeref$))))?true:(((!cljs.core._STAR_out_STAR_.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IDeref,cljs.core._STAR_out_STAR_):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IDeref,cljs.core._STAR_out_STAR_))){\nif((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((0),cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(cljs.core._STAR_out_STAR_)))))))){\nreturn cljs.pprint.prn();\n} else {\nreturn null;\n}\n} else {\nreturn cljs.pprint.prn();\n}\n});\ncljs.pprint.absolute_tabulation \x3d (function cljs$pprint$absolute_tabulation(params,navigator,offsets){\nvar colnum_28670 \x3d new cljs.core.Keyword(null,\x22colnum\x22,\x22colnum\x22,2023796854).cljs$core$IFn$_invoke$arity$1(params);\nvar colinc_28671 \x3d new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385).cljs$core$IFn$_invoke$arity$1(params);\nvar current_28672 \x3d cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(cljs.core._STAR_out_STAR_))));\nvar space_count_28673 \x3d (((current_28672 \x3c colnum_28670))?(colnum_28670 - current_28672):((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(colinc_28671,(0)))?(0):(colinc_28671 - cljs.core.rem((current_28672 - colnum_28670),colinc_28671))\n));\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(space_count_28673,\x22 \x22))], 0));\n\nreturn navigator;\n});\ncljs.pprint.relative_tabulation \x3d (function cljs$pprint$relative_tabulation(params,navigator,offsets){\nvar colrel_28675 \x3d new cljs.core.Keyword(null,\x22colnum\x22,\x22colnum\x22,2023796854).cljs$core$IFn$_invoke$arity$1(params);\nvar colinc_28676 \x3d new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385).cljs$core$IFn$_invoke$arity$1(params);\nvar start_col_28677 \x3d (colrel_28675 + cljs.pprint.get_column(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(cljs.core.deref(cljs.core._STAR_out_STAR_)))));\nvar offset_28678 \x3d (((colinc_28676 \x3e (0)))?cljs.core.rem(start_col_28677,colinc_28676):(0));\nvar space_count_28680 \x3d (colrel_28675 + ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((0),offset_28678))?(0):(colinc_28676 - offset_28678)));\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(space_count_28680,\x22 \x22))], 0));\n\nreturn navigator;\n});\ncljs.pprint.format_logical_block \x3d (function cljs$pprint$format_logical_block(params,navigator,offsets){\nvar clauses \x3d new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(params);\nvar clause_count \x3d cljs.core.count(clauses);\nvar prefix \x3d (((clause_count \x3e (1)))?new cljs.core.Keyword(null,\x22string\x22,\x22string\x22,-1989541586).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(cljs.core.first(cljs.core.first(clauses)))):(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?\x22(\x22:null));\nvar body \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(clauses,(((clause_count \x3e (1)))?(1):(0)));\nvar suffix \x3d (((clause_count \x3e (2)))?new cljs.core.Keyword(null,\x22string\x22,\x22string\x22,-1989541586).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(cljs.core.first(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(clauses,(2))))):(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?\x22)\x22:null));\nvar vec__26005 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26005,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26005,(1),null);\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__26013_28681 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__26014_28682 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__26015_28683 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__26016_28684 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__26015_28683);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__26016_28684);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,prefix,null,suffix);\n\ncljs.pprint.execute_sub_format(body,cljs.pprint.init_navigator(arg),new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params));\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__26014_28682);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__26013_28681);\n}}\n\n\nreturn navigator__$1;\n});\ncljs.pprint.set_indent \x3d (function cljs$pprint$set_indent(params,navigator,offsets){\nvar relative_to \x3d (cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?new cljs.core.Keyword(null,\x22current\x22,\x22current\x22,-1088038603):new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210));\ncljs.pprint.pprint_indent(relative_to,new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025).cljs$core$IFn$_invoke$arity$1(params));\n\nreturn navigator;\n});\ncljs.pprint.conditional_newline \x3d (function cljs$pprint$conditional_newline(params,navigator,offsets){\nvar kind \x3d (cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))?new cljs.core.Keyword(null,\x22mandatory\x22,\x22mandatory\x22,542802336):new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889)):(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))?new cljs.core.Keyword(null,\x22miser\x22,\x22miser\x22,-556060186):new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697)));\ncljs.pprint.pprint_newline(kind);\n\nreturn navigator;\n});\ncljs.pprint.directive_table \x3d cljs.core.PersistentHashMap.fromArrays([\x22A\x22,\x22S\x22,\x22D\x22,\x22B\x22,\x22O\x22,\x22X\x22,\x22R\x22,\x22P\x22,\x22C\x22,\x22F\x22,\x22E\x22,\x22G\x22,\x22$\x22,\x22%\x22,\x22\x26\x22,\x22|\x22,\x22~\x22,\x22\\n\x22,\x22T\x22,\x22*\x22,\x22?\x22,\x22(\x22,\x22)\x22,\x22[\x22,\x22;\x22,\x22]\x22,\x22{\x22,\x22}\x22,\x22\x3c\x22,\x22\x3e\x22,\x22^\x22,\x22W\x22,\x22_\x22,\x22I\x22],[new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22A\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null),new cljs.core.Keyword(null,\x22minpad\x22,\x22minpad\x22,323570901),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (p1__26043_SHARP_,p2__26044_SHARP_,p3__26045_SHARP_){\nreturn cljs.pprint.format_ascii(cljs.core.print_str,p1__26043_SHARP_,p2__26044_SHARP_,p3__26045_SHARP_);\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22S\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null),new cljs.core.Keyword(null,\x22minpad\x22,\x22minpad\x22,323570901),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (p1__26046_SHARP_,p2__26047_SHARP_,p3__26048_SHARP_){\nreturn cljs.pprint.format_ascii(cljs.core.pr_str,p1__26046_SHARP_,p2__26047_SHARP_,p3__26048_SHARP_);\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22D\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22,\x22,String], null),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(3),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (p1__26050_SHARP_,p2__26051_SHARP_,p3__26052_SHARP_){\nreturn cljs.pprint.format_integer((10),p1__26050_SHARP_,p2__26051_SHARP_,p3__26052_SHARP_);\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22B\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22,\x22,String], null),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(3),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (p1__26054_SHARP_,p2__26055_SHARP_,p3__26056_SHARP_){\nreturn cljs.pprint.format_integer((2),p1__26054_SHARP_,p2__26055_SHARP_,p3__26056_SHARP_);\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22O\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22,\x22,String], null),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(3),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (p1__26057_SHARP_,p2__26058_SHARP_,p3__26059_SHARP_){\nreturn cljs.pprint.format_integer((8),p1__26057_SHARP_,p2__26058_SHARP_,p3__26059_SHARP_);\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22X\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22,\x22,String], null),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(3),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (p1__26060_SHARP_,p2__26061_SHARP_,p3__26062_SHARP_){\nreturn cljs.pprint.format_integer((16),p1__26060_SHARP_,p2__26061_SHARP_,p3__26062_SHARP_);\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22R\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(5),[new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null),new cljs.core.Keyword(null,\x22commachar\x22,\x22commachar\x22,652859327),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22,\x22,String], null),new cljs.core.Keyword(null,\x22commainterval\x22,\x22commainterval\x22,-1980061083),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(3),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nif(cljs.core.truth_(cljs.core.first(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(params)))){\nreturn (function (p1__26063_SHARP_,p2__26064_SHARP_,p3__26065_SHARP_){\nreturn cljs.pprint.format_integer(new cljs.core.Keyword(null,\x22base\x22,\x22base\x22,185279322).cljs$core$IFn$_invoke$arity$1(p1__26063_SHARP_),p1__26063_SHARP_,p2__26064_SHARP_,p3__26065_SHARP_);\n});\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params);\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn (function (p1__26067_SHARP_,p2__26068_SHARP_,p3__26069_SHARP_){\nreturn cljs.pprint.format_old_roman(p1__26067_SHARP_,p2__26068_SHARP_,p3__26069_SHARP_);\n});\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))){\nreturn (function (p1__26070_SHARP_,p2__26071_SHARP_,p3__26072_SHARP_){\nreturn cljs.pprint.format_new_roman(p1__26070_SHARP_,p2__26071_SHARP_,p3__26072_SHARP_);\n});\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))){\nreturn (function (p1__26073_SHARP_,p2__26074_SHARP_,p3__26075_SHARP_){\nreturn cljs.pprint.format_ordinal_english(p1__26073_SHARP_,p2__26074_SHARP_,p3__26075_SHARP_);\n});\n} else {\nreturn (function (p1__26076_SHARP_,p2__26077_SHARP_,p3__26078_SHARP_){\nreturn cljs.pprint.format_cardinal_english(p1__26076_SHARP_,p2__26077_SHARP_,p3__26078_SHARP_);\n});\n\n}\n}\n}\n}\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22P\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,navigator,offsets){\nvar navigator__$1 \x3d (cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params__$1))?cljs.pprint.relative_reposition(navigator,(-1)):navigator);\nvar strs \x3d (cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params__$1))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22y\x22,\x22ies\x22], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22\x22,\x22s\x22], null));\nvar vec__26137 \x3d cljs.pprint.next_arg(navigator__$1);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26137,(0),null);\nvar navigator__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26137,(1),null);\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(arg,(1)))?cljs.core.first(strs):cljs.core.second(strs))], 0));\n\nreturn navigator__$2;\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22C\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22char-format\x22,\x22char-format\x22,-1016499218),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))){\nreturn cljs.pprint.pretty_character;\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))){\nreturn cljs.pprint.readable_character;\n} else {\nreturn cljs.pprint.plain_character;\n\n}\n}\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22F\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(5),[new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22k\x22,\x22k\x22,-2146297393),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,String], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn cljs.pprint.fixed_float;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22E\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(7),[new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22e\x22,\x22e\x22,1381269198),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22k\x22,\x22k\x22,-2146297393),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null),new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,String], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null),new cljs.core.Keyword(null,\x22exponentchar\x22,\x22exponentchar\x22,1986664222),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn cljs.pprint.exponential_float;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22G\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(7),[new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22e\x22,\x22e\x22,1381269198),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22k\x22,\x22k\x22,-2146297393),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null),new cljs.core.Keyword(null,\x22overflowchar\x22,\x22overflowchar\x22,-1620088106),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,String], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null),new cljs.core.Keyword(null,\x22exponentchar\x22,\x22exponentchar\x22,1986664222),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn cljs.pprint.general_float;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22$\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(2),Number], null),new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null),new cljs.core.Keyword(null,\x22w\x22,\x22w\x22,354169001),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn cljs.pprint.dollar_float;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22%\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22count\x22,\x22count\x22,2139924085),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),cljs.core.PersistentHashSet.EMPTY,new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,arg_navigator,offsets){\nvar n__5593__auto___28702 \x3d new cljs.core.Keyword(null,\x22count\x22,\x22count\x22,2139924085).cljs$core$IFn$_invoke$arity$1(params__$1);\nvar i_28703 \x3d (0);\nwhile(true){\nif((i_28703 \x3c n__5593__auto___28702)){\ncljs.pprint.prn();\n\nvar G__28705 \x3d (i_28703 + (1));\ni_28703 \x3d G__28705;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn arg_navigator;\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22\x26\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22count\x22,\x22count\x22,2139924085),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22pretty\x22,\x22pretty\x22,-1916372486),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,arg_navigator,offsets){\nvar cnt_28710 \x3d new cljs.core.Keyword(null,\x22count\x22,\x22count\x22,2139924085).cljs$core$IFn$_invoke$arity$1(params__$1);\nif((cnt_28710 \x3e (0))){\ncljs.pprint.fresh_line();\n} else {\n}\n\nvar n__5593__auto___28712 \x3d (cnt_28710 - (1));\nvar i_28713 \x3d (0);\nwhile(true){\nif((i_28713 \x3c n__5593__auto___28712)){\ncljs.pprint.prn();\n\nvar G__28714 \x3d (i_28713 + (1));\ni_28713 \x3d G__28714;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn arg_navigator;\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22|\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22count\x22,\x22count\x22,2139924085),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),cljs.core.PersistentHashSet.EMPTY,new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,arg_navigator,offsets){\nvar n__5593__auto___28715 \x3d new cljs.core.Keyword(null,\x22count\x22,\x22count\x22,2139924085).cljs$core$IFn$_invoke$arity$1(params__$1);\nvar i_28716 \x3d (0);\nwhile(true){\nif((i_28716 \x3c n__5593__auto___28715)){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22\\f\x22], 0));\n\nvar G__28717 \x3d (i_28716 + (1));\ni_28716 \x3d G__28717;\ncontinue;\n} else {\n}\nbreak;\n}\n\nreturn arg_navigator;\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22~\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),cljs.core.PersistentHashSet.EMPTY,new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,arg_navigator,offsets){\nvar n \x3d new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025).cljs$core$IFn$_invoke$arity$1(params__$1);\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(n,\x22~\x22))], 0));\n\nreturn arg_navigator;\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22\\n\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,arg_navigator,offsets){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params__$1))){\ncljs.pprint.prn();\n} else {\n}\n\nreturn arg_navigator;\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22T\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(2),[new cljs.core.Keyword(null,\x22colnum\x22,\x22colnum\x22,2023796854),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null),new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22pretty\x22,\x22pretty\x22,-1916372486),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))){\nreturn (function (p1__26085_SHARP_,p2__26086_SHARP_,p3__26087_SHARP_){\nreturn cljs.pprint.relative_tabulation(p1__26085_SHARP_,p2__26086_SHARP_,p3__26087_SHARP_);\n});\n} else {\nreturn (function (p1__26088_SHARP_,p2__26089_SHARP_,p3__26090_SHARP_){\nreturn cljs.pprint.absolute_tabulation(p1__26088_SHARP_,p2__26089_SHARP_,p3__26090_SHARP_);\n});\n}\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22*\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,navigator,offsets){\nvar n \x3d new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025).cljs$core$IFn$_invoke$arity$1(params__$1);\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params__$1))){\nreturn cljs.pprint.absolute_reposition(navigator,n);\n} else {\nreturn cljs.pprint.relative_reposition(navigator,(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params__$1))?(- n):n));\n}\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22?\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))){\nreturn (function (params__$1,navigator,offsets){\nvar vec__26207 \x3d cljs.pprint.get_format_arg(navigator);\nvar subformat \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26207,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26207,(1),null);\nreturn cljs.pprint.execute_sub_format(subformat,navigator__$1,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params__$1));\n});\n} else {\nreturn (function (params__$1,navigator,offsets){\nvar vec__26217 \x3d cljs.pprint.get_format_arg(navigator);\nvar subformat \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26217,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26217,(1),null);\nvar vec__26220 \x3d cljs.pprint.next_arg(navigator__$1);\nvar subargs \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26220,(0),null);\nvar navigator__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26220,(1),null);\nvar sub_navigator \x3d cljs.pprint.init_navigator(subargs);\ncljs.pprint.execute_sub_format(subformat,sub_navigator,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params__$1));\n\nreturn navigator__$2;\n});\n}\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22(\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833),\x22)\x22,new cljs.core.Keyword(null,\x22allows-separator\x22,\x22allows-separator\x22,-818967742),null,new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146),null], null),new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nvar mod_case_writer \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params);\n} else {\nreturn and__5000__auto__;\n}\n})())?cljs.pprint.upcase_writer:(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?cljs.pprint.capitalize_word_writer:(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))?cljs.pprint.init_cap_writer:cljs.pprint.downcase_writer\n)));\nreturn (function (p1__26095_SHARP_,p2__26096_SHARP_,p3__26097_SHARP_){\nreturn cljs.pprint.modify_case(mod_case_writer,p1__26095_SHARP_,p2__26096_SHARP_,p3__26097_SHARP_);\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22)\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),cljs.core.PersistentHashSet.EMPTY,new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn null;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22[\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22selector\x22,\x22selector\x22,762528866),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833),\x22]\x22,new cljs.core.Keyword(null,\x22allows-separator\x22,\x22allows-separator\x22,-818967742),true,new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146),new cljs.core.Keyword(null,\x22last\x22,\x22last\x22,1105735132)], null),new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))){\nreturn cljs.pprint.boolean_conditional;\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))){\nreturn cljs.pprint.check_arg_conditional;\n} else {\nreturn cljs.pprint.choice_conditional;\n\n}\n}\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22;\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(2),[new cljs.core.Keyword(null,\x22min-remaining\x22,\x22min-remaining\x22,962687677),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22max-columns\x22,\x22max-columns\x22,1742323262),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22separator\x22,\x22separator\x22,-1628749125),true], null),new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn null;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22]\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),cljs.core.PersistentHashSet.EMPTY,new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn null;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22{\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22max-iterations\x22,\x22max-iterations\x22,2021275563),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833),\x22}\x22,new cljs.core.Keyword(null,\x22allows-separator\x22,\x22allows-separator\x22,-818967742),false], null),new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params);\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn cljs.pprint.iterate_main_sublists;\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))){\nreturn cljs.pprint.iterate_list_of_sublists;\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))){\nreturn cljs.pprint.iterate_main_list;\n} else {\nreturn cljs.pprint.iterate_sublist;\n\n}\n}\n}\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22}\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn null;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22\x3c\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(4),[new cljs.core.Keyword(null,\x22mincol\x22,\x22mincol\x22,1230695445),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22colinc\x22,\x22colinc\x22,-584873385),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),Number], null),new cljs.core.Keyword(null,\x22minpad\x22,\x22minpad\x22,323570901),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null),new cljs.core.Keyword(null,\x22padchar\x22,\x22padchar\x22,2018584530),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,String], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null,new cljs.core.Keyword(null,\x22pretty\x22,\x22pretty\x22,-1916372486),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833),\x22\x3e\x22,new cljs.core.Keyword(null,\x22allows-separator\x22,\x22allows-separator\x22,-818967742),true,new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146),new cljs.core.Keyword(null,\x22first\x22,\x22first\x22,-644103046)], null),new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn cljs.pprint.logical_block_or_justify;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22\x3e\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn null;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22^\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(3),[new cljs.core.Keyword(null,\x22arg1\x22,\x22arg1\x22,951899358),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22arg2\x22,\x22arg2\x22,1729550917),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null),new cljs.core.Keyword(null,\x22arg3\x22,\x22arg3\x22,-1486822496),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn (function (params__$1,navigator,offsets){\nvar arg1 \x3d new cljs.core.Keyword(null,\x22arg1\x22,\x22arg1\x22,951899358).cljs$core$IFn$_invoke$arity$1(params__$1);\nvar arg2 \x3d new cljs.core.Keyword(null,\x22arg2\x22,\x22arg2\x22,1729550917).cljs$core$IFn$_invoke$arity$1(params__$1);\nvar arg3 \x3d new cljs.core.Keyword(null,\x22arg3\x22,\x22arg3\x22,-1486822496).cljs$core$IFn$_invoke$arity$1(params__$1);\nvar exit \x3d (cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params__$1))?new cljs.core.Keyword(null,\x22colon-up-arrow\x22,\x22colon-up-arrow\x22,244853007):new cljs.core.Keyword(null,\x22up-arrow\x22,\x22up-arrow\x22,1705310333));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d arg1;\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d arg2;\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn arg3;\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())){\nif((((arg1 \x3c\x3d arg2)) \x26\x26 ((arg2 \x3c\x3d arg3)))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [exit,navigator], null);\n} else {\nreturn navigator;\n}\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d arg1;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn arg2;\n} else {\nreturn and__5000__auto__;\n}\n})())){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(arg1,arg2)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [exit,navigator], null);\n} else {\nreturn navigator;\n}\n} else {\nif(cljs.core.truth_(arg1)){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(arg1,(0))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [exit,navigator], null);\n} else {\nreturn navigator;\n}\n} else {\nif((cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params__$1))?cljs.core.empty_QMARK_(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822).cljs$core$IFn$_invoke$arity$1(params__$1))):cljs.core.empty_QMARK_(new cljs.core.Keyword(null,\x22rest\x22,\x22rest\x22,-1241696419).cljs$core$IFn$_invoke$arity$1(navigator)))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [exit,navigator], null);\n} else {\nreturn navigator;\n}\n\n}\n}\n}\n});\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22W\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null,new cljs.core.Keyword(null,\x22pretty\x22,\x22pretty\x22,-1916372486),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params);\n}\n})())){\nvar bindings \x3d cljs.core.concat.cljs$core$IFn$_invoke$arity$2((cljs.core.truth_(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(params))?new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22level\x22,\x22level\x22,1290497552),null,new cljs.core.Keyword(null,\x22length\x22,\x22length\x22,588987862),null], null):cljs.core.PersistentVector.EMPTY),(cljs.core.truth_(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22pretty\x22,\x22pretty\x22,-1916372486),true], null):cljs.core.PersistentVector.EMPTY));\nreturn (function (params__$1,navigator,offsets){\nvar vec__26256 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26256,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26256,(1),null);\nif(cljs.core.truth_(cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.pprint.write,arg,bindings))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22up-arrow\x22,\x22up-arrow\x22,1705310333),navigator__$1], null);\n} else {\nreturn navigator__$1;\n}\n});\n} else {\nreturn (function (params__$1,navigator,offsets){\nvar vec__26260 \x3d cljs.pprint.next_arg(navigator);\nvar arg \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26260,(0),null);\nvar navigator__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26260,(1),null);\nif(cljs.core.truth_(cljs.pprint.write_out(arg))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22up-arrow\x22,\x22up-arrow\x22,1705310333),navigator__$1], null);\n} else {\nreturn navigator__$1;\n}\n});\n}\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22_\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349),null,new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn cljs.pprint.conditional_newline;\n})], null),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132),\x22I\x22,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235),(new cljs.core.PersistentArrayMap(null,(1),[new cljs.core.Keyword(null,\x22n\x22,\x22n\x22,562130025),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(0),Number], null)],null)),new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),null], null), null),new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656),(function (params,offset){\nreturn cljs.pprint.set_indent;\n})], null)]);\ncljs.pprint.param_pattern \x3d /^([vV]|#|(\x27.)|([+-]?\\d+)|(?\x3d,))/;\ncljs.pprint.special_params \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22remaining-arg-count\x22,\x22remaining-arg-count\x22,-1216589335),null,new cljs.core.Keyword(null,\x22parameter-from-args\x22,\x22parameter-from-args\x22,-758446196),null], null), null);\ncljs.pprint.extract_param \x3d (function cljs$pprint$extract_param(p__26310){\nvar vec__26311 \x3d p__26310;\nvar s \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26311,(0),null);\nvar offset \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26311,(1),null);\nvar saw_comma \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26311,(2),null);\nvar m \x3d (new RegExp(cljs.pprint.param_pattern.source,\x22g\x22));\nvar param \x3d m.exec(s);\nif(cljs.core.truth_(param)){\nvar token_str \x3d cljs.core.first(param);\nvar remainder \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,m.lastIndex);\nvar new_offset \x3d (offset + m.lastIndex);\nif((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22,\x22,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(remainder,(0)))))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [token_str,offset], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [remainder,new_offset,false], null)], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [token_str,offset], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.subs.cljs$core$IFn$_invoke$arity$2(remainder,(1)),(new_offset + (1)),true], null)], null);\n}\n} else {\nif(cljs.core.truth_(saw_comma)){\nreturn cljs.pprint.format_error(\x22Badly formed parameters in format directive\x22,offset);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [s,offset], null)], null);\n}\n}\n});\ncljs.pprint.extract_params \x3d (function cljs$pprint$extract_params(s,offset){\nreturn cljs.pprint.consume(cljs.pprint.extract_param,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [s,offset,false], null));\n});\n/**\n * Translate the string representation of a param to the internalized\n *                                    representation\n */\ncljs.pprint.translate_param \x3d (function cljs$pprint$translate_param(p__26333){\nvar vec__26335 \x3d p__26333;\nvar p \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26335,(0),null);\nvar offset \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26335,(1),null);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(p.length,(0)))?null:((((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(p.length,(1))) \x26\x26 (cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [\x22V\x22,null,\x22v\x22,null], null), null),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(p,(0))))))?new cljs.core.Keyword(null,\x22parameter-from-args\x22,\x22parameter-from-args\x22,-758446196):((((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(p.length,(1))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22#\x22,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(p,(0))))))?new cljs.core.Keyword(null,\x22remaining-arg-count\x22,\x22remaining-arg-count\x22,-1216589335):((((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(p.length,(2))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22\x27\x22,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(p,(0))))))?cljs.core.nth.cljs$core$IFn$_invoke$arity$2(p,(1)):parseInt(p,(10))\n)))),offset], null);\n});\ncljs.pprint.flag_defs \x3d new cljs.core.PersistentArrayMap(null, 2, [\x22:\x22,new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945),\x22@\x22,new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349)], null);\ncljs.pprint.extract_flags \x3d (function cljs$pprint$extract_flags(s,offset){\nreturn cljs.pprint.consume((function (p__26362){\nvar vec__26383 \x3d p__26362;\nvar s__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26383,(0),null);\nvar offset__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26383,(1),null);\nvar flags \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26383,(2),null);\nif(cljs.core.empty_QMARK_(s__$1)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [s__$1,offset__$1,flags], null)], null);\n} else {\nvar flag \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.pprint.flag_defs,cljs.core.first(s__$1));\nif(cljs.core.truth_(flag)){\nif(cljs.core.contains_QMARK_(flags,flag)){\nreturn cljs.pprint.format_error([\x22Flag \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(s__$1)),\x22\\\x22 appears more than once in a directive\x22].join(\x27\x27),offset__$1);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [true,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s__$1,(1)),(offset__$1 + (1)),cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(flags,flag,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [true,offset__$1], null))], null)], null);\n}\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [s__$1,offset__$1,flags], null)], null);\n}\n}\n}),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [s,offset,cljs.core.PersistentArrayMap.EMPTY], null));\n});\ncljs.pprint.check_flags \x3d (function cljs$pprint$check_flags(def,flags){\nvar allowed \x3d new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075).cljs$core$IFn$_invoke$arity$1(def);\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(allowed));\nif(and__5000__auto__){\nreturn new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(flags);\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.pprint.format_error([\x22\\\x22@\\\x22 is an illegal flag for format directive \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132).cljs$core$IFn$_invoke$arity$1(def)),\x22\\\x22\x22].join(\x27\x27),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(flags),(1)));\n} else {\n}\n\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(allowed));\nif(and__5000__auto__){\nreturn new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(flags);\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.pprint.format_error([\x22\\\x22:\\\x22 is an illegal flag for format directive \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132).cljs$core$IFn$_invoke$arity$1(def)),\x22\\\x22\x22].join(\x27\x27),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(flags),(1)));\n} else {\n}\n\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(new cljs.core.Keyword(null,\x22both\x22,\x22both\x22,-393648840).cljs$core$IFn$_invoke$arity$1(allowed));\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(flags);\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(flags);\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn cljs.pprint.format_error([\x22Cannot combine \\\x22@\\\x22 and \\\x22:\\\x22 flags for format directive \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132).cljs$core$IFn$_invoke$arity$1(def)),\x22\\\x22\x22].join(\x27\x27),(function (){var x__5090__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(flags),(1));\nvar y__5091__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22at\x22,\x22at\x22,1476951349).cljs$core$IFn$_invoke$arity$1(flags),(1));\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})());\n} else {\nreturn null;\n}\n});\n/**\n * Takes a directive definition and the list of actual parameters and\n * a map of flags and returns a map of the parameters and flags with defaults\n * filled in. We check to make sure that there are the right types and number\n * of parameters as well.\n */\ncljs.pprint.map_params \x3d (function cljs$pprint$map_params(def,params,flags,offset){\ncljs.pprint.check_flags(def,flags);\n\nif((cljs.core.count(params) \x3e cljs.core.count(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(def)))){\ncljs.pprint.format_error(cljs.pprint.cl_format.cljs$core$IFn$_invoke$arity$variadic(null,\x22Too many parameters for directive \\\x22~C\\\x22: ~D~:* ~[were~;was~:;were~] specified but only ~D~:* ~[are~;is~:;are~] allowed\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132).cljs$core$IFn$_invoke$arity$1(def),cljs.core.count(params),cljs.core.count(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(def))], 0)),cljs.core.second(cljs.core.first(params)));\n} else {\n}\n\ncljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (p1__26505_SHARP_,p2__26508_SHARP_){\nvar val \x3d cljs.core.first(p1__26505_SHARP_);\nif((!((((val \x3d\x3d null)) || (((cljs.core.contains_QMARK_(cljs.pprint.special_params,val)) || (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.second(cljs.core.second(p2__26508_SHARP_)),cljs.core.type(val))))))))){\nreturn cljs.pprint.format_error([\x22Parameter \x22,cljs.core.name(cljs.core.first(p2__26508_SHARP_)),\x22 has bad type in directive \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132).cljs$core$IFn$_invoke$arity$1(def)),\x22\\\x22: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.type(val))].join(\x27\x27),cljs.core.second(p1__26505_SHARP_));\n} else {\nreturn null;\n}\n}),params,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(def)));\n\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.reverse((function (){var iter__5480__auto__ \x3d (function cljs$pprint$map_params_$_iter__26556(s__26557){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__26557__$1 \x3d s__26557;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__26557__$1);\nif(temp__5804__auto__){\nvar s__26557__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__26557__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__26557__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__26559 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__26558 \x3d (0);\nwhile(true){\nif((i__26558 \x3c size__5479__auto__)){\nvar vec__26573 \x3d cljs.core._nth(c__5478__auto__,i__26558);\nvar name \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26573,(0),null);\nvar vec__26576 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26573,(1),null);\nvar default$ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26576,(0),null);\ncljs.core.chunk_append(b__26559,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [name,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [default$,offset], null)], null));\n\nvar G__28753 \x3d (i__26558 + (1));\ni__26558 \x3d G__28753;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__26559),cljs$pprint$map_params_$_iter__26556(cljs.core.chunk_rest(s__26557__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__26559),null);\n}\n} else {\nvar vec__26588 \x3d cljs.core.first(s__26557__$2);\nvar name \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26588,(0),null);\nvar vec__26591 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26588,(1),null);\nvar default$ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26591,(0),null);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [name,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [default$,offset], null)], null),cljs$pprint$map_params_$_iter__26556(cljs.core.rest(s__26557__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(def));\n})())),cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__26516_SHARP_,p2__26517_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.assoc,p1__26516_SHARP_,p2__26517_SHARP_);\n}),cljs.core.PersistentArrayMap.EMPTY,cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__26523_SHARP_){\nreturn cljs.core.first(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(p1__26523_SHARP_,(1)));\n}),cljs.core.zipmap(cljs.core.keys(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(def)),params))),flags], 0));\n});\ncljs.pprint.compile_directive \x3d (function cljs$pprint$compile_directive(s,offset){\nvar vec__26622 \x3d cljs.pprint.extract_params(s,offset);\nvar raw_params \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26622,(0),null);\nvar vec__26625 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26622,(1),null);\nvar rest \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26625,(0),null);\nvar offset__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26625,(1),null);\nvar vec__26628 \x3d cljs.pprint.extract_flags(rest,offset__$1);\nvar _ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26628,(0),null);\nvar vec__26631 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26628,(1),null);\nvar rest__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26631,(0),null);\nvar offset__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26631,(1),null);\nvar flags \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26631,(2),null);\nvar directive \x3d cljs.core.first(rest__$1);\nvar def \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.pprint.directive_table,clojure.string.upper_case(directive));\nvar params \x3d (cljs.core.truth_(def)?cljs.pprint.map_params(def,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.pprint.translate_param,raw_params),flags,offset__$2):null);\nif(cljs.core.not(directive)){\ncljs.pprint.format_error(\x22Format string ended in the middle of a directive\x22,offset__$2);\n} else {\n}\n\nif(cljs.core.not(def)){\ncljs.pprint.format_error([\x22Directive \\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(directive),\x22\\\x22 is undefined\x22].join(\x27\x27),offset__$2);\n} else {\n}\n\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.pprint.compiled_directive((function (){var fexpr__26649 \x3d new cljs.core.Keyword(null,\x22generator-fn\x22,\x22generator-fn\x22,811851656).cljs$core$IFn$_invoke$arity$1(def);\nreturn (fexpr__26649.cljs$core$IFn$_invoke$arity$2 ? fexpr__26649.cljs$core$IFn$_invoke$arity$2(params,offset__$2) : fexpr__26649.call(null, params,offset__$2));\n})(),def,params,offset__$2,null,null,null)),(function (){var remainder \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$2(rest__$1,(1));\nvar offset__$3 \x3d (offset__$2 + (1));\nvar trim_QMARK_ \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22\\n\x22,new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132).cljs$core$IFn$_invoke$arity$1(def))) \x26\x26 (cljs.core.not(new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(params))));\nvar trim_count \x3d ((trim_QMARK_)?cljs.pprint.prefix_count(remainder,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22 \x22,\x22\\t\x22], null)):(0));\nvar remainder__$1 \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$2(remainder,trim_count);\nvar offset__$4 \x3d (offset__$3 + trim_count);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [remainder__$1,offset__$4], null);\n})()], null);\n});\ncljs.pprint.compile_raw_string \x3d (function cljs$pprint$compile_raw_string(s,offset){\nreturn (new cljs.pprint.compiled_directive((function (_,a,___$1){\ncljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([s], 0));\n\nreturn a;\n}),null,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22string\x22,\x22string\x22,-1989541586),s], null),offset,null,null,null));\n});\ncljs.pprint.right_bracket \x3d (function cljs$pprint$right_bracket(this$){\nreturn new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(this$)));\n});\ncljs.pprint.separator_QMARK_ \x3d (function cljs$pprint$separator_QMARK_(this$){\nreturn new cljs.core.Keyword(null,\x22separator\x22,\x22separator\x22,-1628749125).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(this$)));\n});\ncljs.pprint.else_separator_QMARK_ \x3d (function cljs$pprint$else_separator_QMARK_(this$){\nvar and__5000__auto__ \x3d new cljs.core.Keyword(null,\x22separator\x22,\x22separator\x22,-1628749125).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(this$)));\nif(cljs.core.truth_(and__5000__auto__)){\nreturn new cljs.core.Keyword(null,\x22colon\x22,\x22colon\x22,-965200945).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(this$));\n} else {\nreturn and__5000__auto__;\n}\n});\ncljs.pprint.process_bracket \x3d (function cljs$pprint$process_bracket(this$,remainder){\nvar vec__26694 \x3d cljs.pprint.collect_clauses(new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(this$)),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311).cljs$core$IFn$_invoke$arity$1(this$),remainder);\nvar subex \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26694,(0),null);\nvar remainder__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26694,(1),null);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.pprint.compiled_directive(new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040).cljs$core$IFn$_invoke$arity$1(this$),new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(this$),cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(this$),cljs.pprint.tuple_map(subex,new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311).cljs$core$IFn$_invoke$arity$1(this$))], 0)),new cljs.core.Keyword(null,\x22offset\x22,\x22offset\x22,296498311).cljs$core$IFn$_invoke$arity$1(this$),null,null,null)),remainder__$1], null);\n});\ncljs.pprint.process_clause \x3d (function cljs$pprint$process_clause(bracket_info,offset,remainder){\nreturn cljs.pprint.consume((function (remainder__$1){\nif(cljs.core.empty_QMARK_(remainder__$1)){\nreturn cljs.pprint.format_error(\x22No closing bracket found.\x22,offset);\n} else {\nvar this$ \x3d cljs.core.first(remainder__$1);\nvar remainder__$2 \x3d cljs.core.next(remainder__$1);\nif(cljs.core.truth_(cljs.pprint.right_bracket(this$))){\nreturn cljs.pprint.process_bracket(this$,remainder__$2);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833).cljs$core$IFn$_invoke$arity$1(bracket_info),new cljs.core.Keyword(null,\x22directive\x22,\x22directive\x22,793559132).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(this$)))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22right-bracket\x22,\x22right-bracket\x22,951856080),new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(this$),null,remainder__$2], null)], null);\n} else {\nif(cljs.core.truth_(cljs.pprint.else_separator_QMARK_(this$))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146),null,new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(this$),remainder__$2], null)], null);\n} else {\nif(cljs.core.truth_(cljs.pprint.separator_QMARK_(this$))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22separator\x22,\x22separator\x22,-1628749125),null,null,remainder__$2], null)], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [this$,remainder__$2], null);\n\n}\n}\n}\n}\n}\n}),remainder);\n});\ncljs.pprint.collect_clauses \x3d (function cljs$pprint$collect_clauses(bracket_info,offset,remainder){\nreturn cljs.core.second(cljs.pprint.consume((function (p__26718){\nvar vec__26719 \x3d p__26718;\nvar clause_map \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26719,(0),null);\nvar saw_else \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26719,(1),null);\nvar remainder__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26719,(2),null);\nvar vec__26723 \x3d cljs.pprint.process_clause(bracket_info,offset,remainder__$1);\nvar clause \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26723,(0),null);\nvar vec__26726 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26723,(1),null);\nvar type \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26726,(0),null);\nvar right_params \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26726,(1),null);\nvar else_params \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26726,(2),null);\nvar remainder__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26726,(3),null);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(type,new cljs.core.Keyword(null,\x22right-bracket\x22,\x22right-bracket\x22,951856080))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic(cljs.core.concat,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([clause_map,cljs.core.PersistentArrayMap.createAsIfByAssoc([(cljs.core.truth_(saw_else)?new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146):new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241)),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [clause], null),new cljs.core.Keyword(null,\x22right-params\x22,\x22right-params\x22,-1790676237),right_params])], 0)),remainder__$2], null)], null);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(type,new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146))){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146).cljs$core$IFn$_invoke$arity$1(clause_map))){\nreturn cljs.pprint.format_error(\x22Two else clauses (\\\x22~:;\\\x22) inside bracket construction.\x22,offset);\n} else {\nif(cljs.core.not(new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146).cljs$core$IFn$_invoke$arity$1(bracket_info))){\nreturn cljs.pprint.format_error(\x22An else clause (\\\x22~:;\\\x22) is in a bracket type that doesn\x27t support it.\x22,offset);\n} else {\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22first\x22,\x22first\x22,-644103046),new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146).cljs$core$IFn$_invoke$arity$1(bracket_info))) \x26\x26 (cljs.core.seq(new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(clause_map))))){\nreturn cljs.pprint.format_error(\x22The else clause (\\\x22~:;\\\x22) is only allowed in the first position for this directive.\x22,offset);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22first\x22,\x22first\x22,-644103046),new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146).cljs$core$IFn$_invoke$arity$1(bracket_info))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [true,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic(cljs.core.concat,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([clause_map,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [clause], null),new cljs.core.Keyword(null,\x22else-params\x22,\x22else-params\x22,-832171646),else_params], null)], 0)),false,remainder__$2], null)], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [true,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic(cljs.core.concat,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([clause_map,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [clause], null)], null)], 0)),true,remainder__$2], null)], null);\n}\n\n}\n}\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(type,new cljs.core.Keyword(null,\x22separator\x22,\x22separator\x22,-1628749125))){\nif(cljs.core.truth_(saw_else)){\nreturn cljs.pprint.format_error(\x22A plain clause (with \\\x22~;\\\x22) follows an else clause (\\\x22~:;\\\x22) inside bracket construction.\x22,offset);\n} else {\nif(cljs.core.not(new cljs.core.Keyword(null,\x22allows-separator\x22,\x22allows-separator\x22,-818967742).cljs$core$IFn$_invoke$arity$1(bracket_info))){\nreturn cljs.pprint.format_error(\x22A separator (\\\x22~;\\\x22) is in a bracket type that doesn\x27t support it.\x22,offset);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [true,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic(cljs.core.concat,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([clause_map,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [clause], null)], null)], 0)),false,remainder__$2], null)], null);\n\n}\n}\n} else {\nreturn null;\n}\n}\n}\n}),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241),cljs.core.PersistentVector.EMPTY], null),false,remainder], null)));\n});\n/**\n * Take a linearly compiled format and process the bracket directives to give it\n * the appropriate tree structure\n */\ncljs.pprint.process_nesting \x3d (function cljs$pprint$process_nesting(format){\nreturn cljs.core.first(cljs.pprint.consume((function (remainder){\nvar this$ \x3d cljs.core.first(remainder);\nvar remainder__$1 \x3d cljs.core.next(remainder);\nvar bracket \x3d new cljs.core.Keyword(null,\x22bracket-info\x22,\x22bracket-info\x22,-1600092774).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(this$));\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833).cljs$core$IFn$_invoke$arity$1(bracket))){\nreturn cljs.pprint.process_bracket(this$,remainder__$1);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [this$,remainder__$1], null);\n}\n}),format));\n});\n/**\n * Compiles format-str into a compiled format which can be used as an argument\n * to cl-format just like a plain format string. Use this function for improved\n * performance when you\x27re using the same format string repeatedly\n */\ncljs.pprint.compile_format \x3d (function cljs$pprint$compile_format(format_str){\nvar _STAR_format_str_STAR__orig_val__26790 \x3d cljs.pprint._STAR_format_str_STAR_;\nvar _STAR_format_str_STAR__temp_val__26791 \x3d format_str;\n(cljs.pprint._STAR_format_str_STAR_ \x3d _STAR_format_str_STAR__temp_val__26791);\n\ntry{return cljs.pprint.process_nesting(cljs.core.first(cljs.pprint.consume((function (p__26803){\nvar vec__26804 \x3d p__26803;\nvar s \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26804,(0),null);\nvar offset \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26804,(1),null);\nif(cljs.core.empty_QMARK_(s)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,s], null);\n} else {\nvar tilde \x3d s.indexOf(\x22~\x22);\nif((tilde \x3c (0))){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.pprint.compile_raw_string(s,offset),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22\x22,(offset + s.length)], null)], null);\n} else {\nif((tilde \x3d\x3d\x3d (0))){\nreturn cljs.pprint.compile_directive(cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,(1)),(offset + (1)));\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.pprint.compile_raw_string(cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),tilde),offset),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,tilde),(tilde + offset)], null)], null);\n\n}\n}\n}\n}),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [format_str,(0)], null))));\n}finally {(cljs.pprint._STAR_format_str_STAR_ \x3d _STAR_format_str_STAR__orig_val__26790);\n}});\n/**\n * determine whether a given compiled format has any directives that depend on the\n * column number or pretty printing\n */\ncljs.pprint.needs_pretty \x3d (function cljs$pprint$needs_pretty(format){\nvar format__$1 \x3d format;\nwhile(true){\nif(cljs.core.empty_QMARK_(format__$1)){\nreturn false;\n} else {\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22pretty\x22,\x22pretty\x22,-1916372486).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22flags\x22,\x22flags\x22,1775418075).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22def\x22,\x22def\x22,-1043430536).cljs$core$IFn$_invoke$arity$1(cljs.core.first(format__$1))));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d cljs.core.some(cljs.pprint.needs_pretty,cljs.core.first(new cljs.core.Keyword(null,\x22clauses\x22,\x22clauses\x22,1454841241).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(cljs.core.first(format__$1)))));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn cljs.core.some(cljs.pprint.needs_pretty,cljs.core.first(new cljs.core.Keyword(null,\x22else\x22,\x22else\x22,-1508377146).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(cljs.core.first(format__$1)))));\n}\n}\n})())){\nreturn true;\n} else {\nvar G__28780 \x3d cljs.core.next(format__$1);\nformat__$1 \x3d G__28780;\ncontinue;\n}\n}\nbreak;\n}\n});\n/**\n * Executes the format with the arguments.\n */\ncljs.pprint.execute_format \x3d (function cljs$pprint$execute_format(var_args){\nvar G__26830 \x3d arguments.length;\nswitch (G__26830) {\ncase 3:\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 2:\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$3 \x3d (function (stream,format,args){\nvar sb \x3d (new goog.string.StringBuffer());\nvar real_stream \x3d ((((cljs.core.not(stream)) || (stream \x3d\x3d\x3d true)))?(new cljs.core.StringBufferWriter(sb)):stream);\nvar wrapped_stream \x3d ((((cljs.pprint.needs_pretty(format)) \x26\x26 (cljs.core.not(cljs.pprint.pretty_writer_QMARK_(real_stream)))))?cljs.pprint.get_pretty_writer(real_stream):real_stream);\nvar _STAR_out_STAR__orig_val__26854 \x3d cljs.core._STAR_out_STAR_;\nvar _STAR_out_STAR__temp_val__26855 \x3d wrapped_stream;\n(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__temp_val__26855);\n\ntry{try{cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(format,args);\n}finally {if((!((real_stream \x3d\x3d\x3d wrapped_stream)))){\ncljs.core._flush(wrapped_stream);\n} else {\n}\n}\nif(cljs.core.not(stream)){\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb);\n} else {\nif(stream \x3d\x3d\x3d true){\nreturn cljs.core.string_print(cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb));\n} else {\nreturn null;\n\n}\n}\n}finally {(cljs.core._STAR_out_STAR_ \x3d _STAR_out_STAR__orig_val__26854);\n}}));\n\n(cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2 \x3d (function (format,args){\ncljs.pprint.map_passing_context((function (element,context){\nif(cljs.pprint.abort_QMARK_(context)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,context], null);\n} else {\nvar vec__26880 \x3d cljs.pprint.realize_parameter_list(new cljs.core.Keyword(null,\x22params\x22,\x22params\x22,710516235).cljs$core$IFn$_invoke$arity$1(element),context);\nvar params \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26880,(0),null);\nvar args__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26880,(1),null);\nvar vec__26884 \x3d cljs.pprint.unzip_map(params);\nvar params__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26884,(0),null);\nvar offsets \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26884,(1),null);\nvar params__$2 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(params__$1,new cljs.core.Keyword(null,\x22base-args\x22,\x22base-args\x22,-1268706822),args__$1);\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22func\x22,\x22func\x22,-238706040).cljs$core$IFn$_invoke$arity$1(element),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [params__$2,args__$1,offsets], null))], null);\n}\n}),args,format);\n\nreturn null;\n}));\n\n(cljs.pprint.execute_format.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.pprint.cached_compile \x3d cljs.core.memoize(cljs.pprint.compile_format);\n/**\n * Installs a function as a new method of multimethod associated with dispatch-value. \n */\ncljs.pprint.use_method \x3d (function cljs$pprint$use_method(multifn,dispatch_val,func){\nreturn cljs.core._add_method(multifn,dispatch_val,func);\n});\ncljs.pprint.reader_macros \x3d new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Symbol(null,\x22quote\x22,\x22quote\x22,1377916282,null),\x22\x27\x22,new cljs.core.Symbol(null,\x22var\x22,\x22var\x22,870848730,null),\x22#\x27\x22,new cljs.core.Symbol(\x22clojure.core\x22,\x22deref\x22,\x22clojure.core/deref\x22,188719157,null),\x22@\x22,new cljs.core.Symbol(\x22clojure.core\x22,\x22unquote\x22,\x22clojure.core/unquote\x22,843087510,null),\x22~\x22,new cljs.core.Symbol(\x22cljs.core\x22,\x22deref\x22,\x22cljs.core/deref\x22,1901963335,null),\x22@\x22,new cljs.core.Symbol(\x22cljs.core\x22,\x22unquote\x22,\x22cljs.core/unquote\x22,1013085760,null),\x22~\x22], null);\ncljs.pprint.pprint_reader_macro \x3d (function cljs$pprint$pprint_reader_macro(alis){\nvar macro_char \x3d (function (){var G__26910 \x3d cljs.core.first(alis);\nreturn (cljs.pprint.reader_macros.cljs$core$IFn$_invoke$arity$1 ? cljs.pprint.reader_macros.cljs$core$IFn$_invoke$arity$1(G__26910) : cljs.pprint.reader_macros.call(null, G__26910));\n})();\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d macro_char;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((2),cljs.core.count(alis));\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.core._write(cljs.core._STAR_out_STAR_,macro_char);\n\ncljs.pprint.write_out(cljs.core.second(alis));\n\nreturn true;\n} else {\nreturn null;\n}\n});\ncljs.pprint.pprint_simple_list \x3d (function cljs$pprint$pprint_simple_list(alis){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__26913_28791 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__26914_28792 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__26915_28793 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__26916_28794 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__26915_28793);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__26916_28794);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22(\x22,null,\x22)\x22);\n\nvar length_count26917_28795 \x3d (0);\nvar alis_28796__$1 \x3d cljs.core.seq(alis);\nwhile(true){\nif(((cljs.core.not(cljs.core._STAR_print_length_STAR_)) || ((length_count26917_28795 \x3c cljs.core._STAR_print_length_STAR_)))){\nif(alis_28796__$1){\ncljs.pprint.write_out(cljs.core.first(alis_28796__$1));\n\nif(cljs.core.next(alis_28796__$1)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__28797 \x3d (length_count26917_28795 + (1));\nvar G__28798 \x3d cljs.core.next(alis_28796__$1);\nlength_count26917_28795 \x3d G__28797;\nalis_28796__$1 \x3d G__28798;\ncontinue;\n} else {\n}\n} else {\n}\n} else {\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__26914_28792);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__26913_28791);\n}}\n\nreturn null;\n});\ncljs.pprint.pprint_list \x3d (function cljs$pprint$pprint_list(alis){\nif(cljs.core.not(cljs.pprint.pprint_reader_macro(alis))){\nreturn cljs.pprint.pprint_simple_list(alis);\n} else {\nreturn null;\n}\n});\ncljs.pprint.pprint_vector \x3d (function cljs$pprint$pprint_vector(avec){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__26926_28801 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__26927_28802 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__26928_28803 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__26929_28804 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__26928_28803);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__26929_28804);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22[\x22,null,\x22]\x22);\n\nvar length_count26933_28806 \x3d (0);\nvar aseq_28807 \x3d cljs.core.seq(avec);\nwhile(true){\nif(((cljs.core.not(cljs.core._STAR_print_length_STAR_)) || ((length_count26933_28806 \x3c cljs.core._STAR_print_length_STAR_)))){\nif(aseq_28807){\ncljs.pprint.write_out(cljs.core.first(aseq_28807));\n\nif(cljs.core.next(aseq_28807)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__28808 \x3d (length_count26933_28806 + (1));\nvar G__28809 \x3d cljs.core.next(aseq_28807);\nlength_count26933_28806 \x3d G__28808;\naseq_28807 \x3d G__28809;\ncontinue;\n} else {\n}\n} else {\n}\n} else {\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__26927_28802);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__26926_28801);\n}}\n\nreturn null;\n});\ncljs.pprint.pprint_array \x3d (function (){var format_in__21692__auto__ \x3d \x22~\x3c[~;~@{~w~^, ~:_~}~;]~:\x3e\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28810__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28810 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28811__i \x3d 0, G__28811__a \x3d new Array(arguments.length -  0);\nwhile (G__28811__i \x3c G__28811__a.length) {G__28811__a[G__28811__i] \x3d arguments[G__28811__i + 0]; ++G__28811__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28811__a,0,null);\n} \nreturn G__28810__delegate.call(this,args__21694__auto__);};\nG__28810.cljs$lang$maxFixedArity \x3d 0;\nG__28810.cljs$lang$applyTo \x3d (function (arglist__28812){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28812);\nreturn G__28810__delegate(args__21694__auto__);\n});\nG__28810.cljs$core$IFn$_invoke$arity$variadic \x3d G__28810__delegate;\nreturn G__28810;\n})()\n;\n})();\ncljs.pprint.pprint_map \x3d (function cljs$pprint$pprint_map(amap){\nvar vec__26961 \x3d (((!(cljs.core.record_QMARK_(amap))))?(function (){var fexpr__26974 \x3d new cljs.core.Var(function(){return cljs.core.lift_ns;},new cljs.core.Symbol(\x22cljs.core\x22,\x22lift-ns\x22,\x22cljs.core/lift-ns\x22,463499081,null),cljs.core.PersistentHashMap.fromArrays([new cljs.core.Keyword(null,\x22private\x22,\x22private\x22,-558947994),new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),new cljs.core.Keyword(null,\x22name\x22,\x22name\x22,1843675177),new cljs.core.Keyword(null,\x22file\x22,\x22file\x22,-1269645878),new cljs.core.Keyword(null,\x22end-column\x22,\x22end-column\x22,1425389514),new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095),new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),new cljs.core.Keyword(null,\x22end-line\x22,\x22end-line\x22,1837326455),new cljs.core.Keyword(null,\x22arglists\x22,\x22arglists\x22,1661989754),new cljs.core.Keyword(null,\x22doc\x22,\x22doc\x22,1913296891),new cljs.core.Keyword(null,\x22test\x22,\x22test\x22,577538877)],[true,new cljs.core.Symbol(null,\x22cljs.core\x22,\x22cljs.core\x22,770546058,null),new cljs.core.Symbol(null,\x22lift-ns\x22,\x22lift-ns\x22,602311926,null),\x22cljs/core.cljs\x22,15,1,10696,10696,cljs.core.list(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22m\x22,\x22m\x22,-1021758608,null)], null)),\x22Returns [lifted-ns lifted-map] or nil if m can\x27t be lifted.\x22,(cljs.core.truth_(cljs.core.lift_ns)?cljs.core.lift_ns.cljs$lang$test:null)]));\nreturn (fexpr__26974.cljs$core$IFn$_invoke$arity$1 ? fexpr__26974.cljs$core$IFn$_invoke$arity$1(amap) : fexpr__26974.call(null, amap));\n})():null);\nvar ns \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26961,(0),null);\nvar lift_map \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26961,(1),null);\nvar amap__$1 \x3d (function (){var or__5002__auto__ \x3d lift_map;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn amap;\n}\n})();\nvar prefix \x3d (cljs.core.truth_(ns)?[\x22#:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns),\x22{\x22].join(\x27\x27):\x22{\x22);\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__26977_28813 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__26978_28814 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__26979_28815 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__26980_28816 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__26979_28815);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__26980_28816);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,prefix,null,\x22}\x22);\n\nvar length_count26982_28817 \x3d (0);\nvar aseq_28818 \x3d cljs.core.seq(amap__$1);\nwhile(true){\nif(((cljs.core.not(cljs.core._STAR_print_length_STAR_)) || ((length_count26982_28817 \x3c cljs.core._STAR_print_length_STAR_)))){\nif(aseq_28818){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__26988_28819 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__26989_28820 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__26990_28821 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__26991_28822 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__26990_28821);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__26991_28822);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,null,null,null);\n\ncljs.pprint.write_out(cljs.core.ffirst(aseq_28818));\n\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d (0));\n\ncljs.pprint.write_out(cljs.core.fnext(cljs.core.first(aseq_28818)));\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__26989_28820);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__26988_28819);\n}}\n\n\nif(cljs.core.next(aseq_28818)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22, \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__28823 \x3d (length_count26982_28817 + (1));\nvar G__28824 \x3d cljs.core.next(aseq_28818);\nlength_count26982_28817 \x3d G__28823;\naseq_28818 \x3d G__28824;\ncontinue;\n} else {\n}\n} else {\n}\n} else {\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__26978_28814);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__26977_28813);\n}}\n\nreturn null;\n});\ncljs.pprint.pprint_simple_default \x3d (function cljs$pprint$pprint_simple_default(obj){\nreturn cljs.core._write(cljs.core._STAR_out_STAR_,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([obj], 0)));\n});\ncljs.pprint.pprint_set \x3d (function (){var format_in__21692__auto__ \x3d \x22~\x3c#{~;~@{~w~^ ~:_~}~;}~:\x3e\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28825__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28825 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28826__i \x3d 0, G__28826__a \x3d new Array(arguments.length -  0);\nwhile (G__28826__i \x3c G__28826__a.length) {G__28826__a[G__28826__i] \x3d arguments[G__28826__i + 0]; ++G__28826__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28826__a,0,null);\n} \nreturn G__28825__delegate.call(this,args__21694__auto__);};\nG__28825.cljs$lang$maxFixedArity \x3d 0;\nG__28825.cljs$lang$applyTo \x3d (function (arglist__28827){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28827);\nreturn G__28825__delegate(args__21694__auto__);\n});\nG__28825.cljs$core$IFn$_invoke$arity$variadic \x3d G__28825__delegate;\nreturn G__28825;\n})()\n;\n})();\ncljs.pprint.type_map \x3d new cljs.core.PersistentArrayMap(null, 2, [\x22core$future_call\x22,\x22Future\x22,\x22core$promise\x22,\x22Promise\x22], null);\n/**\n * Map ugly type names to something simpler\n */\ncljs.pprint.map_ref_type \x3d (function cljs$pprint$map_ref_type(name){\nvar or__5002__auto__ \x3d (function (){var temp__5804__auto__ \x3d cljs.core.re_find(/^[^$]+\\$[^$]+/,name);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar match \x3d temp__5804__auto__;\nreturn (cljs.pprint.type_map.cljs$core$IFn$_invoke$arity$1 ? cljs.pprint.type_map.cljs$core$IFn$_invoke$arity$1(match) : cljs.pprint.type_map.call(null, match));\n} else {\nreturn null;\n}\n})();\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn name;\n}\n});\ncljs.pprint.pprint_ideref \x3d (function cljs$pprint$pprint_ideref(o){\nvar prefix \x3d [\x22#\x3c\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.pprint.map_ref_type(cljs.core.type(o).name)),\x22@\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(goog.getUid(o)),\x22: \x22].join(\x27\x27);\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27029_28829 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27030_28830 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27031_28831 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27032_28832 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27031_28831);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27032_28832);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,prefix,null,\x22\x3e\x22);\n\ncljs.pprint.pprint_indent(new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),(- (((prefix).length) - (2))));\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\ncljs.pprint.write_out((((function (){var and__5000__auto__ \x3d (((!((o \x3d\x3d null))))?(((((o.cljs$lang$protocol_mask$partition1$ \x26 (1))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d o.cljs$core$IPending$))))?true:(((!o.cljs$lang$protocol_mask$partition1$))?cljs.core.native_satisfies_QMARK_(cljs.core.IPending,o):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IPending,o));\nif(and__5000__auto__){\nreturn (!(cljs.core._realized_QMARK_(o)));\n} else {\nreturn and__5000__auto__;\n}\n})())?new cljs.core.Keyword(null,\x22not-delivered\x22,\x22not-delivered\x22,1599158697):cljs.core.deref(o)));\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27030_28830);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27029_28829);\n}}\n\nreturn null;\n});\ncljs.pprint.pprint_pqueue \x3d (function (){var format_in__21692__auto__ \x3d \x22~\x3c\x3c-(~;~@{~w~^ ~_~}~;)-\x3c~:\x3e\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28834__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28834 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28835__i \x3d 0, G__28835__a \x3d new Array(arguments.length -  0);\nwhile (G__28835__i \x3c G__28835__a.length) {G__28835__a[G__28835__i] \x3d arguments[G__28835__i + 0]; ++G__28835__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28835__a,0,null);\n} \nreturn G__28834__delegate.call(this,args__21694__auto__);};\nG__28834.cljs$lang$maxFixedArity \x3d 0;\nG__28834.cljs$lang$applyTo \x3d (function (arglist__28836){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28836);\nreturn G__28834__delegate(args__21694__auto__);\n});\nG__28834.cljs$core$IFn$_invoke$arity$variadic \x3d G__28834__delegate;\nreturn G__28834;\n})()\n;\n})();\ncljs.pprint.type_dispatcher \x3d (function cljs$pprint$type_dispatcher(obj){\nif((obj instanceof cljs.core.PersistentQueue)){\nreturn new cljs.core.Keyword(null,\x22queue\x22,\x22queue\x22,1455835879);\n} else {\nif((((!((obj \x3d\x3d null))))?(((((obj.cljs$lang$protocol_mask$partition0$ \x26 (32768))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d obj.cljs$core$IDeref$))))?true:(((!obj.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IDeref,obj):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IDeref,obj))){\nreturn new cljs.core.Keyword(null,\x22deref\x22,\x22deref\x22,-145586795);\n} else {\nif((obj instanceof cljs.core.Symbol)){\nreturn new cljs.core.Keyword(null,\x22symbol\x22,\x22symbol\x22,-1038572696);\n} else {\nif(cljs.core.seq_QMARK_(obj)){\nreturn new cljs.core.Keyword(null,\x22list\x22,\x22list\x22,765357683);\n} else {\nif(cljs.core.map_QMARK_(obj)){\nreturn new cljs.core.Keyword(null,\x22map\x22,\x22map\x22,1371690461);\n} else {\nif(cljs.core.vector_QMARK_(obj)){\nreturn new cljs.core.Keyword(null,\x22vector\x22,\x22vector\x22,1902966158);\n} else {\nif(cljs.core.set_QMARK_(obj)){\nreturn new cljs.core.Keyword(null,\x22set\x22,\x22set\x22,304602554);\n} else {\nif((obj \x3d\x3d null)){\nreturn null;\n} else {\nreturn new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328);\n\n}\n}\n}\n}\n}\n}\n}\n}\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint.simple_dispatch !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * The pretty print dispatch function for simple data structure format.\n */\ncljs.pprint.simple_dispatch \x3d (function (){var method_table__5599__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar prefer_table__5600__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar method_cache__5601__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar cached_hierarchy__5602__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar hierarchy__5603__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22hierarchy\x22,\x22hierarchy\x22,-1053470341),(function (){var fexpr__27099 \x3d cljs.core.get_global_hierarchy;\nreturn (fexpr__27099.cljs$core$IFn$_invoke$arity$0 ? fexpr__27099.cljs$core$IFn$_invoke$arity$0() : fexpr__27099.call(null, ));\n})());\nreturn (new cljs.core.MultiFn(cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(\x22cljs.pprint\x22,\x22simple-dispatch\x22),cljs.pprint.type_dispatcher,new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),hierarchy__5603__auto__,method_table__5599__auto__,prefer_table__5600__auto__,method_cache__5601__auto__,cached_hierarchy__5602__auto__));\n})();\n}\ncljs.pprint.use_method(cljs.pprint.simple_dispatch,new cljs.core.Keyword(null,\x22list\x22,\x22list\x22,765357683),cljs.pprint.pprint_list);\ncljs.pprint.use_method(cljs.pprint.simple_dispatch,new cljs.core.Keyword(null,\x22vector\x22,\x22vector\x22,1902966158),cljs.pprint.pprint_vector);\ncljs.pprint.use_method(cljs.pprint.simple_dispatch,new cljs.core.Keyword(null,\x22map\x22,\x22map\x22,1371690461),cljs.pprint.pprint_map);\ncljs.pprint.use_method(cljs.pprint.simple_dispatch,new cljs.core.Keyword(null,\x22set\x22,\x22set\x22,304602554),cljs.pprint.pprint_set);\ncljs.pprint.use_method(cljs.pprint.simple_dispatch,null,(function (){\nreturn cljs.core._write(cljs.core._STAR_out_STAR_,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([null], 0)));\n}));\ncljs.pprint.use_method(cljs.pprint.simple_dispatch,new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),cljs.pprint.pprint_simple_default);\ncljs.pprint.set_pprint_dispatch(cljs.pprint.simple_dispatch);\n/**\n * Figure out which kind of brackets to use\n */\ncljs.pprint.brackets \x3d (function cljs$pprint$brackets(form){\nif(cljs.core.vector_QMARK_(form)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22[\x22,\x22]\x22], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [\x22(\x22,\x22)\x22], null);\n}\n});\n/**\n * Pretty print a single reference (import, use, etc.) from a namespace decl\n */\ncljs.pprint.pprint_ns_reference \x3d (function cljs$pprint$pprint_ns_reference(reference){\nif(cljs.core.sequential_QMARK_(reference)){\nvar vec__27137 \x3d cljs.pprint.brackets(reference);\nvar start \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27137,(0),null);\nvar end \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27137,(1),null);\nvar vec__27140 \x3d reference;\nvar seq__27141 \x3d cljs.core.seq(vec__27140);\nvar first__27142 \x3d cljs.core.first(seq__27141);\nvar seq__27141__$1 \x3d cljs.core.next(seq__27141);\nvar keyw \x3d first__27142;\nvar args \x3d seq__27141__$1;\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27147_28841 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27148_28842 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27149_28843 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27150_28844 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27149_28843);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27150_28844);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,start,null,end);\n\n(function (){var format_in__21692__auto__ \x3d \x22~w~:i\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28846__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28846 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28847__i \x3d 0, G__28847__a \x3d new Array(arguments.length -  0);\nwhile (G__28847__i \x3c G__28847__a.length) {G__28847__a[G__28847__i] \x3d arguments[G__28847__i + 0]; ++G__28847__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28847__a,0,null);\n} \nreturn G__28846__delegate.call(this,args__21694__auto__);};\nG__28846.cljs$lang$maxFixedArity \x3d 0;\nG__28846.cljs$lang$applyTo \x3d (function (arglist__28848){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28848);\nreturn G__28846__delegate(args__21694__auto__);\n});\nG__28846.cljs$core$IFn$_invoke$arity$variadic \x3d G__28846__delegate;\nreturn G__28846;\n})()\n;\n})()(keyw);\n\nvar args_28849__$1 \x3d args;\nwhile(true){\nif(cljs.core.seq(args_28849__$1)){\n(function (){var format_in__21692__auto__ \x3d \x22 \x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn ((function (args_28849__$1,format_in__21692__auto__,cf__21693__auto__,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args){\nreturn (function() { \nvar G__28850__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28850 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28851__i \x3d 0, G__28851__a \x3d new Array(arguments.length -  0);\nwhile (G__28851__i \x3c G__28851__a.length) {G__28851__a[G__28851__i] \x3d arguments[G__28851__i + 0]; ++G__28851__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28851__a,0,null);\n} \nreturn G__28850__delegate.call(this,args__21694__auto__);};\nG__28850.cljs$lang$maxFixedArity \x3d 0;\nG__28850.cljs$lang$applyTo \x3d (function (arglist__28852){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28852);\nreturn G__28850__delegate(args__21694__auto__);\n});\nG__28850.cljs$core$IFn$_invoke$arity$variadic \x3d G__28850__delegate;\nreturn G__28850;\n})()\n;\n;})(args_28849__$1,format_in__21692__auto__,cf__21693__auto__,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args))\n})()();\n\nvar arg_28853 \x3d cljs.core.first(args_28849__$1);\nif(cljs.core.sequential_QMARK_(arg_28853)){\nvar vec__27167_28854 \x3d cljs.pprint.brackets(arg_28853);\nvar start_28855__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27167_28854,(0),null);\nvar end_28856__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27167_28854,(1),null);\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27172_28858 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27173_28859 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27174_28860 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27175_28861 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27174_28860);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27175_28861);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,start_28855__$1,null,end_28856__$1);\n\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(arg_28853),(3))) \x26\x26 ((cljs.core.second(arg_28853) instanceof cljs.core.Keyword)))){\nvar vec__27181_28862 \x3d arg_28853;\nvar ns_28863 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27181_28862,(0),null);\nvar kw_28864 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27181_28862,(1),null);\nvar lis_28865 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27181_28862,(2),null);\n(function (){var format_in__21692__auto__ \x3d \x22~w ~w \x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn ((function (args_28849__$1,format_in__21692__auto__,cf__21693__auto__,vec__27181_28862,ns_28863,kw_28864,lis_28865,_STAR_current_level_STAR__orig_val__27172_28858,_STAR_current_length_STAR__orig_val__27173_28859,_STAR_current_level_STAR__temp_val__27174_28860,_STAR_current_length_STAR__temp_val__27175_28861,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args){\nreturn (function() { \nvar G__28874__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28874 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28875__i \x3d 0, G__28875__a \x3d new Array(arguments.length -  0);\nwhile (G__28875__i \x3c G__28875__a.length) {G__28875__a[G__28875__i] \x3d arguments[G__28875__i + 0]; ++G__28875__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28875__a,0,null);\n} \nreturn G__28874__delegate.call(this,args__21694__auto__);};\nG__28874.cljs$lang$maxFixedArity \x3d 0;\nG__28874.cljs$lang$applyTo \x3d (function (arglist__28876){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28876);\nreturn G__28874__delegate(args__21694__auto__);\n});\nG__28874.cljs$core$IFn$_invoke$arity$variadic \x3d G__28874__delegate;\nreturn G__28874;\n})()\n;\n;})(args_28849__$1,format_in__21692__auto__,cf__21693__auto__,vec__27181_28862,ns_28863,kw_28864,lis_28865,_STAR_current_level_STAR__orig_val__27172_28858,_STAR_current_length_STAR__orig_val__27173_28859,_STAR_current_level_STAR__temp_val__27174_28860,_STAR_current_length_STAR__temp_val__27175_28861,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args))\n})()(ns_28863,kw_28864);\n\nif(cljs.core.sequential_QMARK_(lis_28865)){\n(function (){var format_in__21692__auto__ \x3d ((cljs.core.vector_QMARK_(lis_28865))?\x22~\x3c[~;~@{~w~^ ~:_~}~;]~:\x3e\x22:\x22~\x3c(~;~@{~w~^ ~:_~}~;)~:\x3e\x22);\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn ((function (args_28849__$1,format_in__21692__auto__,cf__21693__auto__,vec__27181_28862,ns_28863,kw_28864,lis_28865,_STAR_current_level_STAR__orig_val__27172_28858,_STAR_current_length_STAR__orig_val__27173_28859,_STAR_current_level_STAR__temp_val__27174_28860,_STAR_current_length_STAR__temp_val__27175_28861,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args){\nreturn (function() { \nvar G__28877__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28877 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28878__i \x3d 0, G__28878__a \x3d new Array(arguments.length -  0);\nwhile (G__28878__i \x3c G__28878__a.length) {G__28878__a[G__28878__i] \x3d arguments[G__28878__i + 0]; ++G__28878__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28878__a,0,null);\n} \nreturn G__28877__delegate.call(this,args__21694__auto__);};\nG__28877.cljs$lang$maxFixedArity \x3d 0;\nG__28877.cljs$lang$applyTo \x3d (function (arglist__28879){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28879);\nreturn G__28877__delegate(args__21694__auto__);\n});\nG__28877.cljs$core$IFn$_invoke$arity$variadic \x3d G__28877__delegate;\nreturn G__28877;\n})()\n;\n;})(args_28849__$1,format_in__21692__auto__,cf__21693__auto__,vec__27181_28862,ns_28863,kw_28864,lis_28865,_STAR_current_level_STAR__orig_val__27172_28858,_STAR_current_length_STAR__orig_val__27173_28859,_STAR_current_level_STAR__temp_val__27174_28860,_STAR_current_length_STAR__temp_val__27175_28861,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args))\n})()(lis_28865);\n} else {\ncljs.pprint.write_out(lis_28865);\n}\n} else {\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2((function (){var format_in__21692__auto__ \x3d \x22~w ~:i~@{~w~^ ~:_~}\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn ((function (args_28849__$1,format_in__21692__auto__,cf__21693__auto__,_STAR_current_level_STAR__orig_val__27172_28858,_STAR_current_length_STAR__orig_val__27173_28859,_STAR_current_level_STAR__temp_val__27174_28860,_STAR_current_length_STAR__temp_val__27175_28861,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args){\nreturn (function() { \nvar G__28880__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28880 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28881__i \x3d 0, G__28881__a \x3d new Array(arguments.length -  0);\nwhile (G__28881__i \x3c G__28881__a.length) {G__28881__a[G__28881__i] \x3d arguments[G__28881__i + 0]; ++G__28881__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28881__a,0,null);\n} \nreturn G__28880__delegate.call(this,args__21694__auto__);};\nG__28880.cljs$lang$maxFixedArity \x3d 0;\nG__28880.cljs$lang$applyTo \x3d (function (arglist__28882){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28882);\nreturn G__28880__delegate(args__21694__auto__);\n});\nG__28880.cljs$core$IFn$_invoke$arity$variadic \x3d G__28880__delegate;\nreturn G__28880;\n})()\n;\n;})(args_28849__$1,format_in__21692__auto__,cf__21693__auto__,_STAR_current_level_STAR__orig_val__27172_28858,_STAR_current_length_STAR__orig_val__27173_28859,_STAR_current_level_STAR__temp_val__27174_28860,_STAR_current_length_STAR__temp_val__27175_28861,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args))\n})(),arg_28853);\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27173_28859);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27172_28858);\n}}\n\n\nif(cljs.core.next(args_28849__$1)){\n(function (){var format_in__21692__auto__ \x3d \x22~_\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn ((function (args_28849__$1,format_in__21692__auto__,cf__21693__auto__,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args){\nreturn (function() { \nvar G__28883__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28883 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28885__i \x3d 0, G__28885__a \x3d new Array(arguments.length -  0);\nwhile (G__28885__i \x3c G__28885__a.length) {G__28885__a[G__28885__i] \x3d arguments[G__28885__i + 0]; ++G__28885__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28885__a,0,null);\n} \nreturn G__28883__delegate.call(this,args__21694__auto__);};\nG__28883.cljs$lang$maxFixedArity \x3d 0;\nG__28883.cljs$lang$applyTo \x3d (function (arglist__28886){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28886);\nreturn G__28883__delegate(args__21694__auto__);\n});\nG__28883.cljs$core$IFn$_invoke$arity$variadic \x3d G__28883__delegate;\nreturn G__28883;\n})()\n;\n;})(args_28849__$1,format_in__21692__auto__,cf__21693__auto__,vec__27167_28854,start_28855__$1,end_28856__$1,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args))\n})()();\n} else {\n}\n} else {\ncljs.pprint.write_out(arg_28853);\n\nif(cljs.core.next(args_28849__$1)){\n(function (){var format_in__21692__auto__ \x3d \x22~:_\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn ((function (args_28849__$1,format_in__21692__auto__,cf__21693__auto__,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args){\nreturn (function() { \nvar G__28887__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28887 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28888__i \x3d 0, G__28888__a \x3d new Array(arguments.length -  0);\nwhile (G__28888__i \x3c G__28888__a.length) {G__28888__a[G__28888__i] \x3d arguments[G__28888__i + 0]; ++G__28888__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28888__a,0,null);\n} \nreturn G__28887__delegate.call(this,args__21694__auto__);};\nG__28887.cljs$lang$maxFixedArity \x3d 0;\nG__28887.cljs$lang$applyTo \x3d (function (arglist__28889){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28889);\nreturn G__28887__delegate(args__21694__auto__);\n});\nG__28887.cljs$core$IFn$_invoke$arity$variadic \x3d G__28887__delegate;\nreturn G__28887;\n})()\n;\n;})(args_28849__$1,format_in__21692__auto__,cf__21693__auto__,arg_28853,_STAR_current_level_STAR__orig_val__27147_28841,_STAR_current_length_STAR__orig_val__27148_28842,_STAR_current_level_STAR__temp_val__27149_28843,_STAR_current_length_STAR__temp_val__27150_28844,vec__27137,start,end,vec__27140,seq__27141,first__27142,seq__27141__$1,keyw,args))\n})()();\n} else {\n}\n}\n\nvar G__28890 \x3d cljs.core.next(args_28849__$1);\nargs_28849__$1 \x3d G__28890;\ncontinue;\n} else {\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27148_28842);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27147_28841);\n}}\n\nreturn null;\n} else {\nreturn cljs.pprint.write_out(reference);\n}\n});\n/**\n * The pretty print dispatch chunk for the ns macro\n */\ncljs.pprint.pprint_ns \x3d (function cljs$pprint$pprint_ns(alis){\nif(cljs.core.next(alis)){\nvar vec__27212 \x3d alis;\nvar seq__27213 \x3d cljs.core.seq(vec__27212);\nvar first__27214 \x3d cljs.core.first(seq__27213);\nvar seq__27213__$1 \x3d cljs.core.next(seq__27213);\nvar ns_sym \x3d first__27214;\nvar first__27214__$1 \x3d cljs.core.first(seq__27213__$1);\nvar seq__27213__$2 \x3d cljs.core.next(seq__27213__$1);\nvar ns_name \x3d first__27214__$1;\nvar stuff \x3d seq__27213__$2;\nvar vec__27215 \x3d ((typeof cljs.core.first(stuff) \x3d\x3d\x3d \x27string\x27)?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(stuff),cljs.core.next(stuff)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,stuff], null));\nvar doc_str \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27215,(0),null);\nvar stuff__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27215,(1),null);\nvar vec__27218 \x3d ((cljs.core.map_QMARK_(cljs.core.first(stuff__$1)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(stuff__$1),cljs.core.next(stuff__$1)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,stuff__$1], null));\nvar attr_map \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27218,(0),null);\nvar references \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27218,(1),null);\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27229_28900 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27230_28901 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27231_28902 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27232_28903 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27231_28902);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27232_28903);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22(\x22,null,\x22)\x22);\n\n(function (){var format_in__21692__auto__ \x3d \x22~w ~1I~@_~w\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28904__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28904 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28905__i \x3d 0, G__28905__a \x3d new Array(arguments.length -  0);\nwhile (G__28905__i \x3c G__28905__a.length) {G__28905__a[G__28905__i] \x3d arguments[G__28905__i + 0]; ++G__28905__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28905__a,0,null);\n} \nreturn G__28904__delegate.call(this,args__21694__auto__);};\nG__28904.cljs$lang$maxFixedArity \x3d 0;\nG__28904.cljs$lang$applyTo \x3d (function (arglist__28906){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28906);\nreturn G__28904__delegate(args__21694__auto__);\n});\nG__28904.cljs$core$IFn$_invoke$arity$variadic \x3d G__28904__delegate;\nreturn G__28904;\n})()\n;\n})()(ns_sym,ns_name);\n\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d doc_str;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d attr_map;\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn cljs.core.seq(references);\n}\n}\n})())){\n(function (){var format_in__21692__auto__ \x3d \x22~@:_\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28907__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28907 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28908__i \x3d 0, G__28908__a \x3d new Array(arguments.length -  0);\nwhile (G__28908__i \x3c G__28908__a.length) {G__28908__a[G__28908__i] \x3d arguments[G__28908__i + 0]; ++G__28908__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28908__a,0,null);\n} \nreturn G__28907__delegate.call(this,args__21694__auto__);};\nG__28907.cljs$lang$maxFixedArity \x3d 0;\nG__28907.cljs$lang$applyTo \x3d (function (arglist__28909){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28909);\nreturn G__28907__delegate(args__21694__auto__);\n});\nG__28907.cljs$core$IFn$_invoke$arity$variadic \x3d G__28907__delegate;\nreturn G__28907;\n})()\n;\n})()();\n} else {\n}\n\nif(cljs.core.truth_(doc_str)){\ncljs.pprint.cl_format.cljs$core$IFn$_invoke$arity$variadic(true,\x22\\\x22~a\\\x22~:[~;~:@_~]\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([doc_str,(function (){var or__5002__auto__ \x3d attr_map;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.seq(references);\n}\n})()], 0));\n} else {\n}\n\nif(cljs.core.truth_(attr_map)){\n(function (){var format_in__21692__auto__ \x3d \x22~w~:[~;~:@_~]\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28910__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28910 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28911__i \x3d 0, G__28911__a \x3d new Array(arguments.length -  0);\nwhile (G__28911__i \x3c G__28911__a.length) {G__28911__a[G__28911__i] \x3d arguments[G__28911__i + 0]; ++G__28911__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28911__a,0,null);\n} \nreturn G__28910__delegate.call(this,args__21694__auto__);};\nG__28910.cljs$lang$maxFixedArity \x3d 0;\nG__28910.cljs$lang$applyTo \x3d (function (arglist__28912){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28912);\nreturn G__28910__delegate(args__21694__auto__);\n});\nG__28910.cljs$core$IFn$_invoke$arity$variadic \x3d G__28910__delegate;\nreturn G__28910;\n})()\n;\n})()(attr_map,cljs.core.seq(references));\n} else {\n}\n\nvar references_28913__$1 \x3d references;\nwhile(true){\ncljs.pprint.pprint_ns_reference(cljs.core.first(references_28913__$1));\n\nvar temp__5804__auto___28914 \x3d cljs.core.next(references_28913__$1);\nif(temp__5804__auto___28914){\nvar references_28915__$2 \x3d temp__5804__auto___28914;\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__28916 \x3d references_28915__$2;\nreferences_28913__$1 \x3d G__28916;\ncontinue;\n} else {\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27230_28901);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27229_28900);\n}}\n\nreturn null;\n} else {\nreturn cljs.pprint.write_out(alis);\n}\n});\ncljs.pprint.pprint_hold_first \x3d (function (){var format_in__21692__auto__ \x3d \x22~:\x3c~w~^ ~@_~w~^ ~_~@{~w~^ ~_~}~:\x3e\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28918__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28918 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28919__i \x3d 0, G__28919__a \x3d new Array(arguments.length -  0);\nwhile (G__28919__i \x3c G__28919__a.length) {G__28919__a[G__28919__i] \x3d arguments[G__28919__i + 0]; ++G__28919__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28919__a,0,null);\n} \nreturn G__28918__delegate.call(this,args__21694__auto__);};\nG__28918.cljs$lang$maxFixedArity \x3d 0;\nG__28918.cljs$lang$applyTo \x3d (function (arglist__28920){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28920);\nreturn G__28918__delegate(args__21694__auto__);\n});\nG__28918.cljs$core$IFn$_invoke$arity$variadic \x3d G__28918__delegate;\nreturn G__28918;\n})()\n;\n})();\ncljs.pprint.single_defn \x3d (function cljs$pprint$single_defn(alis,has_doc_str_QMARK_){\nif(cljs.core.seq(alis)){\nif(cljs.core.truth_(has_doc_str_QMARK_)){\n(function (){var format_in__21692__auto__ \x3d \x22 ~_\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28921__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28921 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28922__i \x3d 0, G__28922__a \x3d new Array(arguments.length -  0);\nwhile (G__28922__i \x3c G__28922__a.length) {G__28922__a[G__28922__i] \x3d arguments[G__28922__i + 0]; ++G__28922__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28922__a,0,null);\n} \nreturn G__28921__delegate.call(this,args__21694__auto__);};\nG__28921.cljs$lang$maxFixedArity \x3d 0;\nG__28921.cljs$lang$applyTo \x3d (function (arglist__28923){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28923);\nreturn G__28921__delegate(args__21694__auto__);\n});\nG__28921.cljs$core$IFn$_invoke$arity$variadic \x3d G__28921__delegate;\nreturn G__28921;\n})()\n;\n})()();\n} else {\n(function (){var format_in__21692__auto__ \x3d \x22 ~@_\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28924__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28924 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28925__i \x3d 0, G__28925__a \x3d new Array(arguments.length -  0);\nwhile (G__28925__i \x3c G__28925__a.length) {G__28925__a[G__28925__i] \x3d arguments[G__28925__i + 0]; ++G__28925__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28925__a,0,null);\n} \nreturn G__28924__delegate.call(this,args__21694__auto__);};\nG__28924.cljs$lang$maxFixedArity \x3d 0;\nG__28924.cljs$lang$applyTo \x3d (function (arglist__28927){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28927);\nreturn G__28924__delegate(args__21694__auto__);\n});\nG__28924.cljs$core$IFn$_invoke$arity$variadic \x3d G__28924__delegate;\nreturn G__28924;\n})()\n;\n})()();\n}\n\nreturn (function (){var format_in__21692__auto__ \x3d \x22~{~w~^ ~_~}\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28929__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28929 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28932__i \x3d 0, G__28932__a \x3d new Array(arguments.length -  0);\nwhile (G__28932__i \x3c G__28932__a.length) {G__28932__a[G__28932__i] \x3d arguments[G__28932__i + 0]; ++G__28932__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28932__a,0,null);\n} \nreturn G__28929__delegate.call(this,args__21694__auto__);};\nG__28929.cljs$lang$maxFixedArity \x3d 0;\nG__28929.cljs$lang$applyTo \x3d (function (arglist__28933){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28933);\nreturn G__28929__delegate(args__21694__auto__);\n});\nG__28929.cljs$core$IFn$_invoke$arity$variadic \x3d G__28929__delegate;\nreturn G__28929;\n})()\n;\n})()(alis);\n} else {\nreturn null;\n}\n});\ncljs.pprint.multi_defn \x3d (function cljs$pprint$multi_defn(alis,has_doc_str_QMARK_){\nif(cljs.core.seq(alis)){\nreturn (function (){var format_in__21692__auto__ \x3d \x22 ~_~{~w~^ ~_~}\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28934__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28934 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28935__i \x3d 0, G__28935__a \x3d new Array(arguments.length -  0);\nwhile (G__28935__i \x3c G__28935__a.length) {G__28935__a[G__28935__i] \x3d arguments[G__28935__i + 0]; ++G__28935__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28935__a,0,null);\n} \nreturn G__28934__delegate.call(this,args__21694__auto__);};\nG__28934.cljs$lang$maxFixedArity \x3d 0;\nG__28934.cljs$lang$applyTo \x3d (function (arglist__28936){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28936);\nreturn G__28934__delegate(args__21694__auto__);\n});\nG__28934.cljs$core$IFn$_invoke$arity$variadic \x3d G__28934__delegate;\nreturn G__28934;\n})()\n;\n})()(alis);\n} else {\nreturn null;\n}\n});\ncljs.pprint.pprint_defn \x3d (function cljs$pprint$pprint_defn(alis){\nif(cljs.core.next(alis)){\nvar vec__27292 \x3d alis;\nvar seq__27293 \x3d cljs.core.seq(vec__27292);\nvar first__27294 \x3d cljs.core.first(seq__27293);\nvar seq__27293__$1 \x3d cljs.core.next(seq__27293);\nvar defn_sym \x3d first__27294;\nvar first__27294__$1 \x3d cljs.core.first(seq__27293__$1);\nvar seq__27293__$2 \x3d cljs.core.next(seq__27293__$1);\nvar defn_name \x3d first__27294__$1;\nvar stuff \x3d seq__27293__$2;\nvar vec__27296 \x3d ((typeof cljs.core.first(stuff) \x3d\x3d\x3d \x27string\x27)?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(stuff),cljs.core.next(stuff)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,stuff], null));\nvar doc_str \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27296,(0),null);\nvar stuff__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27296,(1),null);\nvar vec__27299 \x3d ((cljs.core.map_QMARK_(cljs.core.first(stuff__$1)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(stuff__$1),cljs.core.next(stuff__$1)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,stuff__$1], null));\nvar attr_map \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27299,(0),null);\nvar stuff__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27299,(1),null);\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27309_28937 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27310_28938 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27311_28939 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27312_28940 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27311_28939);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27312_28940);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22(\x22,null,\x22)\x22);\n\n(function (){var format_in__21692__auto__ \x3d \x22~w ~1I~@_~w\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28941__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28941 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28942__i \x3d 0, G__28942__a \x3d new Array(arguments.length -  0);\nwhile (G__28942__i \x3c G__28942__a.length) {G__28942__a[G__28942__i] \x3d arguments[G__28942__i + 0]; ++G__28942__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28942__a,0,null);\n} \nreturn G__28941__delegate.call(this,args__21694__auto__);};\nG__28941.cljs$lang$maxFixedArity \x3d 0;\nG__28941.cljs$lang$applyTo \x3d (function (arglist__28943){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28943);\nreturn G__28941__delegate(args__21694__auto__);\n});\nG__28941.cljs$core$IFn$_invoke$arity$variadic \x3d G__28941__delegate;\nreturn G__28941;\n})()\n;\n})()(defn_sym,defn_name);\n\nif(cljs.core.truth_(doc_str)){\n(function (){var format_in__21692__auto__ \x3d \x22 ~_~w\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28944__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28944 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28945__i \x3d 0, G__28945__a \x3d new Array(arguments.length -  0);\nwhile (G__28945__i \x3c G__28945__a.length) {G__28945__a[G__28945__i] \x3d arguments[G__28945__i + 0]; ++G__28945__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28945__a,0,null);\n} \nreturn G__28944__delegate.call(this,args__21694__auto__);};\nG__28944.cljs$lang$maxFixedArity \x3d 0;\nG__28944.cljs$lang$applyTo \x3d (function (arglist__28946){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28946);\nreturn G__28944__delegate(args__21694__auto__);\n});\nG__28944.cljs$core$IFn$_invoke$arity$variadic \x3d G__28944__delegate;\nreturn G__28944;\n})()\n;\n})()(doc_str);\n} else {\n}\n\nif(cljs.core.truth_(attr_map)){\n(function (){var format_in__21692__auto__ \x3d \x22 ~_~w\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28947__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28947 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28948__i \x3d 0, G__28948__a \x3d new Array(arguments.length -  0);\nwhile (G__28948__i \x3c G__28948__a.length) {G__28948__a[G__28948__i] \x3d arguments[G__28948__i + 0]; ++G__28948__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28948__a,0,null);\n} \nreturn G__28947__delegate.call(this,args__21694__auto__);};\nG__28947.cljs$lang$maxFixedArity \x3d 0;\nG__28947.cljs$lang$applyTo \x3d (function (arglist__28949){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28949);\nreturn G__28947__delegate(args__21694__auto__);\n});\nG__28947.cljs$core$IFn$_invoke$arity$variadic \x3d G__28947__delegate;\nreturn G__28947;\n})()\n;\n})()(attr_map);\n} else {\n}\n\nif(cljs.core.vector_QMARK_(cljs.core.first(stuff__$2))){\ncljs.pprint.single_defn(stuff__$2,(function (){var or__5002__auto__ \x3d doc_str;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn attr_map;\n}\n})());\n} else {\ncljs.pprint.multi_defn(stuff__$2,(function (){var or__5002__auto__ \x3d doc_str;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn attr_map;\n}\n})());\n\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27310_28938);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27309_28937);\n}}\n\nreturn null;\n} else {\nreturn cljs.pprint.pprint_simple_code_list(alis);\n}\n});\ncljs.pprint.pprint_binding_form \x3d (function cljs$pprint$pprint_binding_form(binding_vec){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27327_28950 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27328_28951 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27329_28952 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27330_28953 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27329_28952);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27330_28953);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22[\x22,null,\x22]\x22);\n\nvar length_count27336_28954 \x3d (0);\nvar binding_28955 \x3d binding_vec;\nwhile(true){\nif(((cljs.core.not(cljs.core._STAR_print_length_STAR_)) || ((length_count27336_28954 \x3c cljs.core._STAR_print_length_STAR_)))){\nif(cljs.core.seq(binding_28955)){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27339_28956 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27340_28957 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27341_28958 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27342_28959 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27341_28958);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27342_28959);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,null,null,null);\n\n\ncljs.pprint.write_out(cljs.core.first(binding_28955));\n\nif(cljs.core.next(binding_28955)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22miser\x22,\x22miser\x22,-556060186));\n\ncljs.pprint.write_out(cljs.core.second(binding_28955));\n} else {\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27340_28957);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27339_28956);\n}}\n\n\nif(cljs.core.next(cljs.core.rest(binding_28955))){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__28963 \x3d (length_count27336_28954 + (1));\nvar G__28964 \x3d cljs.core.next(cljs.core.rest(binding_28955));\nlength_count27336_28954 \x3d G__28963;\nbinding_28955 \x3d G__28964;\ncontinue;\n} else {\n}\n} else {\n}\n} else {\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27328_28951);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27327_28950);\n}}\n\nreturn null;\n});\ncljs.pprint.pprint_let \x3d (function cljs$pprint$pprint_let(alis){\nvar base_sym \x3d cljs.core.first(alis);\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27365_28975 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27366_28976 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27367_28977 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27368_28978 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27367_28977);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27368_28978);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22(\x22,null,\x22)\x22);\n\nif(((cljs.core.next(alis)) \x26\x26 (cljs.core.vector_QMARK_(cljs.core.second(alis))))){\n(function (){var format_in__21692__auto__ \x3d \x22~w ~1I~@_\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28981__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28981 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28982__i \x3d 0, G__28982__a \x3d new Array(arguments.length -  0);\nwhile (G__28982__i \x3c G__28982__a.length) {G__28982__a[G__28982__i] \x3d arguments[G__28982__i + 0]; ++G__28982__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28982__a,0,null);\n} \nreturn G__28981__delegate.call(this,args__21694__auto__);};\nG__28981.cljs$lang$maxFixedArity \x3d 0;\nG__28981.cljs$lang$applyTo \x3d (function (arglist__28983){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28983);\nreturn G__28981__delegate(args__21694__auto__);\n});\nG__28981.cljs$core$IFn$_invoke$arity$variadic \x3d G__28981__delegate;\nreturn G__28981;\n})()\n;\n})()(base_sym);\n\ncljs.pprint.pprint_binding_form(cljs.core.second(alis));\n\n(function (){var format_in__21692__auto__ \x3d \x22 ~_~{~w~^ ~_~}\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28984__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28984 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28985__i \x3d 0, G__28985__a \x3d new Array(arguments.length -  0);\nwhile (G__28985__i \x3c G__28985__a.length) {G__28985__a[G__28985__i] \x3d arguments[G__28985__i + 0]; ++G__28985__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28985__a,0,null);\n} \nreturn G__28984__delegate.call(this,args__21694__auto__);};\nG__28984.cljs$lang$maxFixedArity \x3d 0;\nG__28984.cljs$lang$applyTo \x3d (function (arglist__28986){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28986);\nreturn G__28984__delegate(args__21694__auto__);\n});\nG__28984.cljs$core$IFn$_invoke$arity$variadic \x3d G__28984__delegate;\nreturn G__28984;\n})()\n;\n})()(cljs.core.next(cljs.core.rest(alis)));\n} else {\ncljs.pprint.pprint_simple_code_list(alis);\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27366_28976);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27365_28975);\n}}\n\nreturn null;\n});\ncljs.pprint.pprint_if \x3d (function (){var format_in__21692__auto__ \x3d \x22~:\x3c~1I~w~^ ~@_~w~@{ ~_~w~}~:\x3e\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__28987__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__28987 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__28988__i \x3d 0, G__28988__a \x3d new Array(arguments.length -  0);\nwhile (G__28988__i \x3c G__28988__a.length) {G__28988__a[G__28988__i] \x3d arguments[G__28988__i + 0]; ++G__28988__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__28988__a,0,null);\n} \nreturn G__28987__delegate.call(this,args__21694__auto__);};\nG__28987.cljs$lang$maxFixedArity \x3d 0;\nG__28987.cljs$lang$applyTo \x3d (function (arglist__28989){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__28989);\nreturn G__28987__delegate(args__21694__auto__);\n});\nG__28987.cljs$core$IFn$_invoke$arity$variadic \x3d G__28987__delegate;\nreturn G__28987;\n})()\n;\n})();\ncljs.pprint.pprint_cond \x3d (function cljs$pprint$pprint_cond(alis){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27389_28991 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27390_28992 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27391_28993 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27392_28994 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27391_28993);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27392_28994);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22(\x22,null,\x22)\x22);\n\ncljs.pprint.pprint_indent(new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),(1));\n\ncljs.pprint.write_out(cljs.core.first(alis));\n\nif(cljs.core.next(alis)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar length_count27398_28996 \x3d (0);\nvar alis_28997__$1 \x3d cljs.core.next(alis);\nwhile(true){\nif(((cljs.core.not(cljs.core._STAR_print_length_STAR_)) || ((length_count27398_28996 \x3c cljs.core._STAR_print_length_STAR_)))){\nif(alis_28997__$1){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27399_28998 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27401_28999 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27402_29000 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27403_29001 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27402_29000);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27403_29001);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,null,null,null);\n\n\ncljs.pprint.write_out(cljs.core.first(alis_28997__$1));\n\nif(cljs.core.next(alis_28997__$1)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22miser\x22,\x22miser\x22,-556060186));\n\ncljs.pprint.write_out(cljs.core.second(alis_28997__$1));\n} else {\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27401_28999);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27399_28998);\n}}\n\n\nif(cljs.core.next(cljs.core.rest(alis_28997__$1))){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__29006 \x3d (length_count27398_28996 + (1));\nvar G__29007 \x3d cljs.core.next(cljs.core.rest(alis_28997__$1));\nlength_count27398_28996 \x3d G__29006;\nalis_28997__$1 \x3d G__29007;\ncontinue;\n} else {\n}\n} else {\n}\n} else {\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n}\nbreak;\n}\n} else {\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27390_28992);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27389_28991);\n}}\n\nreturn null;\n});\ncljs.pprint.pprint_condp \x3d (function cljs$pprint$pprint_condp(alis){\nif((cljs.core.count(alis) \x3e (3))){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27421_29010 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27422_29011 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27423_29012 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27424_29013 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27423_29012);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27424_29013);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22(\x22,null,\x22)\x22);\n\ncljs.pprint.pprint_indent(new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),(1));\n\ncljs.core.apply.cljs$core$IFn$_invoke$arity$2((function (){var format_in__21692__auto__ \x3d \x22~w ~@_~w ~@_~w ~_\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__29014__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__29014 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__29016__i \x3d 0, G__29016__a \x3d new Array(arguments.length -  0);\nwhile (G__29016__i \x3c G__29016__a.length) {G__29016__a[G__29016__i] \x3d arguments[G__29016__i + 0]; ++G__29016__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__29016__a,0,null);\n} \nreturn G__29014__delegate.call(this,args__21694__auto__);};\nG__29014.cljs$lang$maxFixedArity \x3d 0;\nG__29014.cljs$lang$applyTo \x3d (function (arglist__29017){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__29017);\nreturn G__29014__delegate(args__21694__auto__);\n});\nG__29014.cljs$core$IFn$_invoke$arity$variadic \x3d G__29014__delegate;\nreturn G__29014;\n})()\n;\n})(),alis);\n\nvar length_count27432_29018 \x3d (0);\nvar alis_29019__$1 \x3d cljs.core.seq(cljs.core.drop.cljs$core$IFn$_invoke$arity$2((3),alis));\nwhile(true){\nif(((cljs.core.not(cljs.core._STAR_print_length_STAR_)) || ((length_count27432_29018 \x3c cljs.core._STAR_print_length_STAR_)))){\nif(alis_29019__$1){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27434_29020 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27435_29021 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27436_29022 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27437_29023 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27436_29022);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27437_29023);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,null,null,null);\n\n\ncljs.pprint.write_out(cljs.core.first(alis_29019__$1));\n\nif(cljs.core.next(alis_29019__$1)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22miser\x22,\x22miser\x22,-556060186));\n\ncljs.pprint.write_out(cljs.core.second(alis_29019__$1));\n} else {\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27435_29021);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27434_29020);\n}}\n\n\nif(cljs.core.next(cljs.core.rest(alis_29019__$1))){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__29024 \x3d (length_count27432_29018 + (1));\nvar G__29025 \x3d cljs.core.next(cljs.core.rest(alis_29019__$1));\nlength_count27432_29018 \x3d G__29024;\nalis_29019__$1 \x3d G__29025;\ncontinue;\n} else {\n}\n} else {\n}\n} else {\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27422_29011);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27421_29010);\n}}\n\nreturn null;\n} else {\nreturn cljs.pprint.pprint_simple_code_list(alis);\n}\n});\ncljs.pprint._STAR_symbol_map_STAR_ \x3d cljs.core.PersistentArrayMap.EMPTY;\ncljs.pprint.pprint_anon_func \x3d (function cljs$pprint$pprint_anon_func(alis){\nvar args \x3d cljs.core.second(alis);\nvar nlis \x3d cljs.core.first(cljs.core.rest(cljs.core.rest(alis)));\nif(cljs.core.vector_QMARK_(args)){\nvar _STAR_symbol_map_STAR__orig_val__27450 \x3d cljs.pprint._STAR_symbol_map_STAR_;\nvar _STAR_symbol_map_STAR__temp_val__27451 \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((1),cljs.core.count(args)))?cljs.core.PersistentArrayMap.createAsIfByAssoc([cljs.core.first(args),\x22%\x22]):cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (p1__27447_SHARP_,p2__27448_SHARP_){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[p1__27447_SHARP_,[\x22%\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(p2__27448_SHARP_)].join(\x27\x27)],null));\n}),args,cljs.core.range.cljs$core$IFn$_invoke$arity$2((1),(cljs.core.count(args) + (1))))));\n(cljs.pprint._STAR_symbol_map_STAR_ \x3d _STAR_symbol_map_STAR__temp_val__27451);\n\ntry{return (function (){var format_in__21692__auto__ \x3d \x22~\x3c#(~;~@{~w~^ ~_~}~;)~:\x3e\x22;\nvar cf__21693__auto__ \x3d ((typeof format_in__21692__auto__ \x3d\x3d\x3d \x27string\x27)?cljs.pprint.cached_compile(format_in__21692__auto__):format_in__21692__auto__);\nreturn (function() { \nvar G__29026__delegate \x3d function (args__21694__auto__){\nvar navigator__21695__auto__ \x3d cljs.pprint.init_navigator(args__21694__auto__);\nreturn cljs.pprint.execute_format.cljs$core$IFn$_invoke$arity$2(cf__21693__auto__,navigator__21695__auto__);\n};\nvar G__29026 \x3d function (var_args){\nvar args__21694__auto__ \x3d null;\nif (arguments.length \x3e 0) {\nvar G__29027__i \x3d 0, G__29027__a \x3d new Array(arguments.length -  0);\nwhile (G__29027__i \x3c G__29027__a.length) {G__29027__a[G__29027__i] \x3d arguments[G__29027__i + 0]; ++G__29027__i;}\n  args__21694__auto__ \x3d new cljs.core.IndexedSeq(G__29027__a,0,null);\n} \nreturn G__29026__delegate.call(this,args__21694__auto__);};\nG__29026.cljs$lang$maxFixedArity \x3d 0;\nG__29026.cljs$lang$applyTo \x3d (function (arglist__29028){\nvar args__21694__auto__ \x3d cljs.core.seq(arglist__29028);\nreturn G__29026__delegate(args__21694__auto__);\n});\nG__29026.cljs$core$IFn$_invoke$arity$variadic \x3d G__29026__delegate;\nreturn G__29026;\n})()\n;\n})()(nlis);\n}finally {(cljs.pprint._STAR_symbol_map_STAR_ \x3d _STAR_symbol_map_STAR__orig_val__27450);\n}} else {\nreturn cljs.pprint.pprint_simple_code_list(alis);\n}\n});\ncljs.pprint.pprint_simple_code_list \x3d (function cljs$pprint$pprint_simple_code_list(alis){\nif(cljs.core.truth_(cljs.pprint.level_exceeded())){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22#\x22);\n} else {\nvar _STAR_current_level_STAR__orig_val__27457_29029 \x3d cljs.pprint._STAR_current_level_STAR_;\nvar _STAR_current_length_STAR__orig_val__27459_29030 \x3d cljs.pprint._STAR_current_length_STAR_;\nvar _STAR_current_level_STAR__temp_val__27460_29031 \x3d (cljs.pprint._STAR_current_level_STAR_ + (1));\nvar _STAR_current_length_STAR__temp_val__27461_29032 \x3d (0);\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__temp_val__27460_29031);\n\n(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__temp_val__27461_29032);\n\ntry{cljs.pprint.start_block(cljs.core._STAR_out_STAR_,\x22(\x22,null,\x22)\x22);\n\ncljs.pprint.pprint_indent(new cljs.core.Keyword(null,\x22block\x22,\x22block\x22,664686210),(1));\n\nvar length_count27463_29033 \x3d (0);\nvar alis_29034__$1 \x3d cljs.core.seq(alis);\nwhile(true){\nif(((cljs.core.not(cljs.core._STAR_print_length_STAR_)) || ((length_count27463_29033 \x3c cljs.core._STAR_print_length_STAR_)))){\nif(alis_29034__$1){\ncljs.pprint.write_out(cljs.core.first(alis_29034__$1));\n\nif(cljs.core.next(alis_29034__$1)){\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22 \x22);\n\ncljs.pprint.pprint_newline(new cljs.core.Keyword(null,\x22linear\x22,\x22linear\x22,872268697));\n\nvar G__29039 \x3d (length_count27463_29033 + (1));\nvar G__29040 \x3d cljs.core.next(alis_29034__$1);\nlength_count27463_29033 \x3d G__29039;\nalis_29034__$1 \x3d G__29040;\ncontinue;\n} else {\n}\n} else {\n}\n} else {\ncljs.core._write(cljs.core._STAR_out_STAR_,\x22...\x22);\n}\nbreak;\n}\n\ncljs.pprint.end_block(cljs.core._STAR_out_STAR_);\n}finally {(cljs.pprint._STAR_current_length_STAR_ \x3d _STAR_current_length_STAR__orig_val__27459_29030);\n\n(cljs.pprint._STAR_current_level_STAR_ \x3d _STAR_current_level_STAR__orig_val__27457_29029);\n}}\n\nreturn null;\n});\ncljs.pprint.two_forms \x3d (function cljs$pprint$two_forms(amap){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(cljs.core.identity,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var iter__5480__auto__ \x3d (function cljs$pprint$two_forms_$_iter__27468(s__27469){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__27469__$1 \x3d s__27469;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__27469__$1);\nif(temp__5804__auto__){\nvar s__27469__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__27469__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__27469__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__27471 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__27470 \x3d (0);\nwhile(true){\nif((i__27470 \x3c size__5479__auto__)){\nvar x \x3d cljs.core._nth(c__5478__auto__,i__27470);\ncljs.core.chunk_append(b__27471,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [x,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.name(cljs.core.first(x))),cljs.core.second(x)], null)], null));\n\nvar G__29041 \x3d (i__27470 + (1));\ni__27470 \x3d G__29041;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__27471),cljs$pprint$two_forms_$_iter__27468(cljs.core.chunk_rest(s__27469__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__27471),null);\n}\n} else {\nvar x \x3d cljs.core.first(s__27469__$2);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [x,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.name(cljs.core.first(x))),cljs.core.second(x)], null)], null),cljs$pprint$two_forms_$_iter__27468(cljs.core.rest(s__27469__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(amap);\n})()], 0)));\n});\ncljs.pprint.add_core_ns \x3d (function cljs$pprint$add_core_ns(amap){\nvar core \x3d \x22clojure.core\x22;\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__27490_SHARP_){\nvar vec__27493 \x3d p1__27490_SHARP_;\nvar s \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27493,(0),null);\nvar f \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27493,(1),null);\nif(cljs.core.not((function (){var or__5002__auto__ \x3d cljs.core.namespace(s);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.special_symbol_QMARK_(s);\n}\n})())){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(core,cljs.core.name(s)),f], null);\n} else {\nreturn p1__27490_SHARP_;\n}\n}),amap));\n});\ncljs.pprint._STAR_code_table_STAR_ \x3d cljs.pprint.two_forms(cljs.pprint.add_core_ns(cljs.core.PersistentHashMap.fromArrays([new cljs.core.Symbol(null,\x22.\x22,\x22.\x22,1975675962,null),new cljs.core.Symbol(null,\x22fn*\x22,\x22fn*\x22,-752876845,null),new cljs.core.Symbol(null,\x22when-first\x22,\x22when-first\x22,821699168,null),new cljs.core.Symbol(null,\x22if\x22,\x22if\x22,1181717262,null),new cljs.core.Symbol(null,\x22condp\x22,\x22condp\x22,1054325175,null),new cljs.core.Symbol(null,\x22..\x22,\x22..\x22,-300507420,null),new cljs.core.Symbol(null,\x22defmacro\x22,\x22defmacro\x22,2054157304,null),new cljs.core.Symbol(null,\x22defn\x22,\x22defn\x22,-126010802,null),new cljs.core.Symbol(null,\x22loop\x22,\x22loop\x22,1244978678,null),new cljs.core.Symbol(null,\x22struct\x22,\x22struct\x22,325972931,null),new cljs.core.Symbol(null,\x22doseq\x22,\x22doseq\x22,221164135,null),new cljs.core.Symbol(null,\x22if-not\x22,\x22if-not\x22,-265415609,null),new cljs.core.Symbol(null,\x22when-not\x22,\x22when-not\x22,-1223136340,null),new cljs.core.Symbol(null,\x22def\x22,\x22def\x22,597100991,null),new cljs.core.Symbol(null,\x22when\x22,\x22when\x22,1064114221,null),new cljs.core.Symbol(null,\x22with-open\x22,\x22with-open\x22,172119667,null),new cljs.core.Symbol(null,\x22with-local-vars\x22,\x22with-local-vars\x22,837642072,null),new cljs.core.Symbol(null,\x22defonce\x22,\x22defonce\x22,-1681484013,null),new cljs.core.Symbol(null,\x22when-let\x22,\x22when-let\x22,-1383043480,null),new cljs.core.Symbol(null,\x22ns\x22,\x22ns\x22,2082130287,null),new cljs.core.Symbol(null,\x22dotimes\x22,\x22dotimes\x22,-818708397,null),new cljs.core.Symbol(null,\x22cond\x22,\x22cond\x22,1606708055,null),new cljs.core.Symbol(null,\x22let\x22,\x22let\x22,358118826,null),new cljs.core.Symbol(null,\x22fn\x22,\x22fn\x22,465265323,null),new cljs.core.Symbol(null,\x22defn-\x22,\x22defn-\x22,1097765044,null),new cljs.core.Symbol(null,\x22locking\x22,\x22locking\x22,1542862874,null),new cljs.core.Symbol(null,\x22-\x3e\x22,\x22-\x3e\x22,-2139605430,null),new cljs.core.Symbol(null,\x22if-let\x22,\x22if-let\x22,1803593690,null),new cljs.core.Symbol(null,\x22binding\x22,\x22binding\x22,-2114503176,null),new cljs.core.Symbol(null,\x22struct-map\x22,\x22struct-map\x22,-1387540878,null)],[cljs.pprint.pprint_hold_first,cljs.pprint.pprint_anon_func,cljs.pprint.pprint_let,cljs.pprint.pprint_if,cljs.pprint.pprint_condp,cljs.pprint.pprint_hold_first,cljs.pprint.pprint_defn,cljs.pprint.pprint_defn,cljs.pprint.pprint_let,cljs.pprint.pprint_hold_first,cljs.pprint.pprint_let,cljs.pprint.pprint_if,cljs.pprint.pprint_if,cljs.pprint.pprint_hold_first,cljs.pprint.pprint_if,cljs.pprint.pprint_let,cljs.pprint.pprint_let,cljs.pprint.pprint_hold_first,cljs.pprint.pprint_let,cljs.pprint.pprint_ns,cljs.pprint.pprint_let,cljs.pprint.pprint_cond,cljs.pprint.pprint_let,cljs.pprint.pprint_defn,cljs.pprint.pprint_defn,cljs.pprint.pprint_hold_first,cljs.pprint.pprint_hold_first,cljs.pprint.pprint_let,cljs.pprint.pprint_let,cljs.pprint.pprint_hold_first])));\ncljs.pprint.pprint_code_list \x3d (function cljs$pprint$pprint_code_list(alis){\nif(cljs.core.not(cljs.pprint.pprint_reader_macro(alis))){\nvar temp__5802__auto__ \x3d cljs.pprint._STAR_code_table_STAR_.call(null, cljs.core.first(alis));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar special_form \x3d temp__5802__auto__;\nreturn (special_form.cljs$core$IFn$_invoke$arity$1 ? special_form.cljs$core$IFn$_invoke$arity$1(alis) : special_form.call(null, alis));\n} else {\nreturn cljs.pprint.pprint_simple_code_list(alis);\n}\n} else {\nreturn null;\n}\n});\ncljs.pprint.pprint_code_symbol \x3d (function cljs$pprint$pprint_code_symbol(sym){\nvar temp__5802__auto__ \x3d (sym.cljs$core$IFn$_invoke$arity$1 ? sym.cljs$core$IFn$_invoke$arity$1(cljs.pprint._STAR_symbol_map_STAR_) : sym.call(null, cljs.pprint._STAR_symbol_map_STAR_));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar arg_num \x3d temp__5802__auto__;\nreturn cljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([arg_num], 0));\n} else {\nif(cljs.core.truth_(cljs.pprint._STAR_print_suppress_namespaces_STAR_)){\nreturn cljs.pprint.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.name(sym)], 0));\n} else {\nreturn cljs.pprint.pr.call(null, sym);\n}\n}\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.pprint.code_dispatch !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * The pretty print dispatch function for pretty printing Clojure code.\n */\ncljs.pprint.code_dispatch \x3d (function (){var method_table__5599__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar prefer_table__5600__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar method_cache__5601__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar cached_hierarchy__5602__auto__ \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar hierarchy__5603__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22hierarchy\x22,\x22hierarchy\x22,-1053470341),(function (){var fexpr__27529 \x3d cljs.core.get_global_hierarchy;\nreturn (fexpr__27529.cljs$core$IFn$_invoke$arity$0 ? fexpr__27529.cljs$core$IFn$_invoke$arity$0() : fexpr__27529.call(null, ));\n})());\nreturn (new cljs.core.MultiFn(cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(\x22cljs.pprint\x22,\x22code-dispatch\x22),cljs.pprint.type_dispatcher,new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),hierarchy__5603__auto__,method_table__5599__auto__,prefer_table__5600__auto__,method_cache__5601__auto__,cached_hierarchy__5602__auto__));\n})();\n}\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22list\x22,\x22list\x22,765357683),cljs.pprint.pprint_code_list);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22symbol\x22,\x22symbol\x22,-1038572696),cljs.pprint.pprint_code_symbol);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22vector\x22,\x22vector\x22,1902966158),cljs.pprint.pprint_vector);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22map\x22,\x22map\x22,1371690461),cljs.pprint.pprint_map);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22set\x22,\x22set\x22,304602554),cljs.pprint.pprint_set);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22queue\x22,\x22queue\x22,1455835879),cljs.pprint.pprint_pqueue);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22deref\x22,\x22deref\x22,-145586795),cljs.pprint.pprint_ideref);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,null,cljs.pprint.pr);\ncljs.pprint.use_method(cljs.pprint.code_dispatch,new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),cljs.pprint.pprint_simple_default);\ncljs.pprint.set_pprint_dispatch(cljs.pprint.simple_dispatch);\ncljs.pprint.add_padding \x3d (function cljs$pprint$add_padding(width,s){\nvar padding \x3d (function (){var x__5087__auto__ \x3d (0);\nvar y__5088__auto__ \x3d (width - cljs.core.count(s));\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})();\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.str,clojure.string.join.cljs$core$IFn$_invoke$arity$1(cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(padding,\x22 \x22)),s);\n});\n/**\n * Prints a collection of maps in a textual table. Prints table headings\n * ks, and then a line of output for each row, corresponding to the keys\n * in ks. If ks are not specified, use the keys of the first item in rows.\n */\ncljs.pprint.print_table \x3d (function cljs$pprint$print_table(var_args){\nvar G__27554 \x3d arguments.length;\nswitch (G__27554) {\ncase 2:\nreturn cljs.pprint.print_table.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 1:\nreturn cljs.pprint.print_table.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.pprint.print_table.cljs$core$IFn$_invoke$arity$2 \x3d (function (ks,rows){\nif(cljs.core.seq(rows)){\nvar widths \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (k){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.max,((cljs.core.str.cljs$core$IFn$_invoke$arity$1(k)).length),cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__27548_SHARP_){\nreturn ((cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.get.cljs$core$IFn$_invoke$arity$2(p1__27548_SHARP_,k))).length);\n}),rows));\n}),ks);\nvar spacers \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__27549_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(p1__27549_SHARP_,\x22-\x22));\n}),widths);\nvar fmt_row \x3d (function (leader,divider,trailer,row){\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(leader),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(divider,(function (){var iter__5480__auto__ \x3d (function cljs$pprint$iter__27594(s__27595){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__27595__$1 \x3d s__27595;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__27595__$1);\nif(temp__5804__auto__){\nvar s__27595__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__27595__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__27595__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__27597 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__27596 \x3d (0);\nwhile(true){\nif((i__27596 \x3c size__5479__auto__)){\nvar vec__27604 \x3d cljs.core._nth(c__5478__auto__,i__27596);\nvar col \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27604,(0),null);\nvar width \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27604,(1),null);\ncljs.core.chunk_append(b__27597,cljs.pprint.add_padding(width,cljs.core.str.cljs$core$IFn$_invoke$arity$1(col)));\n\nvar G__29053 \x3d (i__27596 + (1));\ni__27596 \x3d G__29053;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__27597),cljs$pprint$iter__27594(cljs.core.chunk_rest(s__27595__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__27597),null);\n}\n} else {\nvar vec__27614 \x3d cljs.core.first(s__27595__$2);\nvar col \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27614,(0),null);\nvar width \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27614,(1),null);\nreturn cljs.core.cons(cljs.pprint.add_padding(width,cljs.core.str.cljs$core$IFn$_invoke$arity$1(col)),cljs$pprint$iter__27594(cljs.core.rest(s__27595__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(cljs.core.map.cljs$core$IFn$_invoke$arity$3(cljs.core.vector,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__27550_SHARP_){\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(row,p1__27550_SHARP_);\n}),ks),widths));\n})()))),cljs.core.str.cljs$core$IFn$_invoke$arity$1(trailer)].join(\x27\x27);\n});\ncljs.core.println();\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([fmt_row(\x22| \x22,\x22 | \x22,\x22 |\x22,cljs.core.zipmap(ks,ks))], 0));\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([fmt_row(\x22|-\x22,\x22-+-\x22,\x22-|\x22,cljs.core.zipmap(ks,spacers))], 0));\n\nvar seq__27620 \x3d cljs.core.seq(rows);\nvar chunk__27621 \x3d null;\nvar count__27622 \x3d (0);\nvar i__27623 \x3d (0);\nwhile(true){\nif((i__27623 \x3c count__27622)){\nvar row \x3d chunk__27621.cljs$core$IIndexed$_nth$arity$2(null, i__27623);\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([fmt_row(\x22| \x22,\x22 | \x22,\x22 |\x22,row)], 0));\n\n\nvar G__29054 \x3d seq__27620;\nvar G__29055 \x3d chunk__27621;\nvar G__29056 \x3d count__27622;\nvar G__29057 \x3d (i__27623 + (1));\nseq__27620 \x3d G__29054;\nchunk__27621 \x3d G__29055;\ncount__27622 \x3d G__29056;\ni__27623 \x3d G__29057;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__27620);\nif(temp__5804__auto__){\nvar seq__27620__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__27620__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__27620__$1);\nvar G__29060 \x3d cljs.core.chunk_rest(seq__27620__$1);\nvar G__29061 \x3d c__5525__auto__;\nvar G__29062 \x3d cljs.core.count(c__5525__auto__);\nvar G__29063 \x3d (0);\nseq__27620 \x3d G__29060;\nchunk__27621 \x3d G__29061;\ncount__27622 \x3d G__29062;\ni__27623 \x3d G__29063;\ncontinue;\n} else {\nvar row \x3d cljs.core.first(seq__27620__$1);\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([fmt_row(\x22| \x22,\x22 | \x22,\x22 |\x22,row)], 0));\n\n\nvar G__29064 \x3d cljs.core.next(seq__27620__$1);\nvar G__29065 \x3d null;\nvar G__29066 \x3d (0);\nvar G__29067 \x3d (0);\nseq__27620 \x3d G__29064;\nchunk__27621 \x3d G__29065;\ncount__27622 \x3d G__29066;\ni__27623 \x3d G__29067;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n} else {\nreturn null;\n}\n}));\n\n(cljs.pprint.print_table.cljs$core$IFn$_invoke$arity$1 \x3d (function (rows){\nreturn cljs.pprint.print_table.cljs$core$IFn$_invoke$arity$2(cljs.core.keys(cljs.core.first(rows)),rows);\n}));\n\n(cljs.pprint.print_table.cljs$lang$maxFixedArity \x3d 2);\n\n");
SHADOW_ENV.evalLoad("clojure.walk.js", true, "goog.provide(\x27clojure.walk\x27);\n/**\n * Traverses form, an arbitrary data structure.  inner and outer are\n *   functions.  Applies inner to each element of form, building up a\n *   data structure of the same type, then applies outer to the result.\n *   Recognizes all Clojure data structures. Consumes seqs as with doall.\n */\nclojure.walk.walk \x3d (function clojure$walk$walk(inner,outer,form){\nif(cljs.core.list_QMARK_(form)){\nvar G__21723 \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.list,cljs.core.map.cljs$core$IFn$_invoke$arity$2(inner,form));\nreturn (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__21723) : outer.call(null, G__21723));\n} else {\nif(cljs.core.map_entry_QMARK_(form)){\nvar G__21725 \x3d (new cljs.core.MapEntry((function (){var G__21729 \x3d cljs.core.key(form);\nreturn (inner.cljs$core$IFn$_invoke$arity$1 ? inner.cljs$core$IFn$_invoke$arity$1(G__21729) : inner.call(null, G__21729));\n})(),(function (){var G__21730 \x3d cljs.core.val(form);\nreturn (inner.cljs$core$IFn$_invoke$arity$1 ? inner.cljs$core$IFn$_invoke$arity$1(G__21730) : inner.call(null, G__21730));\n})(),null));\nreturn (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__21725) : outer.call(null, G__21725));\n} else {\nif(cljs.core.seq_QMARK_(form)){\nvar G__21731 \x3d cljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$2(inner,form));\nreturn (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__21731) : outer.call(null, G__21731));\n} else {\nif(cljs.core.record_QMARK_(form)){\nvar G__21732 \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (r,x){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(r,(inner.cljs$core$IFn$_invoke$arity$1 ? inner.cljs$core$IFn$_invoke$arity$1(x) : inner.call(null, x)));\n}),form,form);\nreturn (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__21732) : outer.call(null, G__21732));\n} else {\nif(cljs.core.coll_QMARK_(form)){\nvar G__21737 \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.empty(form),cljs.core.map.cljs$core$IFn$_invoke$arity$2(inner,form));\nreturn (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__21737) : outer.call(null, G__21737));\n} else {\nreturn (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(form) : outer.call(null, form));\n\n}\n}\n}\n}\n}\n});\n/**\n * Performs a depth-first, post-order traversal of form.  Calls f on\n *   each sub-form, uses f\x27s return value in place of the original.\n *   Recognizes all Clojure data structures. Consumes seqs as with doall.\n */\nclojure.walk.postwalk \x3d (function clojure$walk$postwalk(f,form){\nreturn clojure.walk.walk(cljs.core.partial.cljs$core$IFn$_invoke$arity$2(clojure.walk.postwalk,f),f,form);\n});\n/**\n * Like postwalk, but does pre-order traversal.\n */\nclojure.walk.prewalk \x3d (function clojure$walk$prewalk(f,form){\nreturn clojure.walk.walk(cljs.core.partial.cljs$core$IFn$_invoke$arity$2(clojure.walk.prewalk,f),cljs.core.identity,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(form) : f.call(null, form)));\n});\n/**\n * Recursively transforms all map keys from strings to keywords.\n */\nclojure.walk.keywordize_keys \x3d (function clojure$walk$keywordize_keys(m){\nvar f \x3d (function (p__21751){\nvar vec__21752 \x3d p__21751;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21752,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21752,(1),null);\nif(typeof k \x3d\x3d\x3d \x27string\x27){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(k),v], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v], null);\n}\n});\nreturn clojure.walk.postwalk((function (x){\nif(cljs.core.map_QMARK_(x)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,x));\n} else {\nreturn x;\n}\n}),m);\n});\n/**\n * Recursively transforms all map keys from keywords to strings.\n */\nclojure.walk.stringify_keys \x3d (function clojure$walk$stringify_keys(m){\nvar f \x3d (function (p__21779){\nvar vec__21782 \x3d p__21779;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21782,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21782,(1),null);\nif((k instanceof cljs.core.Keyword)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.name(k),v], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v], null);\n}\n});\nreturn clojure.walk.postwalk((function (x){\nif(cljs.core.map_QMARK_(x)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,x));\n} else {\nreturn x;\n}\n}),m);\n});\n/**\n * Recursively transforms form by replacing keys in smap with their\n *   values.  Like clojure/replace but works on any data structure.  Does\n *   replacement at the root of the tree first.\n */\nclojure.walk.prewalk_replace \x3d (function clojure$walk$prewalk_replace(smap,form){\nreturn clojure.walk.prewalk((function (x){\nif(cljs.core.contains_QMARK_(smap,x)){\nreturn (smap.cljs$core$IFn$_invoke$arity$1 ? smap.cljs$core$IFn$_invoke$arity$1(x) : smap.call(null, x));\n} else {\nreturn x;\n}\n}),form);\n});\n/**\n * Recursively transforms form by replacing keys in smap with their\n *   values.  Like clojure/replace but works on any data structure.  Does\n *   replacement at the leaves of the tree first.\n */\nclojure.walk.postwalk_replace \x3d (function clojure$walk$postwalk_replace(smap,form){\nreturn clojure.walk.postwalk((function (x){\nif(cljs.core.contains_QMARK_(smap,x)){\nreturn (smap.cljs$core$IFn$_invoke$arity$1 ? smap.cljs$core$IFn$_invoke$arity$1(x) : smap.call(null, x));\n} else {\nreturn x;\n}\n}),form);\n});\n");
SHADOW_ENV.evalLoad("cljs.spec.gen.alpha.js", true, "goog.provide(\x27cljs.spec.gen.alpha\x27);\n\n/**\n* @constructor\n * @implements {cljs.core.IDeref}\n*/\ncljs.spec.gen.alpha.LazyVar \x3d (function (f,cached){\nthis.f \x3d f;\nthis.cached \x3d cached;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 32768;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.gen.alpha.LazyVar.prototype.cljs$core$IDeref$_deref$arity$1 \x3d (function (this$){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif((!((self__.cached \x3d\x3d null)))){\nreturn self__.cached;\n} else {\nvar x \x3d (self__.f.cljs$core$IFn$_invoke$arity$0 ? self__.f.cljs$core$IFn$_invoke$arity$0() : self__.f.call(null, ));\nif((x \x3d\x3d null)){\n} else {\n(self__.cached \x3d x);\n}\n\nreturn x;\n}\n}));\n\n(cljs.spec.gen.alpha.LazyVar.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22f\x22,\x22f\x22,43394975,null),cljs.core.with_meta(new cljs.core.Symbol(null,\x22cached\x22,\x22cached\x22,-1216707864,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22mutable\x22,\x22mutable\x22,875778266),true], null))], null);\n}));\n\n(cljs.spec.gen.alpha.LazyVar.cljs$lang$type \x3d true);\n\n(cljs.spec.gen.alpha.LazyVar.cljs$lang$ctorStr \x3d \x22cljs.spec.gen.alpha/LazyVar\x22);\n\n(cljs.spec.gen.alpha.LazyVar.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.gen.alpha/LazyVar\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.gen.alpha/LazyVar.\n */\ncljs.spec.gen.alpha.__GT_LazyVar \x3d (function cljs$spec$gen$alpha$__GT_LazyVar(f,cached){\nreturn (new cljs.spec.gen.alpha.LazyVar(f,cached));\n});\n\ncljs.spec.gen.alpha.quick_check_ref \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.quick_check !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.quick_check;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check\x22,\x22quick-check\x22,\x22clojure.test.check/quick-check\x22,-810344251,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check\x22,\x22quick-check\x22,\x22clojure.test.check/quick-check\x22,-810344251,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\ncljs.spec.gen.alpha.quick_check \x3d (function cljs$spec$gen$alpha$quick_check(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22851 \x3d arguments.length;\nvar i__5727__auto___22852 \x3d (0);\nwhile(true){\nif((i__5727__auto___22852 \x3c len__5726__auto___22851)){\nargs__5732__auto__.push((arguments[i__5727__auto___22852]));\n\nvar G__22853 \x3d (i__5727__auto___22852 + (1));\ni__5727__auto___22852 \x3d G__22853;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.quick_check.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.quick_check.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.spec.gen.alpha.quick_check_ref),args);\n}));\n\n(cljs.spec.gen.alpha.quick_check.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.quick_check.cljs$lang$applyTo \x3d (function (seq21739){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21739));\n}));\n\ncljs.spec.gen.alpha.for_all_STAR__ref \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.properties !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.properties.for_all_STAR_ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.properties.for_all_STAR_;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.properties\x22,\x22for-all*\x22,\x22clojure.test.check.properties/for-all*\x22,67088845,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.properties\x22,\x22for-all*\x22,\x22clojure.test.check.properties/for-all*\x22,67088845,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Dynamically loaded clojure.test.check.properties/for-all*.\n */\ncljs.spec.gen.alpha.for_all_STAR_ \x3d (function cljs$spec$gen$alpha$for_all_STAR_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22860 \x3d arguments.length;\nvar i__5727__auto___22861 \x3d (0);\nwhile(true){\nif((i__5727__auto___22861 \x3c len__5726__auto___22860)){\nargs__5732__auto__.push((arguments[i__5727__auto___22861]));\n\nvar G__22862 \x3d (i__5727__auto___22861 + (1));\ni__5727__auto___22861 \x3d G__22862;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.for_all_STAR_.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.for_all_STAR_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.spec.gen.alpha.for_all_STAR__ref),args);\n}));\n\n(cljs.spec.gen.alpha.for_all_STAR_.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.for_all_STAR_.cljs$lang$applyTo \x3d (function (seq21778){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21778));\n}));\n\nvar g_QMARK__22867 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.generator_QMARK_ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.generator_QMARK_;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22generator?\x22,\x22clojure.test.check.generators/generator?\x22,-1378210460,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22generator?\x22,\x22clojure.test.check.generators/generator?\x22,-1378210460,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\nvar g_22868 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.generate !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.generate;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22generate\x22,\x22clojure.test.check.generators/generate\x22,-690390711,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22generate\x22,\x22clojure.test.check.generators/generate\x22,-690390711,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\nvar mkg_22869 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.__GT_Generator !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.__GT_Generator;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22-\x3eGenerator\x22,\x22clojure.test.check.generators/-\x3eGenerator\x22,-1179475051,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22-\x3eGenerator\x22,\x22clojure.test.check.generators/-\x3eGenerator\x22,-1179475051,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\ncljs.spec.gen.alpha.generator_QMARK_ \x3d (function cljs$spec$gen$alpha$generator_QMARK_(x){\nvar fexpr__21796 \x3d cljs.core.deref(g_QMARK__22867);\nreturn (fexpr__21796.cljs$core$IFn$_invoke$arity$1 ? fexpr__21796.cljs$core$IFn$_invoke$arity$1(x) : fexpr__21796.call(null, x));\n});\n\ncljs.spec.gen.alpha.generator \x3d (function cljs$spec$gen$alpha$generator(gfn){\nvar fexpr__21798 \x3d cljs.core.deref(mkg_22869);\nreturn (fexpr__21798.cljs$core$IFn$_invoke$arity$1 ? fexpr__21798.cljs$core$IFn$_invoke$arity$1(gfn) : fexpr__21798.call(null, gfn));\n});\n\n/**\n * Generate a single value using generator.\n */\ncljs.spec.gen.alpha.generate \x3d (function cljs$spec$gen$alpha$generate(generator){\nvar fexpr__21799 \x3d cljs.core.deref(g_22868);\nreturn (fexpr__21799.cljs$core$IFn$_invoke$arity$1 ? fexpr__21799.cljs$core$IFn$_invoke$arity$1(generator) : fexpr__21799.call(null, generator));\n});\ncljs.spec.gen.alpha.delay_impl \x3d (function cljs$spec$gen$alpha$delay_impl(gfnd){\nreturn cljs.spec.gen.alpha.generator((function (rnd,size){\nvar fexpr__21802 \x3d new cljs.core.Keyword(null,\x22gen\x22,\x22gen\x22,142575302).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(gfnd));\nreturn (fexpr__21802.cljs$core$IFn$_invoke$arity$2 ? fexpr__21802.cljs$core$IFn$_invoke$arity$2(rnd,size) : fexpr__21802.call(null, rnd,size));\n}));\n});\nvar g__11601__auto___22877 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.hash_map !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.hash_map;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22hash-map\x22,\x22clojure.test.check.generators/hash-map\x22,1961346626,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22hash-map\x22,\x22clojure.test.check.generators/hash-map\x22,1961346626,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/hash-map\n */\ncljs.spec.gen.alpha.hash_map \x3d (function cljs$spec$gen$alpha$hash_map(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22882 \x3d arguments.length;\nvar i__5727__auto___22883 \x3d (0);\nwhile(true){\nif((i__5727__auto___22883 \x3c len__5726__auto___22882)){\nargs__5732__auto__.push((arguments[i__5727__auto___22883]));\n\nvar G__22884 \x3d (i__5727__auto___22883 + (1));\ni__5727__auto___22883 \x3d G__22884;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.hash_map.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.hash_map.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22877),args);\n}));\n\n(cljs.spec.gen.alpha.hash_map.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.hash_map.cljs$lang$applyTo \x3d (function (seq21817){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21817));\n}));\n\n\nvar g__11601__auto___22887 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.list !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.list;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22list\x22,\x22clojure.test.check.generators/list\x22,506971058,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22list\x22,\x22clojure.test.check.generators/list\x22,506971058,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/list\n */\ncljs.spec.gen.alpha.list \x3d (function cljs$spec$gen$alpha$list(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22892 \x3d arguments.length;\nvar i__5727__auto___22893 \x3d (0);\nwhile(true){\nif((i__5727__auto___22893 \x3c len__5726__auto___22892)){\nargs__5732__auto__.push((arguments[i__5727__auto___22893]));\n\nvar G__22894 \x3d (i__5727__auto___22893 + (1));\ni__5727__auto___22893 \x3d G__22894;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.list.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.list.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22887),args);\n}));\n\n(cljs.spec.gen.alpha.list.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.list.cljs$lang$applyTo \x3d (function (seq21845){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21845));\n}));\n\n\nvar g__11601__auto___22896 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.map !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.map;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22map\x22,\x22clojure.test.check.generators/map\x22,45738796,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22map\x22,\x22clojure.test.check.generators/map\x22,45738796,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/map\n */\ncljs.spec.gen.alpha.map \x3d (function cljs$spec$gen$alpha$map(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22901 \x3d arguments.length;\nvar i__5727__auto___22902 \x3d (0);\nwhile(true){\nif((i__5727__auto___22902 \x3c len__5726__auto___22901)){\nargs__5732__auto__.push((arguments[i__5727__auto___22902]));\n\nvar G__22905 \x3d (i__5727__auto___22902 + (1));\ni__5727__auto___22902 \x3d G__22905;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.map.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.map.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22896),args);\n}));\n\n(cljs.spec.gen.alpha.map.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.map.cljs$lang$applyTo \x3d (function (seq21859){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21859));\n}));\n\n\nvar g__11601__auto___22907 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.not_empty !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.not_empty;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22not-empty\x22,\x22clojure.test.check.generators/not-empty\x22,-876211682,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22not-empty\x22,\x22clojure.test.check.generators/not-empty\x22,-876211682,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/not-empty\n */\ncljs.spec.gen.alpha.not_empty \x3d (function cljs$spec$gen$alpha$not_empty(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22911 \x3d arguments.length;\nvar i__5727__auto___22912 \x3d (0);\nwhile(true){\nif((i__5727__auto___22912 \x3c len__5726__auto___22911)){\nargs__5732__auto__.push((arguments[i__5727__auto___22912]));\n\nvar G__22913 \x3d (i__5727__auto___22912 + (1));\ni__5727__auto___22912 \x3d G__22913;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.not_empty.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.not_empty.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22907),args);\n}));\n\n(cljs.spec.gen.alpha.not_empty.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.not_empty.cljs$lang$applyTo \x3d (function (seq21882){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21882));\n}));\n\n\nvar g__11601__auto___22920 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.set !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.set;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22set\x22,\x22clojure.test.check.generators/set\x22,-1027639543,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22set\x22,\x22clojure.test.check.generators/set\x22,-1027639543,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/set\n */\ncljs.spec.gen.alpha.set \x3d (function cljs$spec$gen$alpha$set(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22926 \x3d arguments.length;\nvar i__5727__auto___22927 \x3d (0);\nwhile(true){\nif((i__5727__auto___22927 \x3c len__5726__auto___22926)){\nargs__5732__auto__.push((arguments[i__5727__auto___22927]));\n\nvar G__22928 \x3d (i__5727__auto___22927 + (1));\ni__5727__auto___22927 \x3d G__22928;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.set.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.set.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22920),args);\n}));\n\n(cljs.spec.gen.alpha.set.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.set.cljs$lang$applyTo \x3d (function (seq21913){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21913));\n}));\n\n\nvar g__11601__auto___22932 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.vector !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.vector;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22vector\x22,\x22clojure.test.check.generators/vector\x22,1081775325,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22vector\x22,\x22clojure.test.check.generators/vector\x22,1081775325,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/vector\n */\ncljs.spec.gen.alpha.vector \x3d (function cljs$spec$gen$alpha$vector(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22935 \x3d arguments.length;\nvar i__5727__auto___22936 \x3d (0);\nwhile(true){\nif((i__5727__auto___22936 \x3c len__5726__auto___22935)){\nargs__5732__auto__.push((arguments[i__5727__auto___22936]));\n\nvar G__22937 \x3d (i__5727__auto___22936 + (1));\ni__5727__auto___22936 \x3d G__22937;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22932),args);\n}));\n\n(cljs.spec.gen.alpha.vector.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.vector.cljs$lang$applyTo \x3d (function (seq21939){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21939));\n}));\n\n\nvar g__11601__auto___22939 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.vector_distinct !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.vector_distinct;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22vector-distinct\x22,\x22clojure.test.check.generators/vector-distinct\x22,1656877834,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22vector-distinct\x22,\x22clojure.test.check.generators/vector-distinct\x22,1656877834,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/vector-distinct\n */\ncljs.spec.gen.alpha.vector_distinct \x3d (function cljs$spec$gen$alpha$vector_distinct(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22940 \x3d arguments.length;\nvar i__5727__auto___22941 \x3d (0);\nwhile(true){\nif((i__5727__auto___22941 \x3c len__5726__auto___22940)){\nargs__5732__auto__.push((arguments[i__5727__auto___22941]));\n\nvar G__22942 \x3d (i__5727__auto___22941 + (1));\ni__5727__auto___22941 \x3d G__22942;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.vector_distinct.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.vector_distinct.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22939),args);\n}));\n\n(cljs.spec.gen.alpha.vector_distinct.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.vector_distinct.cljs$lang$applyTo \x3d (function (seq21959){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21959));\n}));\n\n\nvar g__11601__auto___22947 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.fmap !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.fmap;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22fmap\x22,\x22clojure.test.check.generators/fmap\x22,1957997092,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22fmap\x22,\x22clojure.test.check.generators/fmap\x22,1957997092,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/fmap\n */\ncljs.spec.gen.alpha.fmap \x3d (function cljs$spec$gen$alpha$fmap(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22950 \x3d arguments.length;\nvar i__5727__auto___22951 \x3d (0);\nwhile(true){\nif((i__5727__auto___22951 \x3c len__5726__auto___22950)){\nargs__5732__auto__.push((arguments[i__5727__auto___22951]));\n\nvar G__22952 \x3d (i__5727__auto___22951 + (1));\ni__5727__auto___22951 \x3d G__22952;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22947),args);\n}));\n\n(cljs.spec.gen.alpha.fmap.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.fmap.cljs$lang$applyTo \x3d (function (seq21979){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21979));\n}));\n\n\nvar g__11601__auto___22957 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.elements !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.elements;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22elements\x22,\x22clojure.test.check.generators/elements\x22,438991326,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22elements\x22,\x22clojure.test.check.generators/elements\x22,438991326,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/elements\n */\ncljs.spec.gen.alpha.elements \x3d (function cljs$spec$gen$alpha$elements(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22958 \x3d arguments.length;\nvar i__5727__auto___22959 \x3d (0);\nwhile(true){\nif((i__5727__auto___22959 \x3c len__5726__auto___22958)){\nargs__5732__auto__.push((arguments[i__5727__auto___22959]));\n\nvar G__22960 \x3d (i__5727__auto___22959 + (1));\ni__5727__auto___22959 \x3d G__22960;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.elements.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.elements.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22957),args);\n}));\n\n(cljs.spec.gen.alpha.elements.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.elements.cljs$lang$applyTo \x3d (function (seq21986){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21986));\n}));\n\n\nvar g__11601__auto___22965 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.bind !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.bind;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22bind\x22,\x22clojure.test.check.generators/bind\x22,-361313906,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22bind\x22,\x22clojure.test.check.generators/bind\x22,-361313906,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/bind\n */\ncljs.spec.gen.alpha.bind \x3d (function cljs$spec$gen$alpha$bind(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22966 \x3d arguments.length;\nvar i__5727__auto___22967 \x3d (0);\nwhile(true){\nif((i__5727__auto___22967 \x3c len__5726__auto___22966)){\nargs__5732__auto__.push((arguments[i__5727__auto___22967]));\n\nvar G__22968 \x3d (i__5727__auto___22967 + (1));\ni__5727__auto___22967 \x3d G__22968;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.bind.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.bind.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22965),args);\n}));\n\n(cljs.spec.gen.alpha.bind.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.bind.cljs$lang$applyTo \x3d (function (seq22003){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22003));\n}));\n\n\nvar g__11601__auto___22971 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.choose !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.choose;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22choose\x22,\x22clojure.test.check.generators/choose\x22,909997832,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22choose\x22,\x22clojure.test.check.generators/choose\x22,909997832,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/choose\n */\ncljs.spec.gen.alpha.choose \x3d (function cljs$spec$gen$alpha$choose(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22972 \x3d arguments.length;\nvar i__5727__auto___22974 \x3d (0);\nwhile(true){\nif((i__5727__auto___22974 \x3c len__5726__auto___22972)){\nargs__5732__auto__.push((arguments[i__5727__auto___22974]));\n\nvar G__22975 \x3d (i__5727__auto___22974 + (1));\ni__5727__auto___22974 \x3d G__22975;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.choose.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.choose.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22971),args);\n}));\n\n(cljs.spec.gen.alpha.choose.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.choose.cljs$lang$applyTo \x3d (function (seq22025){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22025));\n}));\n\n\nvar g__11601__auto___22976 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.one_of !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.one_of;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22one-of\x22,\x22clojure.test.check.generators/one-of\x22,-183339191,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22one-of\x22,\x22clojure.test.check.generators/one-of\x22,-183339191,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/one-of\n */\ncljs.spec.gen.alpha.one_of \x3d (function cljs$spec$gen$alpha$one_of(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___22979 \x3d arguments.length;\nvar i__5727__auto___22980 \x3d (0);\nwhile(true){\nif((i__5727__auto___22980 \x3c len__5726__auto___22979)){\nargs__5732__auto__.push((arguments[i__5727__auto___22980]));\n\nvar G__22981 \x3d (i__5727__auto___22980 + (1));\ni__5727__auto___22980 \x3d G__22981;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22976),args);\n}));\n\n(cljs.spec.gen.alpha.one_of.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.one_of.cljs$lang$applyTo \x3d (function (seq22076){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22076));\n}));\n\n\nvar g__11601__auto___22987 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.such_that !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.such_that;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22such-that\x22,\x22clojure.test.check.generators/such-that\x22,-1754178732,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22such-that\x22,\x22clojure.test.check.generators/such-that\x22,-1754178732,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/such-that\n */\ncljs.spec.gen.alpha.such_that \x3d (function cljs$spec$gen$alpha$such_that(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23001 \x3d arguments.length;\nvar i__5727__auto___23002 \x3d (0);\nwhile(true){\nif((i__5727__auto___23002 \x3c len__5726__auto___23001)){\nargs__5732__auto__.push((arguments[i__5727__auto___23002]));\n\nvar G__23003 \x3d (i__5727__auto___23002 + (1));\ni__5727__auto___23002 \x3d G__23003;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.such_that.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.such_that.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___22987),args);\n}));\n\n(cljs.spec.gen.alpha.such_that.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.such_that.cljs$lang$applyTo \x3d (function (seq22116){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22116));\n}));\n\n\nvar g__11601__auto___23008 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.tuple !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.tuple;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22tuple\x22,\x22clojure.test.check.generators/tuple\x22,-143711557,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22tuple\x22,\x22clojure.test.check.generators/tuple\x22,-143711557,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/tuple\n */\ncljs.spec.gen.alpha.tuple \x3d (function cljs$spec$gen$alpha$tuple(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23010 \x3d arguments.length;\nvar i__5727__auto___23012 \x3d (0);\nwhile(true){\nif((i__5727__auto___23012 \x3c len__5726__auto___23010)){\nargs__5732__auto__.push((arguments[i__5727__auto___23012]));\n\nvar G__23013 \x3d (i__5727__auto___23012 + (1));\ni__5727__auto___23012 \x3d G__23013;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.tuple.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.tuple.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___23008),args);\n}));\n\n(cljs.spec.gen.alpha.tuple.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.tuple.cljs$lang$applyTo \x3d (function (seq22132){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22132));\n}));\n\n\nvar g__11601__auto___23014 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.sample !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.sample;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22sample\x22,\x22clojure.test.check.generators/sample\x22,-382944992,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22sample\x22,\x22clojure.test.check.generators/sample\x22,-382944992,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/sample\n */\ncljs.spec.gen.alpha.sample \x3d (function cljs$spec$gen$alpha$sample(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23018 \x3d arguments.length;\nvar i__5727__auto___23019 \x3d (0);\nwhile(true){\nif((i__5727__auto___23019 \x3c len__5726__auto___23018)){\nargs__5732__auto__.push((arguments[i__5727__auto___23019]));\n\nvar G__23020 \x3d (i__5727__auto___23019 + (1));\ni__5727__auto___23019 \x3d G__23020;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.sample.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.sample.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___23014),args);\n}));\n\n(cljs.spec.gen.alpha.sample.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.sample.cljs$lang$applyTo \x3d (function (seq22144){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22144));\n}));\n\n\nvar g__11601__auto___23021 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.return$ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.return$;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22return\x22,\x22clojure.test.check.generators/return\x22,1744522038,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22return\x22,\x22clojure.test.check.generators/return\x22,1744522038,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/return\n */\ncljs.spec.gen.alpha.return$ \x3d (function cljs$spec$gen$alpha$return(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23024 \x3d arguments.length;\nvar i__5727__auto___23025 \x3d (0);\nwhile(true){\nif((i__5727__auto___23025 \x3c len__5726__auto___23024)){\nargs__5732__auto__.push((arguments[i__5727__auto___23025]));\n\nvar G__23026 \x3d (i__5727__auto___23025 + (1));\ni__5727__auto___23025 \x3d G__23026;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___23021),args);\n}));\n\n(cljs.spec.gen.alpha.return$.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.return$.cljs$lang$applyTo \x3d (function (seq22168){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22168));\n}));\n\n\nvar g__11601__auto___23028 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.large_integer_STAR_ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.large_integer_STAR_;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22large-integer*\x22,\x22clojure.test.check.generators/large-integer*\x22,-437830670,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22large-integer*\x22,\x22clojure.test.check.generators/large-integer*\x22,-437830670,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/large-integer*\n */\ncljs.spec.gen.alpha.large_integer_STAR_ \x3d (function cljs$spec$gen$alpha$large_integer_STAR_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23031 \x3d arguments.length;\nvar i__5727__auto___23032 \x3d (0);\nwhile(true){\nif((i__5727__auto___23032 \x3c len__5726__auto___23031)){\nargs__5732__auto__.push((arguments[i__5727__auto___23032]));\n\nvar G__23033 \x3d (i__5727__auto___23032 + (1));\ni__5727__auto___23032 \x3d G__23033;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.large_integer_STAR_.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.large_integer_STAR_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___23028),args);\n}));\n\n(cljs.spec.gen.alpha.large_integer_STAR_.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.large_integer_STAR_.cljs$lang$applyTo \x3d (function (seq22209){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22209));\n}));\n\n\nvar g__11601__auto___23035 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.double_STAR_ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.double_STAR_;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22double*\x22,\x22clojure.test.check.generators/double*\x22,841542265,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22double*\x22,\x22clojure.test.check.generators/double*\x22,841542265,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/double*\n */\ncljs.spec.gen.alpha.double_STAR_ \x3d (function cljs$spec$gen$alpha$double_STAR_(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23036 \x3d arguments.length;\nvar i__5727__auto___23037 \x3d (0);\nwhile(true){\nif((i__5727__auto___23037 \x3c len__5726__auto___23036)){\nargs__5732__auto__.push((arguments[i__5727__auto___23037]));\n\nvar G__23038 \x3d (i__5727__auto___23037 + (1));\ni__5727__auto___23037 \x3d G__23038;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.double_STAR_.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.double_STAR_.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___23035),args);\n}));\n\n(cljs.spec.gen.alpha.double_STAR_.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.double_STAR_.cljs$lang$applyTo \x3d (function (seq22231){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22231));\n}));\n\n\nvar g__11601__auto___23040 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.frequency !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.frequency;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22frequency\x22,\x22clojure.test.check.generators/frequency\x22,2090703177,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22frequency\x22,\x22clojure.test.check.generators/frequency\x22,2090703177,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/frequency\n */\ncljs.spec.gen.alpha.frequency \x3d (function cljs$spec$gen$alpha$frequency(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23043 \x3d arguments.length;\nvar i__5727__auto___23044 \x3d (0);\nwhile(true){\nif((i__5727__auto___23044 \x3c len__5726__auto___23043)){\nargs__5732__auto__.push((arguments[i__5727__auto___23044]));\n\nvar G__23047 \x3d (i__5727__auto___23044 + (1));\ni__5727__auto___23044 \x3d G__23047;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.frequency.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.frequency.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___23040),args);\n}));\n\n(cljs.spec.gen.alpha.frequency.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.frequency.cljs$lang$applyTo \x3d (function (seq22265){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22265));\n}));\n\n\nvar g__11601__auto___23050 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.shuffle !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.shuffle;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22shuffle\x22,\x22clojure.test.check.generators/shuffle\x22,1032401055,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22shuffle\x22,\x22clojure.test.check.generators/shuffle\x22,1032401055,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Lazy loaded version of clojure.test.check.generators/shuffle\n */\ncljs.spec.gen.alpha.shuffle \x3d (function cljs$spec$gen$alpha$shuffle(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23052 \x3d arguments.length;\nvar i__5727__auto___23053 \x3d (0);\nwhile(true){\nif((i__5727__auto___23053 \x3c len__5726__auto___23052)){\nargs__5732__auto__.push((arguments[i__5727__auto___23053]));\n\nvar G__23055 \x3d (i__5727__auto___23053 + (1));\ni__5727__auto___23053 \x3d G__23055;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.shuffle.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.shuffle.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(g__11601__auto___23050),args);\n}));\n\n(cljs.spec.gen.alpha.shuffle.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.shuffle.cljs$lang$applyTo \x3d (function (seq22301){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22301));\n}));\n\nvar g__11606__auto___23057 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.any !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.any;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22any\x22,\x22clojure.test.check.generators/any\x22,1883743710,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22any\x22,\x22clojure.test.check.generators/any\x22,1883743710,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/any\n */\ncljs.spec.gen.alpha.any \x3d (function cljs$spec$gen$alpha$any(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23062 \x3d arguments.length;\nvar i__5727__auto___23063 \x3d (0);\nwhile(true){\nif((i__5727__auto___23063 \x3c len__5726__auto___23062)){\nargs__5732__auto__.push((arguments[i__5727__auto___23063]));\n\nvar G__23064 \x3d (i__5727__auto___23063 + (1));\ni__5727__auto___23063 \x3d G__23064;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.any.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.any.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23057);\n}));\n\n(cljs.spec.gen.alpha.any.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.any.cljs$lang$applyTo \x3d (function (seq22340){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22340));\n}));\n\n\nvar g__11606__auto___23076 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.any_printable !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.any_printable;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22any-printable\x22,\x22clojure.test.check.generators/any-printable\x22,-1570493991,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22any-printable\x22,\x22clojure.test.check.generators/any-printable\x22,-1570493991,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/any-printable\n */\ncljs.spec.gen.alpha.any_printable \x3d (function cljs$spec$gen$alpha$any_printable(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23078 \x3d arguments.length;\nvar i__5727__auto___23082 \x3d (0);\nwhile(true){\nif((i__5727__auto___23082 \x3c len__5726__auto___23078)){\nargs__5732__auto__.push((arguments[i__5727__auto___23082]));\n\nvar G__23083 \x3d (i__5727__auto___23082 + (1));\ni__5727__auto___23082 \x3d G__23083;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.any_printable.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.any_printable.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23076);\n}));\n\n(cljs.spec.gen.alpha.any_printable.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.any_printable.cljs$lang$applyTo \x3d (function (seq22359){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22359));\n}));\n\n\nvar g__11606__auto___23085 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.boolean$ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.boolean$;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22boolean\x22,\x22clojure.test.check.generators/boolean\x22,1586992347,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22boolean\x22,\x22clojure.test.check.generators/boolean\x22,1586992347,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/boolean\n */\ncljs.spec.gen.alpha.boolean$ \x3d (function cljs$spec$gen$alpha$boolean(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23086 \x3d arguments.length;\nvar i__5727__auto___23087 \x3d (0);\nwhile(true){\nif((i__5727__auto___23087 \x3c len__5726__auto___23086)){\nargs__5732__auto__.push((arguments[i__5727__auto___23087]));\n\nvar G__23088 \x3d (i__5727__auto___23087 + (1));\ni__5727__auto___23087 \x3d G__23088;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.boolean$.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.boolean$.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23085);\n}));\n\n(cljs.spec.gen.alpha.boolean$.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.boolean$.cljs$lang$applyTo \x3d (function (seq22368){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22368));\n}));\n\n\nvar g__11606__auto___23093 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.char$ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.char$;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char\x22,\x22clojure.test.check.generators/char\x22,-1426343459,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char\x22,\x22clojure.test.check.generators/char\x22,-1426343459,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/char\n */\ncljs.spec.gen.alpha.char$ \x3d (function cljs$spec$gen$alpha$char(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23100 \x3d arguments.length;\nvar i__5727__auto___23102 \x3d (0);\nwhile(true){\nif((i__5727__auto___23102 \x3c len__5726__auto___23100)){\nargs__5732__auto__.push((arguments[i__5727__auto___23102]));\n\nvar G__23103 \x3d (i__5727__auto___23102 + (1));\ni__5727__auto___23102 \x3d G__23103;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.char$.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.char$.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23093);\n}));\n\n(cljs.spec.gen.alpha.char$.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.char$.cljs$lang$applyTo \x3d (function (seq22380){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22380));\n}));\n\n\nvar g__11606__auto___23114 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.char_alpha !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.char_alpha;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char-alpha\x22,\x22clojure.test.check.generators/char-alpha\x22,615785796,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char-alpha\x22,\x22clojure.test.check.generators/char-alpha\x22,615785796,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/char-alpha\n */\ncljs.spec.gen.alpha.char_alpha \x3d (function cljs$spec$gen$alpha$char_alpha(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23116 \x3d arguments.length;\nvar i__5727__auto___23117 \x3d (0);\nwhile(true){\nif((i__5727__auto___23117 \x3c len__5726__auto___23116)){\nargs__5732__auto__.push((arguments[i__5727__auto___23117]));\n\nvar G__23119 \x3d (i__5727__auto___23117 + (1));\ni__5727__auto___23117 \x3d G__23119;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.char_alpha.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.char_alpha.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23114);\n}));\n\n(cljs.spec.gen.alpha.char_alpha.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.char_alpha.cljs$lang$applyTo \x3d (function (seq22389){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22389));\n}));\n\n\nvar g__11606__auto___23127 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.char_alphanumeric !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.char_alphanumeric;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char-alphanumeric\x22,\x22clojure.test.check.generators/char-alphanumeric\x22,1383091431,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char-alphanumeric\x22,\x22clojure.test.check.generators/char-alphanumeric\x22,1383091431,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/char-alphanumeric\n */\ncljs.spec.gen.alpha.char_alphanumeric \x3d (function cljs$spec$gen$alpha$char_alphanumeric(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23132 \x3d arguments.length;\nvar i__5727__auto___23133 \x3d (0);\nwhile(true){\nif((i__5727__auto___23133 \x3c len__5726__auto___23132)){\nargs__5732__auto__.push((arguments[i__5727__auto___23133]));\n\nvar G__23134 \x3d (i__5727__auto___23133 + (1));\ni__5727__auto___23133 \x3d G__23134;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.char_alphanumeric.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.char_alphanumeric.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23127);\n}));\n\n(cljs.spec.gen.alpha.char_alphanumeric.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.char_alphanumeric.cljs$lang$applyTo \x3d (function (seq22402){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22402));\n}));\n\n\nvar g__11606__auto___23138 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.char_ascii !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.char_ascii;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char-ascii\x22,\x22clojure.test.check.generators/char-ascii\x22,-899908538,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22char-ascii\x22,\x22clojure.test.check.generators/char-ascii\x22,-899908538,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/char-ascii\n */\ncljs.spec.gen.alpha.char_ascii \x3d (function cljs$spec$gen$alpha$char_ascii(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23139 \x3d arguments.length;\nvar i__5727__auto___23141 \x3d (0);\nwhile(true){\nif((i__5727__auto___23141 \x3c len__5726__auto___23139)){\nargs__5732__auto__.push((arguments[i__5727__auto___23141]));\n\nvar G__23143 \x3d (i__5727__auto___23141 + (1));\ni__5727__auto___23141 \x3d G__23143;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.char_ascii.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.char_ascii.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23138);\n}));\n\n(cljs.spec.gen.alpha.char_ascii.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.char_ascii.cljs$lang$applyTo \x3d (function (seq22406){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22406));\n}));\n\n\nvar g__11606__auto___23146 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.double$ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.double$;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22double\x22,\x22clojure.test.check.generators/double\x22,668331090,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22double\x22,\x22clojure.test.check.generators/double\x22,668331090,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/double\n */\ncljs.spec.gen.alpha.double$ \x3d (function cljs$spec$gen$alpha$double(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23150 \x3d arguments.length;\nvar i__5727__auto___23151 \x3d (0);\nwhile(true){\nif((i__5727__auto___23151 \x3c len__5726__auto___23150)){\nargs__5732__auto__.push((arguments[i__5727__auto___23151]));\n\nvar G__23152 \x3d (i__5727__auto___23151 + (1));\ni__5727__auto___23151 \x3d G__23152;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.double$.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.double$.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23146);\n}));\n\n(cljs.spec.gen.alpha.double$.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.double$.cljs$lang$applyTo \x3d (function (seq22428){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22428));\n}));\n\n\nvar g__11606__auto___23154 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.int$ !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.int$;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22int\x22,\x22clojure.test.check.generators/int\x22,1756228469,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22int\x22,\x22clojure.test.check.generators/int\x22,1756228469,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/int\n */\ncljs.spec.gen.alpha.int$ \x3d (function cljs$spec$gen$alpha$int(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23170 \x3d arguments.length;\nvar i__5727__auto___23174 \x3d (0);\nwhile(true){\nif((i__5727__auto___23174 \x3c len__5726__auto___23170)){\nargs__5732__auto__.push((arguments[i__5727__auto___23174]));\n\nvar G__23180 \x3d (i__5727__auto___23174 + (1));\ni__5727__auto___23174 \x3d G__23180;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.int$.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.int$.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23154);\n}));\n\n(cljs.spec.gen.alpha.int$.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.int$.cljs$lang$applyTo \x3d (function (seq22477){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22477));\n}));\n\n\nvar g__11606__auto___23182 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.keyword !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.keyword;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22keyword\x22,\x22clojure.test.check.generators/keyword\x22,24530530,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22keyword\x22,\x22clojure.test.check.generators/keyword\x22,24530530,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/keyword\n */\ncljs.spec.gen.alpha.keyword \x3d (function cljs$spec$gen$alpha$keyword(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23190 \x3d arguments.length;\nvar i__5727__auto___23191 \x3d (0);\nwhile(true){\nif((i__5727__auto___23191 \x3c len__5726__auto___23190)){\nargs__5732__auto__.push((arguments[i__5727__auto___23191]));\n\nvar G__23192 \x3d (i__5727__auto___23191 + (1));\ni__5727__auto___23191 \x3d G__23192;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.keyword.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.keyword.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23182);\n}));\n\n(cljs.spec.gen.alpha.keyword.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.keyword.cljs$lang$applyTo \x3d (function (seq22526){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22526));\n}));\n\n\nvar g__11606__auto___23198 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.keyword_ns !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.keyword_ns;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22keyword-ns\x22,\x22clojure.test.check.generators/keyword-ns\x22,-1492628482,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22keyword-ns\x22,\x22clojure.test.check.generators/keyword-ns\x22,-1492628482,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/keyword-ns\n */\ncljs.spec.gen.alpha.keyword_ns \x3d (function cljs$spec$gen$alpha$keyword_ns(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23202 \x3d arguments.length;\nvar i__5727__auto___23203 \x3d (0);\nwhile(true){\nif((i__5727__auto___23203 \x3c len__5726__auto___23202)){\nargs__5732__auto__.push((arguments[i__5727__auto___23203]));\n\nvar G__23205 \x3d (i__5727__auto___23203 + (1));\ni__5727__auto___23203 \x3d G__23205;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.keyword_ns.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.keyword_ns.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23198);\n}));\n\n(cljs.spec.gen.alpha.keyword_ns.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.keyword_ns.cljs$lang$applyTo \x3d (function (seq22569){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22569));\n}));\n\n\nvar g__11606__auto___23207 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.large_integer !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.large_integer;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22large-integer\x22,\x22clojure.test.check.generators/large-integer\x22,-865967138,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22large-integer\x22,\x22clojure.test.check.generators/large-integer\x22,-865967138,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/large-integer\n */\ncljs.spec.gen.alpha.large_integer \x3d (function cljs$spec$gen$alpha$large_integer(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23211 \x3d arguments.length;\nvar i__5727__auto___23215 \x3d (0);\nwhile(true){\nif((i__5727__auto___23215 \x3c len__5726__auto___23211)){\nargs__5732__auto__.push((arguments[i__5727__auto___23215]));\n\nvar G__23216 \x3d (i__5727__auto___23215 + (1));\ni__5727__auto___23215 \x3d G__23216;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.large_integer.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.large_integer.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23207);\n}));\n\n(cljs.spec.gen.alpha.large_integer.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.large_integer.cljs$lang$applyTo \x3d (function (seq22621){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22621));\n}));\n\n\nvar g__11606__auto___23218 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.ratio !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.ratio;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22ratio\x22,\x22clojure.test.check.generators/ratio\x22,1540966915,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22ratio\x22,\x22clojure.test.check.generators/ratio\x22,1540966915,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/ratio\n */\ncljs.spec.gen.alpha.ratio \x3d (function cljs$spec$gen$alpha$ratio(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23226 \x3d arguments.length;\nvar i__5727__auto___23230 \x3d (0);\nwhile(true){\nif((i__5727__auto___23230 \x3c len__5726__auto___23226)){\nargs__5732__auto__.push((arguments[i__5727__auto___23230]));\n\nvar G__23236 \x3d (i__5727__auto___23230 + (1));\ni__5727__auto___23230 \x3d G__23236;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.ratio.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.ratio.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23218);\n}));\n\n(cljs.spec.gen.alpha.ratio.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.ratio.cljs$lang$applyTo \x3d (function (seq22648){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22648));\n}));\n\n\nvar g__11606__auto___23243 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.simple_type !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.simple_type;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22simple-type\x22,\x22clojure.test.check.generators/simple-type\x22,892572284,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22simple-type\x22,\x22clojure.test.check.generators/simple-type\x22,892572284,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/simple-type\n */\ncljs.spec.gen.alpha.simple_type \x3d (function cljs$spec$gen$alpha$simple_type(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23252 \x3d arguments.length;\nvar i__5727__auto___23253 \x3d (0);\nwhile(true){\nif((i__5727__auto___23253 \x3c len__5726__auto___23252)){\nargs__5732__auto__.push((arguments[i__5727__auto___23253]));\n\nvar G__23254 \x3d (i__5727__auto___23253 + (1));\ni__5727__auto___23253 \x3d G__23254;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.simple_type.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.simple_type.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23243);\n}));\n\n(cljs.spec.gen.alpha.simple_type.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.simple_type.cljs$lang$applyTo \x3d (function (seq22695){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22695));\n}));\n\n\nvar g__11606__auto___23256 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.simple_type_printable !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.simple_type_printable;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22simple-type-printable\x22,\x22clojure.test.check.generators/simple-type-printable\x22,-58489962,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22simple-type-printable\x22,\x22clojure.test.check.generators/simple-type-printable\x22,-58489962,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/simple-type-printable\n */\ncljs.spec.gen.alpha.simple_type_printable \x3d (function cljs$spec$gen$alpha$simple_type_printable(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23259 \x3d arguments.length;\nvar i__5727__auto___23260 \x3d (0);\nwhile(true){\nif((i__5727__auto___23260 \x3c len__5726__auto___23259)){\nargs__5732__auto__.push((arguments[i__5727__auto___23260]));\n\nvar G__23262 \x3d (i__5727__auto___23260 + (1));\ni__5727__auto___23260 \x3d G__23262;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.simple_type_printable.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.simple_type_printable.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23256);\n}));\n\n(cljs.spec.gen.alpha.simple_type_printable.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.simple_type_printable.cljs$lang$applyTo \x3d (function (seq22728){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22728));\n}));\n\n\nvar g__11606__auto___23266 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.string !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.string;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22string\x22,\x22clojure.test.check.generators/string\x22,-1704750979,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22string\x22,\x22clojure.test.check.generators/string\x22,-1704750979,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/string\n */\ncljs.spec.gen.alpha.string \x3d (function cljs$spec$gen$alpha$string(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23268 \x3d arguments.length;\nvar i__5727__auto___23270 \x3d (0);\nwhile(true){\nif((i__5727__auto___23270 \x3c len__5726__auto___23268)){\nargs__5732__auto__.push((arguments[i__5727__auto___23270]));\n\nvar G__23272 \x3d (i__5727__auto___23270 + (1));\ni__5727__auto___23270 \x3d G__23272;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.string.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.string.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23266);\n}));\n\n(cljs.spec.gen.alpha.string.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.string.cljs$lang$applyTo \x3d (function (seq22739){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22739));\n}));\n\n\nvar g__11606__auto___23274 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.string_ascii !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.string_ascii;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22string-ascii\x22,\x22clojure.test.check.generators/string-ascii\x22,-2009877640,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22string-ascii\x22,\x22clojure.test.check.generators/string-ascii\x22,-2009877640,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/string-ascii\n */\ncljs.spec.gen.alpha.string_ascii \x3d (function cljs$spec$gen$alpha$string_ascii(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23276 \x3d arguments.length;\nvar i__5727__auto___23277 \x3d (0);\nwhile(true){\nif((i__5727__auto___23277 \x3c len__5726__auto___23276)){\nargs__5732__auto__.push((arguments[i__5727__auto___23277]));\n\nvar G__23278 \x3d (i__5727__auto___23277 + (1));\ni__5727__auto___23277 \x3d G__23278;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.string_ascii.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.string_ascii.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23274);\n}));\n\n(cljs.spec.gen.alpha.string_ascii.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.string_ascii.cljs$lang$applyTo \x3d (function (seq22746){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22746));\n}));\n\n\nvar g__11606__auto___23286 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.string_alphanumeric !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.string_alphanumeric;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22string-alphanumeric\x22,\x22clojure.test.check.generators/string-alphanumeric\x22,836374939,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22string-alphanumeric\x22,\x22clojure.test.check.generators/string-alphanumeric\x22,836374939,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/string-alphanumeric\n */\ncljs.spec.gen.alpha.string_alphanumeric \x3d (function cljs$spec$gen$alpha$string_alphanumeric(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23294 \x3d arguments.length;\nvar i__5727__auto___23296 \x3d (0);\nwhile(true){\nif((i__5727__auto___23296 \x3c len__5726__auto___23294)){\nargs__5732__auto__.push((arguments[i__5727__auto___23296]));\n\nvar G__23297 \x3d (i__5727__auto___23296 + (1));\ni__5727__auto___23296 \x3d G__23297;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.string_alphanumeric.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.string_alphanumeric.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23286);\n}));\n\n(cljs.spec.gen.alpha.string_alphanumeric.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.string_alphanumeric.cljs$lang$applyTo \x3d (function (seq22752){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22752));\n}));\n\n\nvar g__11606__auto___23303 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.symbol !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.symbol;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22symbol\x22,\x22clojure.test.check.generators/symbol\x22,-1305461065,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22symbol\x22,\x22clojure.test.check.generators/symbol\x22,-1305461065,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/symbol\n */\ncljs.spec.gen.alpha.symbol \x3d (function cljs$spec$gen$alpha$symbol(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23314 \x3d arguments.length;\nvar i__5727__auto___23315 \x3d (0);\nwhile(true){\nif((i__5727__auto___23315 \x3c len__5726__auto___23314)){\nargs__5732__auto__.push((arguments[i__5727__auto___23315]));\n\nvar G__23316 \x3d (i__5727__auto___23315 + (1));\ni__5727__auto___23315 \x3d G__23316;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.symbol.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.symbol.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23303);\n}));\n\n(cljs.spec.gen.alpha.symbol.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.symbol.cljs$lang$applyTo \x3d (function (seq22755){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22755));\n}));\n\n\nvar g__11606__auto___23317 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.symbol_ns !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.symbol_ns;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22symbol-ns\x22,\x22clojure.test.check.generators/symbol-ns\x22,-862629490,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22symbol-ns\x22,\x22clojure.test.check.generators/symbol-ns\x22,-862629490,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/symbol-ns\n */\ncljs.spec.gen.alpha.symbol_ns \x3d (function cljs$spec$gen$alpha$symbol_ns(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23318 \x3d arguments.length;\nvar i__5727__auto___23319 \x3d (0);\nwhile(true){\nif((i__5727__auto___23319 \x3c len__5726__auto___23318)){\nargs__5732__auto__.push((arguments[i__5727__auto___23319]));\n\nvar G__23320 \x3d (i__5727__auto___23319 + (1));\ni__5727__auto___23319 \x3d G__23320;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.symbol_ns.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.symbol_ns.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23317);\n}));\n\n(cljs.spec.gen.alpha.symbol_ns.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.symbol_ns.cljs$lang$applyTo \x3d (function (seq22763){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22763));\n}));\n\n\nvar g__11606__auto___23325 \x3d (new cljs.spec.gen.alpha.LazyVar((function (){\nif((typeof clojure !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof clojure.test.check.generators.uuid !\x3d\x3d \x27undefined\x27)){\nreturn clojure.test.check.generators.uuid;\n} else {\nthrow (new Error([\x22Var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22uuid\x22,\x22clojure.test.check.generators/uuid\x22,1589373144,null)),\x22 does not exist, \x22,cljs.core.namespace(new cljs.core.Symbol(\x22clojure.test.check.generators\x22,\x22uuid\x22,\x22clojure.test.check.generators/uuid\x22,1589373144,null)),\x22 never required\x22].join(\x27\x27)));\n}\n}),null));\n/**\n * Fn returning clojure.test.check.generators/uuid\n */\ncljs.spec.gen.alpha.uuid \x3d (function cljs$spec$gen$alpha$uuid(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23328 \x3d arguments.length;\nvar i__5727__auto___23330 \x3d (0);\nwhile(true){\nif((i__5727__auto___23330 \x3c len__5726__auto___23328)){\nargs__5732__auto__.push((arguments[i__5727__auto___23330]));\n\nvar G__23332 \x3d (i__5727__auto___23330 + (1));\ni__5727__auto___23330 \x3d G__23332;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.uuid.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.uuid.cljs$core$IFn$_invoke$arity$variadic \x3d (function (args){\nreturn cljs.core.deref(g__11606__auto___23325);\n}));\n\n(cljs.spec.gen.alpha.uuid.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.uuid.cljs$lang$applyTo \x3d (function (seq22770){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22770));\n}));\n\n/**\n * Returns a generator of a sequence catenated from results of\n * gens, each of which should generate something sequential.\n */\ncljs.spec.gen.alpha.cat \x3d (function cljs$spec$gen$alpha$cat(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___23340 \x3d arguments.length;\nvar i__5727__auto___23341 \x3d (0);\nwhile(true){\nif((i__5727__auto___23341 \x3c len__5726__auto___23340)){\nargs__5732__auto__.push((arguments[i__5727__auto___23341]));\n\nvar G__23342 \x3d (i__5727__auto___23341 + (1));\ni__5727__auto___23341 \x3d G__23342;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.gen.alpha.cat.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.gen.alpha.cat.cljs$core$IFn$_invoke$arity$variadic \x3d (function (gens){\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__22773_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,p1__22773_SHARP_);\n}),cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.spec.gen.alpha.tuple,gens)], 0));\n}));\n\n(cljs.spec.gen.alpha.cat.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.gen.alpha.cat.cljs$lang$applyTo \x3d (function (seq22775){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq22775));\n}));\n\ncljs.spec.gen.alpha.qualified_QMARK_ \x3d (function cljs$spec$gen$alpha$qualified_QMARK_(ident){\nreturn (!((cljs.core.namespace(ident) \x3d\x3d null)));\n});\ncljs.spec.gen.alpha.gen_builtins \x3d (new cljs.core.Delay((function (){\nvar simple \x3d cljs.spec.gen.alpha.simple_type_printable();\nreturn cljs.core.PersistentHashMap.fromArrays([cljs.core.qualified_keyword_QMARK_,cljs.core.seq_QMARK_,cljs.core.vector_QMARK_,cljs.core.any_QMARK_,cljs.core.boolean_QMARK_,cljs.core.char_QMARK_,cljs.core.some_QMARK_,cljs.core.inst_QMARK_,cljs.core.simple_symbol_QMARK_,cljs.core.sequential_QMARK_,cljs.core.float_QMARK_,cljs.core.set_QMARK_,cljs.core.map_QMARK_,cljs.core.empty_QMARK_,cljs.core.string_QMARK_,cljs.core.uri_QMARK_,cljs.core.double_QMARK_,cljs.core.int_QMARK_,cljs.core.associative_QMARK_,cljs.core.keyword_QMARK_,cljs.core.indexed_QMARK_,cljs.core.zero_QMARK_,cljs.core.simple_keyword_QMARK_,cljs.core.neg_int_QMARK_,cljs.core.nil_QMARK_,cljs.core.ident_QMARK_,cljs.core.qualified_ident_QMARK_,cljs.core.true_QMARK_,cljs.core.integer_QMARK_,cljs.core.nat_int_QMARK_,cljs.core.pos_int_QMARK_,cljs.core.uuid_QMARK_,cljs.core.false_QMARK_,cljs.core.list_QMARK_,cljs.core.simple_ident_QMARK_,cljs.core.number_QMARK_,cljs.core.qualified_symbol_QMARK_,cljs.core.seqable_QMARK_,cljs.core.symbol_QMARK_,cljs.core.coll_QMARK_],[cljs.spec.gen.alpha.such_that.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.gen.alpha.qualified_QMARK_,cljs.spec.gen.alpha.keyword_ns()], 0)),cljs.spec.gen.alpha.list.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([null], 0)),cljs.spec.gen.alpha.any_printable()], null)], 0)),cljs.spec.gen.alpha.boolean$(),cljs.spec.gen.alpha.char$(),cljs.spec.gen.alpha.such_that.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.some_QMARK_,cljs.spec.gen.alpha.any_printable()], 0)),cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__22786_SHARP_){\nreturn (new Date(p1__22786_SHARP_));\n}),cljs.spec.gen.alpha.large_integer()], 0)),cljs.spec.gen.alpha.symbol(),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.list.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0))], null)], 0)),cljs.spec.gen.alpha.double$(),cljs.spec.gen.alpha.set.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.map.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple,simple], 0)),cljs.spec.gen.alpha.elements.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,cljs.core.List.EMPTY,cljs.core.PersistentVector.EMPTY,cljs.core.PersistentArrayMap.EMPTY,cljs.core.PersistentHashSet.EMPTY], null)], 0)),cljs.spec.gen.alpha.string_alphanumeric(),cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__22785_SHARP_){\nreturn (new goog.Uri([\x22http://\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(p1__22785_SHARP_),\x22.com\x22].join(\x27\x27)));\n}),cljs.spec.gen.alpha.uuid()], 0)),cljs.spec.gen.alpha.double$(),cljs.spec.gen.alpha.large_integer(),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.map.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple,simple], 0)),cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0))], null)], 0)),cljs.spec.gen.alpha.keyword_ns(),cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(0)], 0)),cljs.spec.gen.alpha.keyword(),cljs.spec.gen.alpha.large_integer_STAR_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22max\x22,\x22max\x22,61366548),(-1)], null)], 0)),cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([null], 0)),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.keyword_ns(),cljs.spec.gen.alpha.symbol_ns()], null)], 0)),cljs.spec.gen.alpha.such_that.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.gen.alpha.qualified_QMARK_,cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.keyword_ns(),cljs.spec.gen.alpha.symbol_ns()], null)], 0))], 0)),cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([true], 0)),cljs.spec.gen.alpha.large_integer(),cljs.spec.gen.alpha.large_integer_STAR_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22min\x22,\x22min\x22,444991522),(0)], null)], 0)),cljs.spec.gen.alpha.large_integer_STAR_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22min\x22,\x22min\x22,444991522),(1)], null)], 0)),cljs.spec.gen.alpha.uuid(),cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([false], 0)),cljs.spec.gen.alpha.list.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.keyword(),cljs.spec.gen.alpha.symbol()], null)], 0)),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.large_integer(),cljs.spec.gen.alpha.double$()], null)], 0)),cljs.spec.gen.alpha.such_that.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.gen.alpha.qualified_QMARK_,cljs.spec.gen.alpha.symbol_ns()], 0)),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([null], 0)),cljs.spec.gen.alpha.list.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.map.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple,simple], 0)),cljs.spec.gen.alpha.set.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.string_alphanumeric()], null)], 0)),cljs.spec.gen.alpha.symbol_ns(),cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.gen.alpha.map.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple,simple], 0)),cljs.spec.gen.alpha.list.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0)),cljs.spec.gen.alpha.set.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([simple], 0))], null)], 0))]);\n}),null));\n/**\n * Given a predicate, returns a built-in generator if one exists.\n */\ncljs.spec.gen.alpha.gen_for_pred \x3d (function cljs$spec$gen$alpha$gen_for_pred(pred){\nif(cljs.core.set_QMARK_(pred)){\nreturn cljs.spec.gen.alpha.elements.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([pred], 0));\n} else {\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.spec.gen.alpha.gen_builtins),pred);\n}\n});\n");
SHADOW_ENV.evalLoad("cljs.spec.alpha.js", true, "goog.provide(\x27cljs.spec.alpha\x27);\ngoog.scope(function(){\n  cljs.spec.alpha.goog$module$goog$object \x3d goog.module.get(\x27goog.object\x27);\n});\ncljs.spec.alpha.MAX_INT \x3d (9007199254740991);\n/**\n * A soft limit on how many times a branching spec (or/alt/* /opt-keys/multi-spec)\n *   can be recursed through during generation. After this a\n *   non-recursive branch will be chosen.\n */\ncljs.spec.alpha._STAR_recursion_limit_STAR_ \x3d (4);\n/**\n * The number of times an anonymous fn specified by fspec will be (generatively) tested during conform\n */\ncljs.spec.alpha._STAR_fspec_iterations_STAR_ \x3d (21);\n/**\n * The number of items validated in a collection spec\x27ed with \x27every\x27\n */\ncljs.spec.alpha._STAR_coll_check_limit_STAR_ \x3d (101);\n/**\n * The number of errors reported by explain in a collection spec\x27ed with \x27every\x27\n */\ncljs.spec.alpha._STAR_coll_error_limit_STAR_ \x3d (20);\n\n/**\n * @interface\n */\ncljs.spec.alpha.Spec \x3d function(){};\n\nvar cljs$spec$alpha$Spec$conform_STAR_$dyn_26249 \x3d (function (spec,x){\nvar x__5350__auto__ \x3d (((spec \x3d\x3d null))?null:spec);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.conform_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(spec,x) : m__5351__auto__.call(null, spec,x));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.conform_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(spec,x) : m__5349__auto__.call(null, spec,x));\n} else {\nthrow cljs.core.missing_protocol(\x22Spec.conform*\x22,spec);\n}\n}\n});\ncljs.spec.alpha.conform_STAR_ \x3d (function cljs$spec$alpha$conform_STAR_(spec,x){\nif((((!((spec \x3d\x3d null)))) \x26\x26 ((!((spec.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d\x3d null)))))){\nreturn spec.cljs$spec$alpha$Spec$conform_STAR_$arity$2(spec,x);\n} else {\nreturn cljs$spec$alpha$Spec$conform_STAR_$dyn_26249(spec,x);\n}\n});\n\nvar cljs$spec$alpha$Spec$unform_STAR_$dyn_26252 \x3d (function (spec,y){\nvar x__5350__auto__ \x3d (((spec \x3d\x3d null))?null:spec);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.unform_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(spec,y) : m__5351__auto__.call(null, spec,y));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.unform_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(spec,y) : m__5349__auto__.call(null, spec,y));\n} else {\nthrow cljs.core.missing_protocol(\x22Spec.unform*\x22,spec);\n}\n}\n});\ncljs.spec.alpha.unform_STAR_ \x3d (function cljs$spec$alpha$unform_STAR_(spec,y){\nif((((!((spec \x3d\x3d null)))) \x26\x26 ((!((spec.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d\x3d null)))))){\nreturn spec.cljs$spec$alpha$Spec$unform_STAR_$arity$2(spec,y);\n} else {\nreturn cljs$spec$alpha$Spec$unform_STAR_$dyn_26252(spec,y);\n}\n});\n\nvar cljs$spec$alpha$Spec$explain_STAR_$dyn_26254 \x3d (function (spec,path,via,in$,x){\nvar x__5350__auto__ \x3d (((spec \x3d\x3d null))?null:spec);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.explain_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$5 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$5(spec,path,via,in$,x) : m__5351__auto__.call(null, spec,path,via,in$,x));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.explain_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$5 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$5(spec,path,via,in$,x) : m__5349__auto__.call(null, spec,path,via,in$,x));\n} else {\nthrow cljs.core.missing_protocol(\x22Spec.explain*\x22,spec);\n}\n}\n});\ncljs.spec.alpha.explain_STAR_ \x3d (function cljs$spec$alpha$explain_STAR_(spec,path,via,in$,x){\nif((((!((spec \x3d\x3d null)))) \x26\x26 ((!((spec.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d\x3d null)))))){\nreturn spec.cljs$spec$alpha$Spec$explain_STAR_$arity$5(spec,path,via,in$,x);\n} else {\nreturn cljs$spec$alpha$Spec$explain_STAR_$dyn_26254(spec,path,via,in$,x);\n}\n});\n\nvar cljs$spec$alpha$Spec$gen_STAR_$dyn_26259 \x3d (function (spec,overrides,path,rmap){\nvar x__5350__auto__ \x3d (((spec \x3d\x3d null))?null:spec);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.gen_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$4(spec,overrides,path,rmap) : m__5351__auto__.call(null, spec,overrides,path,rmap));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.gen_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$4(spec,overrides,path,rmap) : m__5349__auto__.call(null, spec,overrides,path,rmap));\n} else {\nthrow cljs.core.missing_protocol(\x22Spec.gen*\x22,spec);\n}\n}\n});\ncljs.spec.alpha.gen_STAR_ \x3d (function cljs$spec$alpha$gen_STAR_(spec,overrides,path,rmap){\nif((((!((spec \x3d\x3d null)))) \x26\x26 ((!((spec.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d\x3d null)))))){\nreturn spec.cljs$spec$alpha$Spec$gen_STAR_$arity$4(spec,overrides,path,rmap);\n} else {\nreturn cljs$spec$alpha$Spec$gen_STAR_$dyn_26259(spec,overrides,path,rmap);\n}\n});\n\nvar cljs$spec$alpha$Spec$with_gen_STAR_$dyn_26263 \x3d (function (spec,gfn){\nvar x__5350__auto__ \x3d (((spec \x3d\x3d null))?null:spec);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.with_gen_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(spec,gfn) : m__5351__auto__.call(null, spec,gfn));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.with_gen_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(spec,gfn) : m__5349__auto__.call(null, spec,gfn));\n} else {\nthrow cljs.core.missing_protocol(\x22Spec.with-gen*\x22,spec);\n}\n}\n});\ncljs.spec.alpha.with_gen_STAR_ \x3d (function cljs$spec$alpha$with_gen_STAR_(spec,gfn){\nif((((!((spec \x3d\x3d null)))) \x26\x26 ((!((spec.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d\x3d null)))))){\nreturn spec.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2(spec,gfn);\n} else {\nreturn cljs$spec$alpha$Spec$with_gen_STAR_$dyn_26263(spec,gfn);\n}\n});\n\nvar cljs$spec$alpha$Spec$describe_STAR_$dyn_26264 \x3d (function (spec){\nvar x__5350__auto__ \x3d (((spec \x3d\x3d null))?null:spec);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.describe_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(spec) : m__5351__auto__.call(null, spec));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.describe_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(spec) : m__5349__auto__.call(null, spec));\n} else {\nthrow cljs.core.missing_protocol(\x22Spec.describe*\x22,spec);\n}\n}\n});\ncljs.spec.alpha.describe_STAR_ \x3d (function cljs$spec$alpha$describe_STAR_(spec){\nif((((!((spec \x3d\x3d null)))) \x26\x26 ((!((spec.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d\x3d null)))))){\nreturn spec.cljs$spec$alpha$Spec$describe_STAR_$arity$1(spec);\n} else {\nreturn cljs$spec$alpha$Spec$describe_STAR_$dyn_26264(spec);\n}\n});\n\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec.alpha !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec.alpha.registry_ref !\x3d\x3d \x27undefined\x27)){\n} else {\ncljs.spec.alpha.registry_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\n}\ncljs.spec.alpha.deep_resolve \x3d (function cljs$spec$alpha$deep_resolve(reg,k){\nvar spec \x3d k;\nwhile(true){\nif(cljs.core.ident_QMARK_(spec)){\nvar G__26283 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(reg,spec);\nspec \x3d G__26283;\ncontinue;\n} else {\nreturn spec;\n}\nbreak;\n}\n});\n/**\n * returns the spec/regex at end of alias chain starting with k, nil if not found, k if k not ident\n */\ncljs.spec.alpha.reg_resolve \x3d (function cljs$spec$alpha$reg_resolve(k){\nif(cljs.core.ident_QMARK_(k)){\nvar reg \x3d cljs.core.deref(cljs.spec.alpha.registry_ref);\nvar spec \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(reg,k);\nif((!(cljs.core.ident_QMARK_(spec)))){\nreturn spec;\n} else {\nreturn cljs.spec.alpha.deep_resolve(reg,spec);\n}\n} else {\nreturn k;\n}\n});\n/**\n * returns the spec/regex at end of alias chain starting with k, throws if not found, k if k not ident\n */\ncljs.spec.alpha.reg_resolve_BANG_ \x3d (function cljs$spec$alpha$reg_resolve_BANG_(k){\nif(cljs.core.ident_QMARK_(k)){\nvar or__5002__auto__ \x3d cljs.spec.alpha.reg_resolve(k);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nthrow (new Error([\x22Unable to resolve spec: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(k)].join(\x27\x27)));\n}\n} else {\nreturn k;\n}\n});\n/**\n * returns x if x is a spec object, else logical false\n */\ncljs.spec.alpha.spec_QMARK_ \x3d (function cljs$spec$alpha$spec_QMARK_(x){\nif((((!((x \x3d\x3d null))))?((((false) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d x.cljs$spec$alpha$Spec$))))?true:false):false)){\nreturn x;\n} else {\nreturn null;\n}\n});\n/**\n * returns x if x is a (cljs.spec.alpha) regex op, else logical false\n */\ncljs.spec.alpha.regex_QMARK_ \x3d (function cljs$spec$alpha$regex_QMARK_(x){\nvar and__5000__auto__ \x3d new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252).cljs$core$IFn$_invoke$arity$1(x);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn x;\n} else {\nreturn and__5000__auto__;\n}\n});\ncljs.spec.alpha.with_name \x3d (function cljs$spec$alpha$with_name(spec,name){\nif(cljs.core.ident_QMARK_(spec)){\nreturn spec;\n} else {\nif(cljs.core.truth_(cljs.spec.alpha.regex_QMARK_(spec))){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(spec,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22name\x22,\x22cljs.spec.alpha/name\x22,205233570),name);\n} else {\nif((((!((spec \x3d\x3d null))))?(((((spec.cljs$lang$protocol_mask$partition0$ \x26 (131072))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d spec.cljs$core$IMeta$))))?true:false):false)){\nreturn cljs.core.with_meta(spec,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.meta(spec),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22name\x22,\x22cljs.spec.alpha/name\x22,205233570),name));\n} else {\nreturn null;\n}\n}\n}\n});\ncljs.spec.alpha.spec_name \x3d (function cljs$spec$alpha$spec_name(spec){\nif(cljs.core.ident_QMARK_(spec)){\nreturn spec;\n} else {\nif(cljs.core.truth_(cljs.spec.alpha.regex_QMARK_(spec))){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22name\x22,\x22cljs.spec.alpha/name\x22,205233570).cljs$core$IFn$_invoke$arity$1(spec);\n} else {\nif((((!((spec \x3d\x3d null))))?(((((spec.cljs$lang$protocol_mask$partition0$ \x26 (131072))) || ((cljs.core.PROTOCOL_SENTINEL \x3d\x3d\x3d spec.cljs$core$IMeta$))))?true:false):false)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22name\x22,\x22cljs.spec.alpha/name\x22,205233570).cljs$core$IFn$_invoke$arity$1(cljs.core.meta(spec));\n} else {\nreturn null;\n}\n}\n}\n});\n/**\n * spec-or-k must be a spec, regex or resolvable kw/sym, else returns nil.\n */\ncljs.spec.alpha.maybe_spec \x3d (function cljs$spec$alpha$maybe_spec(spec_or_k){\nvar s \x3d (function (){var or__5002__auto__ \x3d (function (){var and__5000__auto__ \x3d cljs.core.ident_QMARK_(spec_or_k);\nif(and__5000__auto__){\nreturn cljs.spec.alpha.reg_resolve(spec_or_k);\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d cljs.spec.alpha.spec_QMARK_(spec_or_k);\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nvar or__5002__auto____$2 \x3d cljs.spec.alpha.regex_QMARK_(spec_or_k);\nif(cljs.core.truth_(or__5002__auto____$2)){\nreturn or__5002__auto____$2;\n} else {\nreturn null;\n}\n}\n}\n})();\nif(cljs.core.truth_(cljs.spec.alpha.regex_QMARK_(s))){\nreturn cljs.spec.alpha.with_name(cljs.spec.alpha.regex_spec_impl(s,null),cljs.spec.alpha.spec_name(s));\n} else {\nreturn s;\n}\n});\n/**\n * spec-or-k must be a spec, regex or kw/sym, else returns nil. Throws if unresolvable kw/sym\n */\ncljs.spec.alpha.the_spec \x3d (function cljs$spec$alpha$the_spec(spec_or_k){\nvar or__5002__auto__ \x3d cljs.spec.alpha.maybe_spec(spec_or_k);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nif(cljs.core.ident_QMARK_(spec_or_k)){\nthrow (new Error([\x22Unable to resolve spec: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(spec_or_k)].join(\x27\x27)));\n} else {\nreturn null;\n}\n}\n});\ncljs.spec.alpha.fn_sym \x3d (function cljs$spec$alpha$fn_sym(f_n){\nif(clojure.string.blank_QMARK_(f_n)){\nreturn null;\n} else {\nvar xs \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.demunge,clojure.string.split.cljs$core$IFn$_invoke$arity$2(f_n,\x22$\x22));\nif(((((2) \x3c\x3d cljs.core.count(xs))) \x26\x26 (cljs.core.every_QMARK_((function (p1__23200_SHARP_){\nreturn (!(clojure.string.blank_QMARK_(p1__23200_SHARP_)));\n}),xs)))){\nvar vec__23212 \x3d cljs.core.juxt.cljs$core$IFn$_invoke$arity$2(cljs.core.butlast,cljs.core.last)(xs);\nvar xs__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23212,(0),null);\nvar y \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23212,(1),null);\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([clojure.string.join.cljs$core$IFn$_invoke$arity$2(\x22.\x22,xs__$1),\x22/\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(\x27\x27));\n} else {\nreturn null;\n}\n}\n});\n\n/**\n * @interface\n */\ncljs.spec.alpha.Specize \x3d function(){};\n\nvar cljs$spec$alpha$Specize$specize_STAR_$dyn_26316 \x3d (function() {\nvar G__26317 \x3d null;\nvar G__26317__1 \x3d (function (_){\nvar x__5350__auto__ \x3d (((_ \x3d\x3d null))?null:_);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.specize_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(_) : m__5351__auto__.call(null, _));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.specize_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(_) : m__5349__auto__.call(null, _));\n} else {\nthrow cljs.core.missing_protocol(\x22Specize.specize*\x22,_);\n}\n}\n});\nvar G__26317__2 \x3d (function (_,form){\nvar x__5350__auto__ \x3d (((_ \x3d\x3d null))?null:_);\nvar m__5351__auto__ \x3d (cljs.spec.alpha.specize_STAR_[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(_,form) : m__5351__auto__.call(null, _,form));\n} else {\nvar m__5349__auto__ \x3d (cljs.spec.alpha.specize_STAR_[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(_,form) : m__5349__auto__.call(null, _,form));\n} else {\nthrow cljs.core.missing_protocol(\x22Specize.specize*\x22,_);\n}\n}\n});\nG__26317 \x3d function(_,form){\nswitch(arguments.length){\ncase 1:\nreturn G__26317__1.call(this,_);\ncase 2:\nreturn G__26317__2.call(this,_,form);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26317.cljs$core$IFn$_invoke$arity$1 \x3d G__26317__1;\nG__26317.cljs$core$IFn$_invoke$arity$2 \x3d G__26317__2;\nreturn G__26317;\n})()\n;\ncljs.spec.alpha.specize_STAR_ \x3d (function cljs$spec$alpha$specize_STAR_(var_args){\nvar G__23264 \x3d arguments.length;\nswitch (G__23264) {\ncase 1:\nreturn cljs.spec.alpha.specize_STAR_.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.spec.alpha.specize_STAR_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.specize_STAR_.cljs$core$IFn$_invoke$arity$1 \x3d (function (_){\nif((((!((_ \x3d\x3d null)))) \x26\x26 ((!((_.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d\x3d null)))))){\nreturn _.cljs$spec$alpha$Specize$specize_STAR_$arity$1(_);\n} else {\nreturn cljs$spec$alpha$Specize$specize_STAR_$dyn_26316(_);\n}\n}));\n\n(cljs.spec.alpha.specize_STAR_.cljs$core$IFn$_invoke$arity$2 \x3d (function (_,form){\nif((((!((_ \x3d\x3d null)))) \x26\x26 ((!((_.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d\x3d null)))))){\nreturn _.cljs$spec$alpha$Specize$specize_STAR_$arity$2(_,form);\n} else {\nreturn cljs$spec$alpha$Specize$specize_STAR_$dyn_26316(_,form);\n}\n}));\n\n(cljs.spec.alpha.specize_STAR_.cljs$lang$maxFixedArity \x3d 2);\n\n\n(cljs.core.Keyword.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Keyword.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (k){\nvar k__$1 \x3d this;\nreturn cljs.spec.alpha.specize_STAR_(cljs.spec.alpha.reg_resolve_BANG_(k__$1));\n}));\n\n(cljs.core.Keyword.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (k,_){\nvar k__$1 \x3d this;\nreturn cljs.spec.alpha.specize_STAR_(cljs.spec.alpha.reg_resolve_BANG_(k__$1));\n}));\n\n(cljs.core.Symbol.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.Symbol.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar s__$1 \x3d this;\nreturn cljs.spec.alpha.specize_STAR_(cljs.spec.alpha.reg_resolve_BANG_(s__$1));\n}));\n\n(cljs.core.Symbol.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar s__$1 \x3d this;\nreturn cljs.spec.alpha.specize_STAR_(cljs.spec.alpha.reg_resolve_BANG_(s__$1));\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentHashSet.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar s__$1 \x3d this;\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(s__$1,s__$1,null,null);\n}));\n\n(cljs.core.PersistentHashSet.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,form){\nvar s__$1 \x3d this;\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(form,s__$1,null,null);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.core.PersistentTreeSet.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar s__$1 \x3d this;\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(s__$1,s__$1,null,null);\n}));\n\n(cljs.core.PersistentTreeSet.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,form){\nvar s__$1 \x3d this;\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(form,s__$1,null,null);\n}));\n\n(cljs.spec.alpha.Specize[\x22_\x22] \x3d true);\n\n(cljs.spec.alpha.specize_STAR_[\x22_\x22] \x3d (function() {\nvar G__26332 \x3d null;\nvar G__26332__1 \x3d (function (o){\nvar temp__5802__auto__ \x3d (function (){var and__5000__auto__ \x3d cljs.core.fn_QMARK_(o);\nif(and__5000__auto__){\nreturn cljs.spec.alpha.fn_sym(o.name);\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.truth_(temp__5802__auto__)){\nvar f_n \x3d temp__5802__auto__;\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(f_n,o,null,null);\n} else {\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22unknown\x22,\x22cljs.spec.alpha/unknown\x22,651034818),o,null,null);\n}\n});\nvar G__26332__2 \x3d (function (o,form){\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(form,o,null,null);\n});\nG__26332 \x3d function(o,form){\nswitch(arguments.length){\ncase 1:\nreturn G__26332__1.call(this,o);\ncase 2:\nreturn G__26332__2.call(this,o,form);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nG__26332.cljs$core$IFn$_invoke$arity$1 \x3d G__26332__1;\nG__26332.cljs$core$IFn$_invoke$arity$2 \x3d G__26332__2;\nreturn G__26332;\n})()\n);\ncljs.spec.alpha.specize \x3d (function cljs$spec$alpha$specize(var_args){\nvar G__23347 \x3d arguments.length;\nswitch (G__23347) {\ncase 1:\nreturn cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1 \x3d (function (s){\nvar or__5002__auto__ \x3d cljs.spec.alpha.spec_QMARK_(s);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.spec.alpha.specize_STAR_(s);\n}\n}));\n\n(cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$2 \x3d (function (s,form){\nvar or__5002__auto__ \x3d cljs.spec.alpha.spec_QMARK_(s);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.spec.alpha.specize_STAR_(s,form);\n}\n}));\n\n(cljs.spec.alpha.specize.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * tests the validity of a conform return value\n */\ncljs.spec.alpha.invalid_QMARK_ \x3d (function cljs$spec$alpha$invalid_QMARK_(ret){\nreturn cljs.core.keyword_identical_QMARK_(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119),ret);\n});\n/**\n * Given a spec and a value, returns :cljs.spec.alpha/invalid if value does\n *   not match spec, else the (possibly destructured) value.\n */\ncljs.spec.alpha.conform \x3d (function cljs$spec$alpha$conform(spec,x){\nreturn cljs.spec.alpha.conform_STAR_(cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec),x);\n});\n/**\n * Given a spec and a value created by or compliant with a call to\n *   \x27conform\x27 with the same spec, returns a value with all conform\n * destructuring undone.\n */\ncljs.spec.alpha.unform \x3d (function cljs$spec$alpha$unform(spec,x){\nreturn cljs.spec.alpha.unform_STAR_(cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec),x);\n});\n/**\n * returns the spec as data\n */\ncljs.spec.alpha.form \x3d (function cljs$spec$alpha$form(spec){\nreturn cljs.spec.alpha.describe_STAR_(cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec));\n});\ncljs.spec.alpha.abbrev \x3d (function cljs$spec$alpha$abbrev(form){\nif(cljs.core.seq_QMARK_(form)){\nreturn clojure.walk.postwalk((function (form__$1){\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d (form__$1 instanceof cljs.core.Symbol);\nif(and__5000__auto__){\nreturn cljs.core.namespace(form__$1);\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.name(form__$1));\n} else {\nif(((cljs.core.seq_QMARK_(form__$1)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Symbol(null,\x22fn\x22,\x22fn\x22,465265323,null),cljs.core.first(form__$1))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null)], null),cljs.core.second(form__$1))))))){\nreturn cljs.core.last(form__$1);\n} else {\nreturn form__$1;\n\n}\n}\n}),form);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d (form instanceof cljs.core.Symbol);\nif(and__5000__auto__){\nreturn cljs.core.namespace(form);\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.name(form));\n} else {\nreturn form;\n\n}\n}\n});\n/**\n * returns an abbreviated description of the spec as data\n */\ncljs.spec.alpha.describe \x3d (function cljs$spec$alpha$describe(spec){\nreturn cljs.spec.alpha.abbrev(cljs.spec.alpha.form(spec));\n});\n/**\n * Takes a spec and a no-arg, generator-returning fn and returns a version of that spec that uses that generator\n */\ncljs.spec.alpha.with_gen \x3d (function cljs$spec$alpha$with_gen(spec,gen_fn){\nvar spec__$1 \x3d cljs.spec.alpha.reg_resolve(spec);\nif(cljs.core.truth_(cljs.spec.alpha.regex_QMARK_(spec__$1))){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(spec__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22gfn\x22,\x22cljs.spec.alpha/gfn\x22,-593120375),gen_fn);\n} else {\nreturn cljs.spec.alpha.with_gen_STAR_(cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec__$1),gen_fn);\n}\n});\ncljs.spec.alpha.explain_data_STAR_ \x3d (function cljs$spec$alpha$explain_data_STAR_(spec,path,via,in$,x){\nvar temp__5804__auto__ \x3d cljs.spec.alpha.explain_STAR_(cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec),path,via,in$,x);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar probs \x3d temp__5804__auto__;\nif(cljs.core.empty_QMARK_(probs)){\nreturn null;\n} else {\nreturn new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22problems\x22,\x22cljs.spec.alpha/problems\x22,447400814),probs,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22spec\x22,\x22cljs.spec.alpha/spec\x22,1947137578),spec,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22value\x22,\x22cljs.spec.alpha/value\x22,1974786274),x], null);\n}\n} else {\nreturn null;\n}\n});\n/**\n * Given a spec and a value x which ought to conform, returns nil if x\n *   conforms, else a map with at least the key ::problems whose value is\n *   a collection of problem-maps, where problem-map has at least :path :pred and :val\n *   keys describing the predicate and the value that failed at that\n *   path.\n */\ncljs.spec.alpha.explain_data \x3d (function cljs$spec$alpha$explain_data(spec,x){\nreturn cljs.spec.alpha.explain_data_STAR_(spec,cljs.core.PersistentVector.EMPTY,(function (){var temp__5802__auto__ \x3d cljs.spec.alpha.spec_name(spec);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar name \x3d temp__5802__auto__;\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [name], null);\n} else {\nreturn cljs.core.PersistentVector.EMPTY;\n}\n})(),cljs.core.PersistentVector.EMPTY,x);\n});\n/**\n * Default printer for explain-data. nil indicates a successful validation.\n */\ncljs.spec.alpha.explain_printer \x3d (function cljs$spec$alpha$explain_printer(ed){\nif(cljs.core.truth_(ed)){\nvar problems \x3d cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2((function (p1__23426_SHARP_){\nreturn (- cljs.core.count(new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168).cljs$core$IFn$_invoke$arity$1(p1__23426_SHARP_)));\n}),cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2((function (p1__23425_SHARP_){\nreturn (- cljs.core.count(new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865).cljs$core$IFn$_invoke$arity$1(p1__23425_SHARP_)));\n}),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22problems\x22,\x22cljs.spec.alpha/problems\x22,447400814).cljs$core$IFn$_invoke$arity$1(ed)));\nreturn cljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var sb__5647__auto__ \x3d (new goog.string.StringBuffer());\nvar _STAR_print_newline_STAR__orig_val__23434_26357 \x3d cljs.core._STAR_print_newline_STAR_;\nvar _STAR_print_fn_STAR__orig_val__23435_26358 \x3d cljs.core._STAR_print_fn_STAR_;\nvar _STAR_print_newline_STAR__temp_val__23436_26359 \x3d true;\nvar _STAR_print_fn_STAR__temp_val__23437_26361 \x3d (function (x__5648__auto__){\nreturn sb__5647__auto__.append(x__5648__auto__);\n});\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__temp_val__23436_26359);\n\n(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__temp_val__23437_26361);\n\ntry{var seq__23442_26363 \x3d cljs.core.seq(problems);\nvar chunk__23443_26364 \x3d null;\nvar count__23444_26365 \x3d (0);\nvar i__23445_26366 \x3d (0);\nwhile(true){\nif((i__23445_26366 \x3c count__23444_26365)){\nvar map__23554_26373 \x3d chunk__23443_26364.cljs$core$IIndexed$_nth$arity$2(null, i__23445_26366);\nvar map__23554_26374__$1 \x3d cljs.core.__destructure_map(map__23554_26373);\nvar prob_26375 \x3d map__23554_26374__$1;\nvar path_26376 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23554_26374__$1,new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168));\nvar pred_26377 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23554_26374__$1,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397));\nvar val_26378 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23554_26374__$1,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612));\nvar reason_26379 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23554_26374__$1,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759));\nvar via_26380 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23554_26374__$1,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336));\nvar in_26381 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23554_26374__$1,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865));\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([val_26378], 0));\n\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 - failed: \x22], 0));\n\nif(cljs.core.truth_(reason_26379)){\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([reason_26379], 0));\n} else {\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.alpha.abbrev(pred_26377)], 0));\n}\n\nif(cljs.core.empty_QMARK_(in_26381)){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22 in: \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([in_26381], 0))].join(\x27\x27)], 0));\n}\n\nif(cljs.core.empty_QMARK_(path_26376)){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22 at: \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([path_26376], 0))].join(\x27\x27)], 0));\n}\n\nif(cljs.core.empty_QMARK_(via_26380)){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22 spec: \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.last(via_26380)], 0))].join(\x27\x27)], 0));\n}\n\nvar seq__23574_26388 \x3d cljs.core.seq(prob_26375);\nvar chunk__23575_26389 \x3d null;\nvar count__23576_26390 \x3d (0);\nvar i__23577_26391 \x3d (0);\nwhile(true){\nif((i__23577_26391 \x3c count__23576_26390)){\nvar vec__23632_26392 \x3d chunk__23575_26389.cljs$core$IIndexed$_nth$arity$2(null, i__23577_26391);\nvar k_26393 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23632_26392,(0),null);\nvar v_26394 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23632_26392,(1),null);\nif(cljs.core.truth_((function (){var fexpr__23639 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),null,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),null,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),null,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),null,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),null,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),null], null), null);\nreturn (fexpr__23639.cljs$core$IFn$_invoke$arity$1 ? fexpr__23639.cljs$core$IFn$_invoke$arity$1(k_26393) : fexpr__23639.call(null, k_26393));\n})())){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22\\n\\t\x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([k_26393], 0)),\x22 \x22], 0));\n\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([v_26394], 0));\n}\n\n\nvar G__26401 \x3d seq__23574_26388;\nvar G__26402 \x3d chunk__23575_26389;\nvar G__26403 \x3d count__23576_26390;\nvar G__26404 \x3d (i__23577_26391 + (1));\nseq__23574_26388 \x3d G__26401;\nchunk__23575_26389 \x3d G__26402;\ncount__23576_26390 \x3d G__26403;\ni__23577_26391 \x3d G__26404;\ncontinue;\n} else {\nvar temp__5804__auto___26405 \x3d cljs.core.seq(seq__23574_26388);\nif(temp__5804__auto___26405){\nvar seq__23574_26406__$1 \x3d temp__5804__auto___26405;\nif(cljs.core.chunked_seq_QMARK_(seq__23574_26406__$1)){\nvar c__5525__auto___26407 \x3d cljs.core.chunk_first(seq__23574_26406__$1);\nvar G__26408 \x3d cljs.core.chunk_rest(seq__23574_26406__$1);\nvar G__26409 \x3d c__5525__auto___26407;\nvar G__26410 \x3d cljs.core.count(c__5525__auto___26407);\nvar G__26411 \x3d (0);\nseq__23574_26388 \x3d G__26408;\nchunk__23575_26389 \x3d G__26409;\ncount__23576_26390 \x3d G__26410;\ni__23577_26391 \x3d G__26411;\ncontinue;\n} else {\nvar vec__23653_26412 \x3d cljs.core.first(seq__23574_26406__$1);\nvar k_26413 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23653_26412,(0),null);\nvar v_26414 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23653_26412,(1),null);\nif(cljs.core.truth_((function (){var fexpr__23661 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),null,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),null,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),null,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),null,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),null,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),null], null), null);\nreturn (fexpr__23661.cljs$core$IFn$_invoke$arity$1 ? fexpr__23661.cljs$core$IFn$_invoke$arity$1(k_26413) : fexpr__23661.call(null, k_26413));\n})())){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22\\n\\t\x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([k_26413], 0)),\x22 \x22], 0));\n\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([v_26414], 0));\n}\n\n\nvar G__26416 \x3d cljs.core.next(seq__23574_26406__$1);\nvar G__26417 \x3d null;\nvar G__26418 \x3d (0);\nvar G__26419 \x3d (0);\nseq__23574_26388 \x3d G__26416;\nchunk__23575_26389 \x3d G__26417;\ncount__23576_26390 \x3d G__26418;\ni__23577_26391 \x3d G__26419;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\ncljs.core.newline.cljs$core$IFn$_invoke$arity$0();\n\n\nvar G__26421 \x3d seq__23442_26363;\nvar G__26422 \x3d chunk__23443_26364;\nvar G__26423 \x3d count__23444_26365;\nvar G__26424 \x3d (i__23445_26366 + (1));\nseq__23442_26363 \x3d G__26421;\nchunk__23443_26364 \x3d G__26422;\ncount__23444_26365 \x3d G__26423;\ni__23445_26366 \x3d G__26424;\ncontinue;\n} else {\nvar temp__5804__auto___26425 \x3d cljs.core.seq(seq__23442_26363);\nif(temp__5804__auto___26425){\nvar seq__23442_26426__$1 \x3d temp__5804__auto___26425;\nif(cljs.core.chunked_seq_QMARK_(seq__23442_26426__$1)){\nvar c__5525__auto___26427 \x3d cljs.core.chunk_first(seq__23442_26426__$1);\nvar G__26428 \x3d cljs.core.chunk_rest(seq__23442_26426__$1);\nvar G__26429 \x3d c__5525__auto___26427;\nvar G__26430 \x3d cljs.core.count(c__5525__auto___26427);\nvar G__26431 \x3d (0);\nseq__23442_26363 \x3d G__26428;\nchunk__23443_26364 \x3d G__26429;\ncount__23444_26365 \x3d G__26430;\ni__23445_26366 \x3d G__26431;\ncontinue;\n} else {\nvar map__23675_26432 \x3d cljs.core.first(seq__23442_26426__$1);\nvar map__23675_26433__$1 \x3d cljs.core.__destructure_map(map__23675_26432);\nvar prob_26434 \x3d map__23675_26433__$1;\nvar path_26435 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23675_26433__$1,new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168));\nvar pred_26436 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23675_26433__$1,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397));\nvar val_26437 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23675_26433__$1,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612));\nvar reason_26438 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23675_26433__$1,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759));\nvar via_26439 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23675_26433__$1,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336));\nvar in_26440 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__23675_26433__$1,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865));\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([val_26437], 0));\n\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 - failed: \x22], 0));\n\nif(cljs.core.truth_(reason_26438)){\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([reason_26438], 0));\n} else {\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.alpha.abbrev(pred_26436)], 0));\n}\n\nif(cljs.core.empty_QMARK_(in_26440)){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22 in: \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([in_26440], 0))].join(\x27\x27)], 0));\n}\n\nif(cljs.core.empty_QMARK_(path_26435)){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22 at: \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([path_26435], 0))].join(\x27\x27)], 0));\n}\n\nif(cljs.core.empty_QMARK_(via_26439)){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22 spec: \x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.last(via_26439)], 0))].join(\x27\x27)], 0));\n}\n\nvar seq__23686_26447 \x3d cljs.core.seq(prob_26434);\nvar chunk__23687_26448 \x3d null;\nvar count__23688_26449 \x3d (0);\nvar i__23689_26450 \x3d (0);\nwhile(true){\nif((i__23689_26450 \x3c count__23688_26449)){\nvar vec__23711_26451 \x3d chunk__23687_26448.cljs$core$IIndexed$_nth$arity$2(null, i__23689_26450);\nvar k_26452 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23711_26451,(0),null);\nvar v_26453 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23711_26451,(1),null);\nif(cljs.core.truth_((function (){var fexpr__23715 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),null,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),null,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),null,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),null,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),null,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),null], null), null);\nreturn (fexpr__23715.cljs$core$IFn$_invoke$arity$1 ? fexpr__23715.cljs$core$IFn$_invoke$arity$1(k_26452) : fexpr__23715.call(null, k_26452));\n})())){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22\\n\\t\x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([k_26452], 0)),\x22 \x22], 0));\n\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([v_26453], 0));\n}\n\n\nvar G__26458 \x3d seq__23686_26447;\nvar G__26459 \x3d chunk__23687_26448;\nvar G__26460 \x3d count__23688_26449;\nvar G__26461 \x3d (i__23689_26450 + (1));\nseq__23686_26447 \x3d G__26458;\nchunk__23687_26448 \x3d G__26459;\ncount__23688_26449 \x3d G__26460;\ni__23689_26450 \x3d G__26461;\ncontinue;\n} else {\nvar temp__5804__auto___26462__$1 \x3d cljs.core.seq(seq__23686_26447);\nif(temp__5804__auto___26462__$1){\nvar seq__23686_26465__$1 \x3d temp__5804__auto___26462__$1;\nif(cljs.core.chunked_seq_QMARK_(seq__23686_26465__$1)){\nvar c__5525__auto___26467 \x3d cljs.core.chunk_first(seq__23686_26465__$1);\nvar G__26470 \x3d cljs.core.chunk_rest(seq__23686_26465__$1);\nvar G__26471 \x3d c__5525__auto___26467;\nvar G__26472 \x3d cljs.core.count(c__5525__auto___26467);\nvar G__26473 \x3d (0);\nseq__23686_26447 \x3d G__26470;\nchunk__23687_26448 \x3d G__26471;\ncount__23688_26449 \x3d G__26472;\ni__23689_26450 \x3d G__26473;\ncontinue;\n} else {\nvar vec__23721_26475 \x3d cljs.core.first(seq__23686_26465__$1);\nvar k_26476 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23721_26475,(0),null);\nvar v_26477 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__23721_26475,(1),null);\nif(cljs.core.truth_((function (){var fexpr__23726 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),null,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),null,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),null,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),null,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),null,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),null], null), null);\nreturn (fexpr__23726.cljs$core$IFn$_invoke$arity$1 ? fexpr__23726.cljs$core$IFn$_invoke$arity$1(k_26476) : fexpr__23726.call(null, k_26476));\n})())){\n} else {\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22\\n\\t\x22,cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([k_26476], 0)),\x22 \x22], 0));\n\ncljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([v_26477], 0));\n}\n\n\nvar G__26494 \x3d cljs.core.next(seq__23686_26465__$1);\nvar G__26495 \x3d null;\nvar G__26496 \x3d (0);\nvar G__26497 \x3d (0);\nseq__23686_26447 \x3d G__26494;\nchunk__23687_26448 \x3d G__26495;\ncount__23688_26449 \x3d G__26496;\ni__23689_26450 \x3d G__26497;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\ncljs.core.newline.cljs$core$IFn$_invoke$arity$0();\n\n\nvar G__26501 \x3d cljs.core.next(seq__23442_26426__$1);\nvar G__26502 \x3d null;\nvar G__26503 \x3d (0);\nvar G__26504 \x3d (0);\nseq__23442_26363 \x3d G__26501;\nchunk__23443_26364 \x3d G__26502;\ncount__23444_26365 \x3d G__26503;\ni__23445_26366 \x3d G__26504;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n}finally {(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__orig_val__23435_26358);\n\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__orig_val__23434_26357);\n}\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb__5647__auto__);\n})()], 0));\n} else {\nreturn cljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22Success!\x22], 0));\n}\n});\ncljs.spec.alpha._STAR_explain_out_STAR_ \x3d cljs.spec.alpha.explain_printer;\n/**\n * Prints explanation data (per \x27explain-data\x27) to *out* using the printer in *explain-out*,\n *  by default explain-printer.\n */\ncljs.spec.alpha.explain_out \x3d (function cljs$spec$alpha$explain_out(ed){\nreturn cljs.spec.alpha._STAR_explain_out_STAR_.call(null, ed);\n});\n/**\n * Given a spec and a value that fails to conform, prints an explanation to *out*.\n */\ncljs.spec.alpha.explain \x3d (function cljs$spec$alpha$explain(spec,x){\nreturn cljs.spec.alpha.explain_out(cljs.spec.alpha.explain_data(spec,x));\n});\n/**\n * Given a spec and a value that fails to conform, returns an explanation as a string.\n */\ncljs.spec.alpha.explain_str \x3d (function cljs$spec$alpha$explain_str(spec,x){\nvar sb__5647__auto__ \x3d (new goog.string.StringBuffer());\nvar _STAR_print_newline_STAR__orig_val__23749_26531 \x3d cljs.core._STAR_print_newline_STAR_;\nvar _STAR_print_fn_STAR__orig_val__23750_26532 \x3d cljs.core._STAR_print_fn_STAR_;\nvar _STAR_print_newline_STAR__temp_val__23752_26533 \x3d true;\nvar _STAR_print_fn_STAR__temp_val__23753_26534 \x3d (function (x__5648__auto__){\nreturn sb__5647__auto__.append(x__5648__auto__);\n});\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__temp_val__23752_26533);\n\n(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__temp_val__23753_26534);\n\ntry{cljs.spec.alpha.explain(spec,x);\n}finally {(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__orig_val__23750_26532);\n\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__orig_val__23749_26531);\n}\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb__5647__auto__);\n});\ncljs.spec.alpha.gensub \x3d (function cljs$spec$alpha$gensub(spec,overrides,path,rmap,form){\nvar spec__$1 \x3d cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec);\nvar temp__5802__auto__ \x3d (function (){var or__5002__auto__ \x3d (function (){var temp__5804__auto__ \x3d (function (){var or__5002__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(overrides,(function (){var or__5002__auto__ \x3d cljs.spec.alpha.spec_name(spec__$1);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn spec__$1;\n}\n})());\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(overrides,path);\n}\n})();\nif(cljs.core.truth_(temp__5804__auto__)){\nvar gfn \x3d temp__5804__auto__;\nreturn (gfn.cljs$core$IFn$_invoke$arity$0 ? gfn.cljs$core$IFn$_invoke$arity$0() : gfn.call(null, ));\n} else {\nreturn null;\n}\n})();\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.spec.alpha.gen_STAR_(spec__$1,overrides,path,rmap);\n}\n})();\nif(cljs.core.truth_(temp__5802__auto__)){\nvar g \x3d temp__5802__auto__;\nreturn cljs.spec.gen.alpha.such_that.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__23786_SHARP_){\nreturn cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$2(spec__$1,p1__23786_SHARP_);\n}),g,(100)], 0));\n} else {\nthrow (new Error([\x22Unable to construct gen at: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(path),\x22 for: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.spec.alpha.abbrev(form))].join(\x27\x27)));\n}\n});\n/**\n * Given a spec, returns the generator for it, or throws if none can\n *   be constructed. Optionally an overrides map can be provided which\n *   should map spec names or paths (vectors of keywords) to no-arg\n *   generator-creating fns. These will be used instead of the generators at those\n *   names/paths. Note that parent generator (in the spec or overrides\n *   map) will supersede those of any subtrees. A generator for a regex\n *   op must always return a sequential collection (i.e. a generator for\n *   s/? should return either an empty sequence/vector or a\n *   sequence/vector with one item in it)\n */\ncljs.spec.alpha.gen \x3d (function cljs$spec$alpha$gen(var_args){\nvar G__23859 \x3d arguments.length;\nswitch (G__23859) {\ncase 1:\nreturn cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$1 \x3d (function (spec){\nreturn cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$2(spec,null);\n}));\n\n(cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$2 \x3d (function (spec,overrides){\nreturn cljs.spec.alpha.gensub(spec,overrides,cljs.core.PersistentVector.EMPTY,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22recursion-limit\x22,\x22cljs.spec.alpha/recursion-limit\x22,601284994),cljs.spec.alpha._STAR_recursion_limit_STAR_], null),spec);\n}));\n\n(cljs.spec.alpha.gen.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * Do not call this directly, use \x27def\x27\n */\ncljs.spec.alpha.def_impl \x3d (function cljs$spec$alpha$def_impl(k,form,spec){\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.ident_QMARK_(k);\nif(and__5000__auto__){\nreturn cljs.core.namespace(k);\n} else {\nreturn and__5000__auto__;\n}\n})())){\n} else {\nthrow (new Error([\x22Assert failed: \x22,\x22k must be namespaced keyword or resolveable symbol\x22,\x22\\n\x22,\x22(c/and (ident? k) (namespace k))\x22].join(\x27\x27)));\n}\n\nif((spec \x3d\x3d null)){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.registry_ref,cljs.core.dissoc,k);\n} else {\nvar spec_26546__$1 \x3d (cljs.core.truth_((function (){var or__5002__auto__ \x3d cljs.spec.alpha.spec_QMARK_(spec);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d cljs.spec.alpha.regex_QMARK_(spec);\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.spec.alpha.registry_ref),spec);\n}\n}\n})())?spec:cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4(form,spec,null,null));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.spec.alpha.registry_ref,cljs.core.assoc,k,cljs.spec.alpha.with_name(spec_26546__$1,k));\n}\n\nreturn k;\n});\n/**\n * returns the registry map, prefer \x27get-spec\x27 to lookup a spec by name\n */\ncljs.spec.alpha.registry \x3d (function cljs$spec$alpha$registry(){\nreturn cljs.core.deref(cljs.spec.alpha.registry_ref);\n});\n/**\n * Returns a symbol from a symbol or var\n */\ncljs.spec.alpha.__GT_sym \x3d (function cljs$spec$alpha$__GT_sym(x){\nif(cljs.core.var_QMARK_(x)){\nreturn x.sym;\n} else {\nreturn x;\n}\n});\n/**\n * Returns spec registered for keyword/symbol/var k, or nil.\n */\ncljs.spec.alpha.get_spec \x3d (function cljs$spec$alpha$get_spec(k){\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.spec.alpha.registry(),(((k instanceof cljs.core.Keyword))?k:cljs.spec.alpha.__GT_sym(k)));\n});\ncljs.spec.alpha.macroexpand_check \x3d (function cljs$spec$alpha$macroexpand_check(v,args){\nvar specs \x3d cljs.spec.alpha.get_spec(v);\nvar temp__5804__auto__ \x3d new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576).cljs$core$IFn$_invoke$arity$1(specs);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar arg_spec \x3d temp__5804__auto__;\nif(cljs.spec.alpha.invalid_QMARK_(cljs.spec.alpha.conform(arg_spec,args))){\nvar ed \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.explain_data_STAR_(arg_spec,cljs.core.PersistentVector.EMPTY,(function (){var temp__5802__auto__ \x3d cljs.spec.alpha.spec_name(arg_spec);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar name \x3d temp__5802__auto__;\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [name], null);\n} else {\nreturn cljs.core.PersistentVector.EMPTY;\n}\n})(),cljs.core.PersistentVector.EMPTY,args),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22args\x22,\x22cljs.spec.alpha/args\x22,1870769783),args);\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2([\x22Call to \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.spec.alpha.__GT_sym(v)),\x22 did not conform to spec.\x22].join(\x27\x27),ed);\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n});\ncljs.spec.alpha.recur_limit_QMARK_ \x3d (function cljs$spec$alpha$recur_limit_QMARK_(rmap,id,path,k){\nreturn (((cljs.core.get.cljs$core$IFn$_invoke$arity$2(rmap,id) \x3e new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22recursion-limit\x22,\x22cljs.spec.alpha/recursion-limit\x22,601284994).cljs$core$IFn$_invoke$arity$1(rmap))) \x26\x26 (cljs.core.contains_QMARK_(cljs.core.set(path),k)));\n});\ncljs.spec.alpha.inck \x3d (function cljs$spec$alpha$inck(m,k){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,((function (){var or__5002__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (0);\n}\n})() + (1)));\n});\ncljs.spec.alpha.dt \x3d (function cljs$spec$alpha$dt(var_args){\nvar G__23949 \x3d arguments.length;\nswitch (G__23949) {\ncase 3:\nreturn cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3 \x3d (function (pred,x,form){\nreturn cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$4(pred,x,form,null);\n}));\n\n(cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$4 \x3d (function (pred,x,form,cpred_QMARK_){\nif(cljs.core.truth_(pred)){\nvar temp__5802__auto__ \x3d cljs.spec.alpha.the_spec(pred);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar spec \x3d temp__5802__auto__;\nreturn cljs.spec.alpha.conform(spec,x);\n} else {\nif(cljs.core.ifn_QMARK_(pred)){\nif(cljs.core.truth_(cpred_QMARK_)){\nreturn (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x));\n} else {\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x)))){\nreturn x;\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}\n} else {\nthrow (new Error([cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([form], 0)),\x22 is not a fn, expected predicate fn\x22].join(\x27\x27)));\n}\n}\n} else {\nreturn x;\n}\n}));\n\n(cljs.spec.alpha.dt.cljs$lang$maxFixedArity \x3d 4);\n\n/**\n * Helper function that returns true when x is valid for spec.\n */\ncljs.spec.alpha.valid_QMARK_ \x3d (function cljs$spec$alpha$valid_QMARK_(var_args){\nvar G__23980 \x3d arguments.length;\nswitch (G__23980) {\ncase 2:\nreturn cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$2 \x3d (function (spec,x){\nvar spec__$1 \x3d cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec);\nreturn (!(cljs.spec.alpha.invalid_QMARK_(cljs.spec.alpha.conform_STAR_(spec__$1,x))));\n}));\n\n(cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$3 \x3d (function (spec,x,form){\nvar spec__$1 \x3d cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$2(spec,form);\nreturn (!(cljs.spec.alpha.invalid_QMARK_(cljs.spec.alpha.conform_STAR_(spec__$1,x))));\n}));\n\n(cljs.spec.alpha.valid_QMARK_.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * internal helper function that returns true when x is valid for spec.\n */\ncljs.spec.alpha.pvalid_QMARK_ \x3d (function cljs$spec$alpha$pvalid_QMARK_(var_args){\nvar G__24009 \x3d arguments.length;\nswitch (G__24009) {\ncase 2:\nreturn cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2 \x3d (function (pred,x){\nreturn (!(cljs.spec.alpha.invalid_QMARK_(cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(pred,x,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22unknown\x22,\x22cljs.spec.alpha/unknown\x22,651034818)))));\n}));\n\n(cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$3 \x3d (function (pred,x,form){\nreturn (!(cljs.spec.alpha.invalid_QMARK_(cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(pred,x,form))));\n}));\n\n(cljs.spec.alpha.pvalid_QMARK_.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.spec.alpha.explain_1 \x3d (function cljs$spec$alpha$explain_1(form,pred,path,via,in$,v){\nvar pred__$1 \x3d cljs.spec.alpha.maybe_spec(pred);\nif(cljs.core.truth_(cljs.spec.alpha.spec_QMARK_(pred__$1))){\nreturn cljs.spec.alpha.explain_STAR_(pred__$1,path,(function (){var temp__5802__auto__ \x3d cljs.spec.alpha.spec_name(pred__$1);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar name \x3d temp__5802__auto__;\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(via,name);\n} else {\nreturn via;\n}\n})(),in$,v);\n} else {\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),form,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),v,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n}\n});\n\n/**\n * returns a generator for form f, which can be a keyword or a list\n *   starting with \x27or or \x27and.\n */\ncljs.spec.alpha.k_gen \x3d (function cljs$spec$alpha$k_gen(f){\nif((f instanceof cljs.core.Keyword)){\nreturn cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([f], 0));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Symbol(null,\x22or\x22,\x22or\x22,1876275696,null),cljs.core.first(f))){\nreturn cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$2((1),cljs.core.rest(f));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Symbol(null,\x22and\x22,\x22and\x22,668631710,null),cljs.core.first(f))){\nreturn cljs.spec.alpha.and_k_gen(cljs.core.rest(f));\n} else {\nreturn null;\n}\n}\n}\n});\n/**\n * returns a tuple generator made up of generators for a random subset\n *   of min-count (default 0) to all elements in s.\n */\ncljs.spec.alpha.or_k_gen \x3d (function cljs$spec$alpha$or_k_gen(var_args){\nvar G__24054 \x3d arguments.length;\nswitch (G__24054) {\ncase 1:\nreturn cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$1 \x3d (function (s){\nreturn cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$2((0),s);\n}));\n\n(cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$2 \x3d (function (min_count,s){\nreturn cljs.spec.gen.alpha.bind.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.gen.alpha.tuple.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.gen.alpha.choose.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([min_count,cljs.core.count(s)], 0)),cljs.spec.gen.alpha.shuffle.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.spec.alpha.k_gen,s)], 0))], 0)),(function (p__24061){\nvar vec__24063 \x3d p__24061;\nvar n \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24063,(0),null);\nvar gens \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24063,(1),null);\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.spec.gen.alpha.tuple,cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,gens));\n})], 0));\n}));\n\n(cljs.spec.alpha.or_k_gen.cljs$lang$maxFixedArity \x3d 2);\n\n/**\n * returns a tuple generator made up of generators for every element\n *   in s.\n */\ncljs.spec.alpha.and_k_gen \x3d (function cljs$spec$alpha$and_k_gen(s){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.spec.gen.alpha.tuple,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.spec.alpha.k_gen,s));\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha24087 \x3d (function (p__24079,keys__GT_specnames,opt,req_un,opt_un,gfn,pred_exprs,keys_pred,argm,opt_keys,req_specs,map__24081,req,id,req_keys,opt_specs,k__GT_s,pred_forms,meta24088){\nthis.p__24079 \x3d p__24079;\nthis.keys__GT_specnames \x3d keys__GT_specnames;\nthis.opt \x3d opt;\nthis.req_un \x3d req_un;\nthis.opt_un \x3d opt_un;\nthis.gfn \x3d gfn;\nthis.pred_exprs \x3d pred_exprs;\nthis.keys_pred \x3d keys_pred;\nthis.argm \x3d argm;\nthis.opt_keys \x3d opt_keys;\nthis.req_specs \x3d req_specs;\nthis.map__24081 \x3d map__24081;\nthis.req \x3d req;\nthis.id \x3d id;\nthis.req_keys \x3d req_keys;\nthis.opt_specs \x3d opt_specs;\nthis.k__GT_s \x3d k__GT_s;\nthis.pred_forms \x3d pred_forms;\nthis.meta24088 \x3d meta24088;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24089,meta24088__$1){\nvar self__ \x3d this;\nvar _24089__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24087(self__.p__24079,self__.keys__GT_specnames,self__.opt,self__.req_un,self__.opt_un,self__.gfn,self__.pred_exprs,self__.keys_pred,self__.argm,self__.opt_keys,self__.req_specs,self__.map__24081,self__.req,self__.id,self__.req_keys,self__.opt_specs,self__.k__GT_s,self__.pred_forms,meta24088__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24089){\nvar self__ \x3d this;\nvar _24089__$1 \x3d this;\nreturn self__.meta24088;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,m){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_((self__.keys_pred.cljs$core$IFn$_invoke$arity$1 ? self__.keys_pred.cljs$core$IFn$_invoke$arity$1(m) : self__.keys_pred.call(null, m)))){\nvar reg \x3d cljs.spec.alpha.registry();\nvar ret \x3d m;\nvar G__24107 \x3d m;\nvar vec__24109 \x3d G__24107;\nvar seq__24110 \x3d cljs.core.seq(vec__24109);\nvar first__24111 \x3d cljs.core.first(seq__24110);\nvar seq__24110__$1 \x3d cljs.core.next(seq__24110);\nvar vec__24112 \x3d first__24111;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24112,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24112,(1),null);\nvar ks \x3d seq__24110__$1;\nvar keys \x3d vec__24109;\nvar ret__$1 \x3d ret;\nvar G__24107__$1 \x3d G__24107;\nwhile(true){\nvar ret__$2 \x3d ret__$1;\nvar vec__24119 \x3d G__24107__$1;\nvar seq__24120 \x3d cljs.core.seq(vec__24119);\nvar first__24121 \x3d cljs.core.first(seq__24120);\nvar seq__24120__$1 \x3d cljs.core.next(seq__24120);\nvar vec__24122 \x3d first__24121;\nvar k__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24122,(0),null);\nvar v__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24122,(1),null);\nvar ks__$1 \x3d seq__24120__$1;\nvar keys__$1 \x3d vec__24119;\nif(cljs.core.truth_(keys__$1)){\nvar sname \x3d (self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1 ? self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1(k__$1) : self__.keys__GT_specnames.call(null, k__$1));\nvar temp__5802__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(reg,sname);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar s \x3d temp__5802__auto__;\nvar cv \x3d cljs.spec.alpha.conform(s,v__$1);\nif(cljs.spec.alpha.invalid_QMARK_(cv)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nvar G__26617 \x3d (((cv \x3d\x3d\x3d v__$1))?ret__$2:cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret__$2,k__$1,cv));\nvar G__26618 \x3d ks__$1;\nret__$1 \x3d G__26617;\nG__24107__$1 \x3d G__26618;\ncontinue;\n}\n} else {\nvar G__26619 \x3d ret__$2;\nvar G__26620 \x3d ks__$1;\nret__$1 \x3d G__26619;\nG__24107__$1 \x3d G__26620;\ncontinue;\n}\n} else {\nreturn ret__$2;\n}\nbreak;\n}\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,m){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar reg \x3d cljs.spec.alpha.registry();\nvar ret \x3d m;\nvar G__24129 \x3d cljs.core.keys(m);\nvar vec__24132 \x3d G__24129;\nvar seq__24133 \x3d cljs.core.seq(vec__24132);\nvar first__24134 \x3d cljs.core.first(seq__24133);\nvar seq__24133__$1 \x3d cljs.core.next(seq__24133);\nvar k \x3d first__24134;\nvar ks \x3d seq__24133__$1;\nvar keys \x3d vec__24132;\nvar ret__$1 \x3d ret;\nvar G__24129__$1 \x3d G__24129;\nwhile(true){\nvar ret__$2 \x3d ret__$1;\nvar vec__24141 \x3d G__24129__$1;\nvar seq__24142 \x3d cljs.core.seq(vec__24141);\nvar first__24143 \x3d cljs.core.first(seq__24142);\nvar seq__24142__$1 \x3d cljs.core.next(seq__24142);\nvar k__$1 \x3d first__24143;\nvar ks__$1 \x3d seq__24142__$1;\nvar keys__$1 \x3d vec__24141;\nif(cljs.core.truth_(keys__$1)){\nif(cljs.core.contains_QMARK_(reg,(self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1 ? self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1(k__$1) : self__.keys__GT_specnames.call(null, k__$1)))){\nvar cv \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k__$1);\nvar v \x3d cljs.spec.alpha.unform((self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1 ? self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1(k__$1) : self__.keys__GT_specnames.call(null, k__$1)),cv);\nvar G__26637 \x3d (((cv \x3d\x3d\x3d v))?ret__$2:cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret__$2,k__$1,v));\nvar G__26638 \x3d ks__$1;\nret__$1 \x3d G__26637;\nG__24129__$1 \x3d G__26638;\ncontinue;\n} else {\nvar G__26641 \x3d ret__$2;\nvar G__26642 \x3d ks__$1;\nret__$1 \x3d G__26641;\nG__24129__$1 \x3d G__26642;\ncontinue;\n}\n} else {\nreturn ret__$2;\n}\nbreak;\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((!(cljs.core.map_QMARK_(x)))){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),new cljs.core.Symbol(\x22cljs.core\x22,\x22map?\x22,\x22cljs.core/map?\x22,-1390345523,null),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nvar reg \x3d cljs.spec.alpha.registry();\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.concat,(function (){var temp__5804__auto__ \x3d cljs.core.seq(cljs.core.keep.cljs$core$IFn$_invoke$arity$2(cljs.core.identity,cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (pred,form){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x)))){\nreturn null;\n} else {\nreturn form;\n}\n}),self__.pred_exprs,self__.pred_forms)));\nif(temp__5804__auto__){\nvar probs \x3d temp__5804__auto__;\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__24073_SHARP_){\nreturn cljs.core.identity(new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),p1__24073_SHARP_,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null));\n}),probs);\n} else {\nreturn null;\n}\n})(),cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p__24154){\nvar vec__24156 \x3d p__24154;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24156,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24156,(1),null);\nif((((!(cljs.core.contains_QMARK_(reg,(self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1 ? self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1(k) : self__.keys__GT_specnames.call(null, k)))))) || (cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$3((self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1 ? self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1(k) : self__.keys__GT_specnames.call(null, k)),v,k)))){\nreturn null;\n} else {\nreturn cljs.spec.alpha.explain_1((self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1 ? self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1(k) : self__.keys__GT_specnames.call(null, k)),(self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1 ? self__.keys__GT_specnames.cljs$core$IFn$_invoke$arity$1(k) : self__.keys__GT_specnames.call(null, k)),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k),via,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(in$,k),v);\n}\n}),cljs.core.seq(x)));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nvar rmap__$1 \x3d cljs.spec.alpha.inck(rmap,self__.id);\nvar rgen \x3d (function (k,s){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,cljs.spec.alpha.gensub(s,overrides,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k),rmap__$1,k)], null);\n});\nvar ogen \x3d (function (k,s){\nif(cljs.spec.alpha.recur_limit_QMARK_(rmap__$1,self__.id,path,k)){\nreturn null;\n} else {\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,cljs.spec.gen.alpha.delay_impl((new cljs.core.Delay((function (){\nreturn cljs.spec.alpha.gensub(s,overrides,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k),rmap__$1,k);\n}),null)))], null);\n}\n});\nvar reqs \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$3(rgen,self__.req_keys,self__.req_specs);\nvar opts \x3d cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,cljs.core.map.cljs$core$IFn$_invoke$arity$3(ogen,self__.opt_keys,self__.opt_specs));\nif(cljs.core.every_QMARK_(cljs.core.identity,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.second,reqs),cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.second,opts)))){\nreturn cljs.spec.gen.alpha.bind.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.gen.alpha.tuple.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.alpha.and_k_gen(self__.req),cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$1(self__.opt),cljs.spec.alpha.and_k_gen(self__.req_un),cljs.spec.alpha.or_k_gen.cljs$core$IFn$_invoke$arity$1(self__.opt_un)], 0)),(function (p__24177){\nvar vec__24178 \x3d p__24177;\nvar req_ks \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24178,(0),null);\nvar opt_ks \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24178,(1),null);\nvar req_un_ks \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24178,(2),null);\nvar opt_un_ks \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24178,(3),null);\nvar qks \x3d cljs.core.flatten(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(req_ks,opt_ks));\nvar unqks \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.comp.cljs$core$IFn$_invoke$arity$2(cljs.core.keyword,cljs.core.name),cljs.core.flatten(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(req_un_ks,opt_un_ks)));\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.spec.gen.alpha.hash_map,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__24077_SHARP_){\nvar G__24185 \x3d cljs.core.first(p1__24077_SHARP_);\nvar fexpr__24184 \x3d cljs.core.set(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(qks,unqks));\nreturn (fexpr__24184.cljs$core$IFn$_invoke$arity$1 ? fexpr__24184.cljs$core$IFn$_invoke$arity$1(G__24185) : fexpr__24184.call(null, G__24185));\n}),cljs.core.into.cljs$core$IFn$_invoke$arity$2(reqs,opts))));\n})], 0));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar G__24189 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.argm,new cljs.core.Keyword(null,\x22gfn\x22,\x22gfn\x22,791517474),gfn__$1);\nreturn (cljs.spec.alpha.map_spec_impl.cljs$core$IFn$_invoke$arity$1 ? cljs.spec.alpha.map_spec_impl.cljs$core$IFn$_invoke$arity$1(G__24189) : cljs.spec.alpha.map_spec_impl.call(null, G__24189));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.cons(new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22keys\x22,\x22cljs.spec.alpha/keys\x22,1109346032,null),(function (){var G__24194 \x3d cljs.core.PersistentVector.EMPTY;\nvar G__24194__$1 \x3d (cljs.core.truth_(self__.req)?cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(G__24194,new cljs.core.Keyword(null,\x22req\x22,\x22req\x22,-326448303),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.req], 0)):G__24194);\nvar G__24194__$2 \x3d (cljs.core.truth_(self__.opt)?cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(G__24194__$1,new cljs.core.Keyword(null,\x22opt\x22,\x22opt\x22,-794706369),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.opt], 0)):G__24194__$1);\nvar G__24194__$3 \x3d (cljs.core.truth_(self__.req_un)?cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(G__24194__$2,new cljs.core.Keyword(null,\x22req-un\x22,\x22req-un\x22,1074571008),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.req_un], 0)):G__24194__$2);\nif(cljs.core.truth_(self__.opt_un)){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(G__24194__$3,new cljs.core.Keyword(null,\x22opt-un\x22,\x22opt-un\x22,883442496),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.opt_un], 0));\n} else {\nreturn G__24194__$3;\n}\n})());\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 19, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22p__24079\x22,\x22p__24079\x22,1666468260,null),new cljs.core.Symbol(null,\x22keys-\x3especnames\x22,\x22keys-\x3especnames\x22,1791294693,null),new cljs.core.Symbol(null,\x22opt\x22,\x22opt\x22,845825158,null),new cljs.core.Symbol(null,\x22req-un\x22,\x22req-un\x22,-1579864761,null),new cljs.core.Symbol(null,\x22opt-un\x22,\x22opt-un\x22,-1770993273,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22pred-exprs\x22,\x22pred-exprs\x22,-862164374,null),new cljs.core.Symbol(null,\x22keys-pred\x22,\x22keys-pred\x22,-1795451030,null),new cljs.core.Symbol(null,\x22argm\x22,\x22argm\x22,-181546357,null),new cljs.core.Symbol(null,\x22opt-keys\x22,\x22opt-keys\x22,-1391747508,null),new cljs.core.Symbol(null,\x22req-specs\x22,\x22req-specs\x22,-2100473456,null),new cljs.core.Symbol(null,\x22map__24081\x22,\x22map__24081\x22,1774407863,null),new cljs.core.Symbol(null,\x22req\x22,\x22req\x22,1314083224,null),new cljs.core.Symbol(null,\x22id\x22,\x22id\x22,252129435,null),new cljs.core.Symbol(null,\x22req-keys\x22,\x22req-keys\x22,-2140116548,null),new cljs.core.Symbol(null,\x22opt-specs\x22,\x22opt-specs\x22,1255626077,null),new cljs.core.Symbol(null,\x22k-\x3es\x22,\x22k-\x3es\x22,-1685112801,null),new cljs.core.Symbol(null,\x22pred-forms\x22,\x22pred-forms\x22,1813143359,null),new cljs.core.Symbol(null,\x22meta24088\x22,\x22meta24088\x22,-730358078,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha24087\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24087.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha24087\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha24087.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha24087 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha24087(p__24079,keys__GT_specnames,opt,req_un,opt_un,gfn,pred_exprs,keys_pred,argm,opt_keys,req_specs,map__24081,req,id,req_keys,opt_specs,k__GT_s,pred_forms,meta24088){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24087(p__24079,keys__GT_specnames,opt,req_un,opt_un,gfn,pred_exprs,keys_pred,argm,opt_keys,req_specs,map__24081,req,id,req_keys,opt_specs,k__GT_s,pred_forms,meta24088));\n});\n\n\n/**\n * Do not call this directly, use \x27spec\x27 with a map argument\n */\ncljs.spec.alpha.map_spec_impl \x3d (function cljs$spec$alpha$map_spec_impl(p__24079){\nvar map__24081 \x3d p__24079;\nvar map__24081__$1 \x3d cljs.core.__destructure_map(map__24081);\nvar argm \x3d map__24081__$1;\nvar opt \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22opt\x22,\x22opt\x22,-794706369));\nvar req_un \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22req-un\x22,\x22req-un\x22,1074571008));\nvar opt_un \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22opt-un\x22,\x22opt-un\x22,883442496));\nvar gfn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22gfn\x22,\x22gfn\x22,791517474));\nvar pred_exprs \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22pred-exprs\x22,\x22pred-exprs\x22,1792271395));\nvar keys_pred \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22keys-pred\x22,\x22keys-pred\x22,858984739));\nvar opt_keys \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22opt-keys\x22,\x22opt-keys\x22,1262688261));\nvar req_specs \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22req-specs\x22,\x22req-specs\x22,553962313));\nvar req \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22req\x22,\x22req\x22,-326448303));\nvar req_keys \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22req-keys\x22,\x22req-keys\x22,514319221));\nvar opt_specs \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22opt-specs\x22,\x22opt-specs\x22,-384905450));\nvar pred_forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24081__$1,new cljs.core.Keyword(null,\x22pred-forms\x22,\x22pred-forms\x22,172611832));\nvar k__GT_s \x3d cljs.core.zipmap(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(req_keys,opt_keys),cljs.core.concat.cljs$core$IFn$_invoke$arity$2(req_specs,opt_specs));\nvar keys__GT_specnames \x3d (function (p1__24071_SHARP_){\nvar or__5002__auto__ \x3d (k__GT_s.cljs$core$IFn$_invoke$arity$1 ? k__GT_s.cljs$core$IFn$_invoke$arity$1(p1__24071_SHARP_) : k__GT_s.call(null, p1__24071_SHARP_));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn p1__24071_SHARP_;\n}\n});\nvar id \x3d cljs.core.random_uuid();\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24087(p__24079,keys__GT_specnames,opt,req_un,opt_un,gfn,pred_exprs,keys_pred,argm,opt_keys,req_specs,map__24081__$1,req,id,req_keys,opt_specs,k__GT_s,pred_forms,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha24312 \x3d (function (form,pred,gfn,cpred_QMARK_,unc,meta24313){\nthis.form \x3d form;\nthis.pred \x3d pred;\nthis.gfn \x3d gfn;\nthis.cpred_QMARK_ \x3d cpred_QMARK_;\nthis.unc \x3d unc;\nthis.meta24313 \x3d meta24313;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24314,meta24313__$1){\nvar self__ \x3d this;\nvar _24314__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24312(self__.form,self__.pred,self__.gfn,self__.cpred_QMARK_,self__.unc,meta24313__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24314){\nvar self__ \x3d this;\nvar _24314__$1 \x3d this;\nreturn self__.meta24313;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar ret \x3d (self__.pred.cljs$core$IFn$_invoke$arity$1 ? self__.pred.cljs$core$IFn$_invoke$arity$1(x) : self__.pred.call(null, x));\nif(cljs.core.truth_(self__.cpred_QMARK_)){\nreturn ret;\n} else {\nif(cljs.core.truth_(ret)){\nreturn x;\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.cpred_QMARK_)){\nif(cljs.core.truth_(self__.unc)){\nreturn (self__.unc.cljs$core$IFn$_invoke$arity$1 ? self__.unc.cljs$core$IFn$_invoke$arity$1(x) : self__.unc.call(null, x));\n} else {\nthrow (new Error(\x22no unform fn for conformer\x22));\n}\n} else {\nreturn x;\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.spec.alpha.invalid_QMARK_(cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$4(self__.pred,x,self__.form,self__.cpred_QMARK_))){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),self__.form,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nreturn null;\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,___$1,___$2,___$3){\nvar self__ \x3d this;\nvar ___$4 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nreturn cljs.spec.gen.alpha.gen_for_pred(self__.pred);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$5(self__.form,self__.pred,gfn__$1,self__.cpred_QMARK_,self__.unc);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn self__.form;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22form\x22,\x22form\x22,16469056,null),new cljs.core.Symbol(null,\x22pred\x22,\x22pred\x22,-727012372,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22cpred?\x22,\x22cpred?\x22,35589515,null),new cljs.core.Symbol(null,\x22unc\x22,\x22unc\x22,-465250751,null),new cljs.core.Symbol(null,\x22meta24313\x22,\x22meta24313\x22,-473590518,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha24312\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24312.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha24312\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha24312.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha24312 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha24312(form,pred,gfn,cpred_QMARK_,unc,meta24313){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24312(form,pred,gfn,cpred_QMARK_,unc,meta24313));\n});\n\n\n/**\n * Do not call this directly, use \x27spec\x27\n */\ncljs.spec.alpha.spec_impl \x3d (function cljs$spec$alpha$spec_impl(var_args){\nvar G__24245 \x3d arguments.length;\nswitch (G__24245) {\ncase 4:\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ncase 5:\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$4 \x3d (function (form,pred,gfn,cpred_QMARK_){\nreturn cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$5(form,pred,gfn,cpred_QMARK_,null);\n}));\n\n(cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$5 \x3d (function (form,pred,gfn,cpred_QMARK_,unc){\nif(cljs.core.truth_(cljs.spec.alpha.spec_QMARK_(pred))){\nvar G__24286 \x3d pred;\nif(cljs.core.truth_(gfn)){\nreturn cljs.spec.alpha.with_gen(G__24286,gfn);\n} else {\nreturn G__24286;\n}\n} else {\nif(cljs.core.truth_(cljs.spec.alpha.regex_QMARK_(pred))){\nreturn cljs.spec.alpha.regex_spec_impl(pred,gfn);\n} else {\nif(cljs.core.ident_QMARK_(pred)){\nvar G__24305 \x3d cljs.spec.alpha.the_spec(pred);\nif(cljs.core.truth_(gfn)){\nreturn cljs.spec.alpha.with_gen(G__24305,gfn);\n} else {\nreturn G__24305;\n}\n} else {\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24312(form,pred,gfn,cpred_QMARK_,unc,cljs.core.PersistentArrayMap.EMPTY));\n\n}\n}\n}\n}));\n\n(cljs.spec.alpha.spec_impl.cljs$lang$maxFixedArity \x3d 5);\n\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha24538 \x3d (function (form,mmvar,retag,gfn,id,predx,dval,tag,meta24539){\nthis.form \x3d form;\nthis.mmvar \x3d mmvar;\nthis.retag \x3d retag;\nthis.gfn \x3d gfn;\nthis.id \x3d id;\nthis.predx \x3d predx;\nthis.dval \x3d dval;\nthis.tag \x3d tag;\nthis.meta24539 \x3d meta24539;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24540,meta24539__$1){\nvar self__ \x3d this;\nvar _24540__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24538(self__.form,self__.mmvar,self__.retag,self__.gfn,self__.id,self__.predx,self__.dval,self__.tag,meta24539__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24540){\nvar self__ \x3d this;\nvar _24540__$1 \x3d this;\nreturn self__.meta24539;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar temp__5802__auto__ \x3d (self__.predx.cljs$core$IFn$_invoke$arity$1 ? self__.predx.cljs$core$IFn$_invoke$arity$1(x) : self__.predx.call(null, x));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar pred \x3d temp__5802__auto__;\nreturn cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(pred,x,self__.form);\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar temp__5802__auto__ \x3d (self__.predx.cljs$core$IFn$_invoke$arity$1 ? self__.predx.cljs$core$IFn$_invoke$arity$1(x) : self__.predx.call(null, x));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar pred \x3d temp__5802__auto__;\nreturn cljs.spec.alpha.unform(pred,x);\n} else {\nthrow (new Error([\x22No method of: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.form),\x22 for dispatch value: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((self__.dval.cljs$core$IFn$_invoke$arity$1 ? self__.dval.cljs$core$IFn$_invoke$arity$1(x) : self__.dval.call(null, x)))].join(\x27\x27)));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar dv \x3d (self__.dval.cljs$core$IFn$_invoke$arity$1 ? self__.dval.cljs$core$IFn$_invoke$arity$1(x) : self__.dval.call(null, x));\nvar path__$1 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,dv);\nvar temp__5802__auto__ \x3d (self__.predx.cljs$core$IFn$_invoke$arity$1 ? self__.predx.cljs$core$IFn$_invoke$arity$1(x) : self__.predx.call(null, x));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar pred \x3d temp__5802__auto__;\nreturn cljs.spec.alpha.explain_1(self__.form,pred,path__$1,via,in$,x);\n} else {\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path__$1,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),self__.form,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),\x22no method\x22,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nvar gen \x3d (function (p__24565){\nvar vec__24568 \x3d p__24565;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24568,(0),null);\nvar f \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24568,(1),null);\nvar p \x3d (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(null) : f.call(null, null));\nvar rmap__$1 \x3d cljs.spec.alpha.inck(rmap,self__.id);\nif(cljs.spec.alpha.recur_limit_QMARK_(rmap__$1,self__.id,path,k)){\nreturn null;\n} else {\nreturn cljs.spec.gen.alpha.delay_impl((new cljs.core.Delay((function (){\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__24510_SHARP_){\nreturn (self__.tag.cljs$core$IFn$_invoke$arity$2 ? self__.tag.cljs$core$IFn$_invoke$arity$2(p1__24510_SHARP_,k) : self__.tag.call(null, p1__24510_SHARP_,k));\n}),cljs.spec.alpha.gensub(p,overrides,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k),rmap__$1,(new cljs.core.List(null,new cljs.core.Symbol(null,\x22method\x22,\x22method\x22,1696235119,null),(new cljs.core.List(null,self__.form,(new cljs.core.List(null,k,null,(1),null)),(2),null)),(3),null)))], 0));\n}),null)));\n}\n});\nvar gs \x3d cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,cljs.core.map.cljs$core$IFn$_invoke$arity$2(gen,cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p__24581){\nvar vec__24584 \x3d p__24581;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24584,(0),null);\nreturn cljs.spec.alpha.invalid_QMARK_(k);\n}),cljs.core.methods$(cljs.core.deref(self__.mmvar)))));\nif(cljs.core.every_QMARK_(cljs.core.identity,gs)){\nreturn cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([gs], 0));\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.multi_spec_impl.cljs$core$IFn$_invoke$arity$4(self__.form,self__.mmvar,self__.retag,gfn__$1);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22multi-spec\x22,\x22cljs.spec.alpha/multi-spec\x22,175821274,null),null,(1),null)),(new cljs.core.List(null,self__.form,null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs.core.List(null,self__.retag,null,(1),null))], 0))));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22form\x22,\x22form\x22,16469056,null),new cljs.core.Symbol(null,\x22mmvar\x22,\x22mmvar\x22,-1714325675,null),new cljs.core.Symbol(null,\x22retag\x22,\x22retag\x22,528972725,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22id\x22,\x22id\x22,252129435,null),new cljs.core.Symbol(null,\x22predx\x22,\x22predx\x22,2063470948,null),new cljs.core.Symbol(null,\x22dval\x22,\x22dval\x22,835211877,null),new cljs.core.Symbol(null,\x22tag\x22,\x22tag\x22,350170304,null),new cljs.core.Symbol(null,\x22meta24539\x22,\x22meta24539\x22,272357320,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha24538\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24538.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha24538\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha24538.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha24538 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha24538(form,mmvar,retag,gfn,id,predx,dval,tag,meta24539){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24538(form,mmvar,retag,gfn,id,predx,dval,tag,meta24539));\n});\n\n\n/**\n * Do not call this directly, use \x27multi-spec\x27\n */\ncljs.spec.alpha.multi_spec_impl \x3d (function cljs$spec$alpha$multi_spec_impl(var_args){\nvar G__24518 \x3d arguments.length;\nswitch (G__24518) {\ncase 3:\nreturn cljs.spec.alpha.multi_spec_impl.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.spec.alpha.multi_spec_impl.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.multi_spec_impl.cljs$core$IFn$_invoke$arity$3 \x3d (function (form,mmvar,retag){\nreturn cljs.spec.alpha.multi_spec_impl.cljs$core$IFn$_invoke$arity$4(form,mmvar,retag,null);\n}));\n\n(cljs.spec.alpha.multi_spec_impl.cljs$core$IFn$_invoke$arity$4 \x3d (function (form,mmvar,retag,gfn){\nvar id \x3d cljs.core.random_uuid();\nvar predx \x3d (function (p1__24502_SHARP_){\nvar mm \x3d cljs.core.deref(mmvar);\nvar and__5000__auto__ \x3d cljs.core._get_method(mm,(function (){var fexpr__24531 \x3d cljs.core._dispatch_fn(mm);\nreturn (fexpr__24531.cljs$core$IFn$_invoke$arity$1 ? fexpr__24531.cljs$core$IFn$_invoke$arity$1(p1__24502_SHARP_) : fexpr__24531.call(null, p1__24502_SHARP_));\n})());\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (mm.cljs$core$IFn$_invoke$arity$1 ? mm.cljs$core$IFn$_invoke$arity$1(p1__24502_SHARP_) : mm.call(null, p1__24502_SHARP_));\n} else {\nreturn and__5000__auto__;\n}\n});\nvar dval \x3d (function (p1__24504_SHARP_){\nvar fexpr__24535 \x3d cljs.core._dispatch_fn(cljs.core.deref(mmvar));\nreturn (fexpr__24535.cljs$core$IFn$_invoke$arity$1 ? fexpr__24535.cljs$core$IFn$_invoke$arity$1(p1__24504_SHARP_) : fexpr__24535.call(null, p1__24504_SHARP_));\n});\nvar tag \x3d (((retag instanceof cljs.core.Keyword))?(function (p1__24506_SHARP_,p2__24507_SHARP_){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(p1__24506_SHARP_,retag,p2__24507_SHARP_);\n}):retag);\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24538(form,mmvar,retag,gfn,id,predx,dval,tag,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(cljs.spec.alpha.multi_spec_impl.cljs$lang$maxFixedArity \x3d 4);\n\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha24632 \x3d (function (forms,preds,gfn,specs,cnt,meta24633){\nthis.forms \x3d forms;\nthis.preds \x3d preds;\nthis.gfn \x3d gfn;\nthis.specs \x3d specs;\nthis.cnt \x3d cnt;\nthis.meta24633 \x3d meta24633;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24634,meta24633__$1){\nvar self__ \x3d this;\nvar _24634__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24632(self__.forms,self__.preds,self__.gfn,self__.specs,self__.cnt,meta24633__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24634){\nvar self__ \x3d this;\nvar _24634__$1 \x3d this;\nreturn self__.meta24633;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar specs__$1 \x3d cljs.core.deref(self__.specs);\nif((!(((cljs.core.vector_QMARK_(x)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(x),self__.cnt)))))){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nvar ret \x3d x;\nvar i \x3d (0);\nwhile(true){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(i,self__.cnt)){\nreturn ret;\n} else {\nvar v \x3d (x.cljs$core$IFn$_invoke$arity$1 ? x.cljs$core$IFn$_invoke$arity$1(i) : x.call(null, i));\nvar cv \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1(i) : specs__$1.call(null, i)),v);\nif(cljs.spec.alpha.invalid_QMARK_(cv)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nvar G__26748 \x3d (((cv \x3d\x3d\x3d v))?ret:cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,i,cv));\nvar G__26749 \x3d (i + (1));\nret \x3d G__26748;\ni \x3d G__26749;\ncontinue;\n}\n}\nbreak;\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(((cljs.core.vector_QMARK_(x)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(x),cljs.core.count(self__.preds))))){\n} else {\nthrow (new Error(\x22Assert failed: (c/and (vector? x) (\x3d (count x) (count preds)))\x22));\n}\n\nvar ret \x3d x;\nvar i \x3d (0);\nwhile(true){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(i,cljs.core.count(x))){\nreturn ret;\n} else {\nvar cv \x3d (x.cljs$core$IFn$_invoke$arity$1 ? x.cljs$core$IFn$_invoke$arity$1(i) : x.call(null, i));\nvar v \x3d cljs.spec.alpha.unform((self__.preds.cljs$core$IFn$_invoke$arity$1 ? self__.preds.cljs$core$IFn$_invoke$arity$1(i) : self__.preds.call(null, i)),cv);\nvar G__26755 \x3d (((cv \x3d\x3d\x3d v))?ret:cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,i,v));\nvar G__26756 \x3d (i + (1));\nret \x3d G__26755;\ni \x3d G__26756;\ncontinue;\n}\nbreak;\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((!(cljs.core.vector_QMARK_(x)))){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),new cljs.core.Symbol(\x22cljs.core\x22,\x22vector?\x22,\x22cljs.core/vector?\x22,-1550392028,null),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nif(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(x),cljs.core.count(self__.preds))){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22\x3d\x22,\x22cljs.core/\x3d\x22,-1891498332,null),null,(1),null)),(new cljs.core.List(null,cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22count\x22,\x22cljs.core/count\x22,-921270233,null),null,(1),null)),(new cljs.core.List(null,new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null),null,(1),null))))),null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs.core.List(null,cljs.core.count(self__.preds),null,(1),null))], 0)))),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,cljs.core.map.cljs$core$IFn$_invoke$arity$4((function (i,form,pred){\nvar v \x3d (x.cljs$core$IFn$_invoke$arity$1 ? x.cljs$core$IFn$_invoke$arity$1(i) : x.call(null, i));\nif(cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2(pred,v)){\nreturn null;\n} else {\nreturn cljs.spec.alpha.explain_1(form,pred,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,i),via,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(in$,i),v);\n}\n}),cljs.core.range.cljs$core$IFn$_invoke$arity$1(cljs.core.count(self__.preds)),self__.forms,self__.preds));\n\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nvar gen \x3d (function (i,p,f){\nreturn cljs.spec.alpha.gensub(p,overrides,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,i),rmap,f);\n});\nvar gs \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$4(gen,cljs.core.range.cljs$core$IFn$_invoke$arity$1(cljs.core.count(self__.preds)),self__.preds,self__.forms);\nif(cljs.core.every_QMARK_(cljs.core.identity,gs)){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.spec.gen.alpha.tuple,gs);\n} else {\nreturn null;\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.tuple_impl.cljs$core$IFn$_invoke$arity$3(self__.forms,self__.preds,gfn__$1);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22tuple\x22,\x22cljs.spec.alpha/tuple\x22,-415901908,null),null,(1),null)),self__.forms)));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22forms\x22,\x22forms\x22,-608443419,null),new cljs.core.Symbol(null,\x22preds\x22,\x22preds\x22,150921777,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22specs\x22,\x22specs\x22,-1227865028,null),new cljs.core.Symbol(null,\x22cnt\x22,\x22cnt\x22,1924510325,null),new cljs.core.Symbol(null,\x22meta24633\x22,\x22meta24633\x22,-601352932,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha24632\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24632.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha24632\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha24632.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha24632 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha24632(forms,preds,gfn,specs,cnt,meta24633){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24632(forms,preds,gfn,specs,cnt,meta24633));\n});\n\n\n/**\n * Do not call this directly, use \x27tuple\x27\n */\ncljs.spec.alpha.tuple_impl \x3d (function cljs$spec$alpha$tuple_impl(var_args){\nvar G__24622 \x3d arguments.length;\nswitch (G__24622) {\ncase 2:\nreturn cljs.spec.alpha.tuple_impl.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.spec.alpha.tuple_impl.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.tuple_impl.cljs$core$IFn$_invoke$arity$2 \x3d (function (forms,preds){\nreturn cljs.spec.alpha.tuple_impl.cljs$core$IFn$_invoke$arity$3(forms,preds,null);\n}));\n\n(cljs.spec.alpha.tuple_impl.cljs$core$IFn$_invoke$arity$3 \x3d (function (forms,preds,gfn){\nvar specs \x3d (new cljs.core.Delay((function (){\nreturn cljs.core.mapv.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.specize,preds,forms);\n}),null));\nvar cnt \x3d cljs.core.count(preds);\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24632(forms,preds,gfn,specs,cnt,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(cljs.spec.alpha.tuple_impl.cljs$lang$maxFixedArity \x3d 3);\n\ncljs.spec.alpha.tagged_ret \x3d (function cljs$spec$alpha$tagged_ret(tag,ret){\nreturn (new cljs.core.MapEntry(tag,ret,null));\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha24714 \x3d (function (keys,forms,preds,gfn,id,kps,specs,cform,meta24715){\nthis.keys \x3d keys;\nthis.forms \x3d forms;\nthis.preds \x3d preds;\nthis.gfn \x3d gfn;\nthis.id \x3d id;\nthis.kps \x3d kps;\nthis.specs \x3d specs;\nthis.cform \x3d cform;\nthis.meta24715 \x3d meta24715;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24716,meta24715__$1){\nvar self__ \x3d this;\nvar _24716__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24714(self__.keys,self__.forms,self__.preds,self__.gfn,self__.id,self__.kps,self__.specs,self__.cform,meta24715__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24716){\nvar self__ \x3d this;\nvar _24716__$1 \x3d this;\nreturn self__.meta24715;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (self__.cform.cljs$core$IFn$_invoke$arity$1 ? self__.cform.cljs$core$IFn$_invoke$arity$1(x) : self__.cform.call(null, x));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,p__24722){\nvar self__ \x3d this;\nvar vec__24723 \x3d p__24722;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24723,(0),null);\nvar x \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__24723,(1),null);\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.unform((self__.kps.cljs$core$IFn$_invoke$arity$1 ? self__.kps.cljs$core$IFn$_invoke$arity$1(k) : self__.kps.call(null, k)),x);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (this$,path,via,in$,x){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nif(cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2(this$__$1,x)){\nreturn null;\n} else {\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,cljs.core.map.cljs$core$IFn$_invoke$arity$4((function (k,form,pred){\nif(cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2(pred,x)){\nreturn null;\n} else {\nreturn cljs.spec.alpha.explain_1(form,pred,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k),via,in$,x);\n}\n}),self__.keys,self__.forms,self__.preds));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nvar gen \x3d (function (k,p,f){\nvar rmap__$1 \x3d cljs.spec.alpha.inck(rmap,self__.id);\nif(cljs.spec.alpha.recur_limit_QMARK_(rmap__$1,self__.id,path,k)){\nreturn null;\n} else {\nreturn cljs.spec.gen.alpha.delay_impl((new cljs.core.Delay((function (){\nreturn cljs.spec.alpha.gensub(p,overrides,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k),rmap__$1,f);\n}),null)));\n}\n});\nvar gs \x3d cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,cljs.core.map.cljs$core$IFn$_invoke$arity$4(gen,self__.keys,self__.preds,self__.forms));\nif(cljs.core.empty_QMARK_(gs)){\nreturn null;\n} else {\nreturn cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([gs], 0));\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (cljs.spec.alpha.or_spec_impl.cljs$core$IFn$_invoke$arity$4 ? cljs.spec.alpha.or_spec_impl.cljs$core$IFn$_invoke$arity$4(self__.keys,self__.forms,self__.preds,gfn__$1) : cljs.spec.alpha.or_spec_impl.call(null, self__.keys,self__.forms,self__.preds,gfn__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22or\x22,\x22cljs.spec.alpha/or\x22,-831679639,null),null,(1),null)),cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(cljs.core.vector,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.keys,self__.forms], 0)))));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22keys\x22,\x22keys\x22,-1586012071,null),new cljs.core.Symbol(null,\x22forms\x22,\x22forms\x22,-608443419,null),new cljs.core.Symbol(null,\x22preds\x22,\x22preds\x22,150921777,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22id\x22,\x22id\x22,252129435,null),new cljs.core.Symbol(null,\x22kps\x22,\x22kps\x22,-1157342767,null),new cljs.core.Symbol(null,\x22specs\x22,\x22specs\x22,-1227865028,null),new cljs.core.Symbol(null,\x22cform\x22,\x22cform\x22,1319506748,null),new cljs.core.Symbol(null,\x22meta24715\x22,\x22meta24715\x22,-542060588,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha24714\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24714.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha24714\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha24714.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha24714 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha24714(keys,forms,preds,gfn,id,kps,specs,cform,meta24715){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24714(keys,forms,preds,gfn,id,kps,specs,cform,meta24715));\n});\n\n\n/**\n * Do not call this directly, use \x27or\x27\n */\ncljs.spec.alpha.or_spec_impl \x3d (function cljs$spec$alpha$or_spec_impl(keys,forms,preds,gfn){\nvar id \x3d cljs.core.random_uuid();\nvar kps \x3d cljs.core.zipmap(keys,preds);\nvar specs \x3d (new cljs.core.Delay((function (){\nreturn cljs.core.mapv.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.specize,preds,forms);\n}),null));\nvar cform \x3d (function (){var G__24697 \x3d cljs.core.count(preds);\nswitch (G__24697) {\ncase (2):\nreturn (function (x){\nvar specs__$1 \x3d cljs.core.deref(specs);\nvar ret \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((0)) : specs__$1.call(null, (0))),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret)){\nvar ret__$1 \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((1)) : specs__$1.call(null, (1))),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret__$1)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nreturn cljs.spec.alpha.tagged_ret((keys.cljs$core$IFn$_invoke$arity$1 ? keys.cljs$core$IFn$_invoke$arity$1((1)) : keys.call(null, (1))),ret__$1);\n}\n} else {\nreturn cljs.spec.alpha.tagged_ret((keys.cljs$core$IFn$_invoke$arity$1 ? keys.cljs$core$IFn$_invoke$arity$1((0)) : keys.call(null, (0))),ret);\n}\n});\n\nbreak;\ncase (3):\nreturn (function (x){\nvar specs__$1 \x3d cljs.core.deref(specs);\nvar ret \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((0)) : specs__$1.call(null, (0))),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret)){\nvar ret__$1 \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((1)) : specs__$1.call(null, (1))),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret__$1)){\nvar ret__$2 \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((2)) : specs__$1.call(null, (2))),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret__$2)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nreturn cljs.spec.alpha.tagged_ret((keys.cljs$core$IFn$_invoke$arity$1 ? keys.cljs$core$IFn$_invoke$arity$1((2)) : keys.call(null, (2))),ret__$2);\n}\n} else {\nreturn cljs.spec.alpha.tagged_ret((keys.cljs$core$IFn$_invoke$arity$1 ? keys.cljs$core$IFn$_invoke$arity$1((1)) : keys.call(null, (1))),ret__$1);\n}\n} else {\nreturn cljs.spec.alpha.tagged_ret((keys.cljs$core$IFn$_invoke$arity$1 ? keys.cljs$core$IFn$_invoke$arity$1((0)) : keys.call(null, (0))),ret);\n}\n});\n\nbreak;\ndefault:\nreturn (function (x){\nvar specs__$1 \x3d cljs.core.deref(specs);\nvar i \x3d (0);\nwhile(true){\nif((i \x3c cljs.core.count(specs__$1))){\nvar spec \x3d (specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1(i) : specs__$1.call(null, i));\nvar ret \x3d cljs.spec.alpha.conform_STAR_(spec,x);\nif(cljs.spec.alpha.invalid_QMARK_(ret)){\nvar G__26811 \x3d (i + (1));\ni \x3d G__26811;\ncontinue;\n} else {\nreturn cljs.spec.alpha.tagged_ret((keys.cljs$core$IFn$_invoke$arity$1 ? keys.cljs$core$IFn$_invoke$arity$1(i) : keys.call(null, i)),ret);\n}\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\nbreak;\n}\n});\n\n}\n})();\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24714(keys,forms,preds,gfn,id,kps,specs,cform,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.spec.alpha.and_preds \x3d (function cljs$spec$alpha$and_preds(x,preds,forms){\nvar ret \x3d x;\nvar G__24763 \x3d preds;\nvar vec__24765 \x3d G__24763;\nvar seq__24766 \x3d cljs.core.seq(vec__24765);\nvar first__24767 \x3d cljs.core.first(seq__24766);\nvar seq__24766__$1 \x3d cljs.core.next(seq__24766);\nvar pred \x3d first__24767;\nvar preds__$1 \x3d seq__24766__$1;\nvar G__24764 \x3d forms;\nvar vec__24768 \x3d G__24764;\nvar seq__24769 \x3d cljs.core.seq(vec__24768);\nvar first__24770 \x3d cljs.core.first(seq__24769);\nvar seq__24769__$1 \x3d cljs.core.next(seq__24769);\nvar form \x3d first__24770;\nvar forms__$1 \x3d seq__24769__$1;\nvar ret__$1 \x3d ret;\nvar G__24763__$1 \x3d G__24763;\nvar G__24764__$1 \x3d G__24764;\nwhile(true){\nvar ret__$2 \x3d ret__$1;\nvar vec__24771 \x3d G__24763__$1;\nvar seq__24772 \x3d cljs.core.seq(vec__24771);\nvar first__24773 \x3d cljs.core.first(seq__24772);\nvar seq__24772__$1 \x3d cljs.core.next(seq__24772);\nvar pred__$1 \x3d first__24773;\nvar preds__$2 \x3d seq__24772__$1;\nvar vec__24774 \x3d G__24764__$1;\nvar seq__24775 \x3d cljs.core.seq(vec__24774);\nvar first__24776 \x3d cljs.core.first(seq__24775);\nvar seq__24775__$1 \x3d cljs.core.next(seq__24775);\nvar form__$1 \x3d first__24776;\nvar forms__$2 \x3d seq__24775__$1;\nif(cljs.core.truth_(pred__$1)){\nvar nret \x3d cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(pred__$1,ret__$2,form__$1);\nif(cljs.spec.alpha.invalid_QMARK_(nret)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nvar G__26831 \x3d nret;\nvar G__26832 \x3d preds__$2;\nvar G__26833 \x3d forms__$2;\nret__$1 \x3d G__26831;\nG__24763__$1 \x3d G__26832;\nG__24764__$1 \x3d G__26833;\ncontinue;\n}\n} else {\nreturn ret__$2;\n}\nbreak;\n}\n});\ncljs.spec.alpha.explain_pred_list \x3d (function cljs$spec$alpha$explain_pred_list(forms,preds,path,via,in$,x){\nvar ret \x3d x;\nvar G__24783 \x3d forms;\nvar vec__24785 \x3d G__24783;\nvar seq__24786 \x3d cljs.core.seq(vec__24785);\nvar first__24787 \x3d cljs.core.first(seq__24786);\nvar seq__24786__$1 \x3d cljs.core.next(seq__24786);\nvar form \x3d first__24787;\nvar forms__$1 \x3d seq__24786__$1;\nvar G__24784 \x3d preds;\nvar vec__24788 \x3d G__24784;\nvar seq__24789 \x3d cljs.core.seq(vec__24788);\nvar first__24790 \x3d cljs.core.first(seq__24789);\nvar seq__24789__$1 \x3d cljs.core.next(seq__24789);\nvar pred \x3d first__24790;\nvar preds__$1 \x3d seq__24789__$1;\nvar ret__$1 \x3d ret;\nvar G__24783__$1 \x3d G__24783;\nvar G__24784__$1 \x3d G__24784;\nwhile(true){\nvar ret__$2 \x3d ret__$1;\nvar vec__24791 \x3d G__24783__$1;\nvar seq__24792 \x3d cljs.core.seq(vec__24791);\nvar first__24793 \x3d cljs.core.first(seq__24792);\nvar seq__24792__$1 \x3d cljs.core.next(seq__24792);\nvar form__$1 \x3d first__24793;\nvar forms__$2 \x3d seq__24792__$1;\nvar vec__24794 \x3d G__24784__$1;\nvar seq__24795 \x3d cljs.core.seq(vec__24794);\nvar first__24796 \x3d cljs.core.first(seq__24795);\nvar seq__24795__$1 \x3d cljs.core.next(seq__24795);\nvar pred__$1 \x3d first__24796;\nvar preds__$2 \x3d seq__24795__$1;\nif(cljs.core.truth_(pred__$1)){\nvar nret \x3d cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(pred__$1,ret__$2,form__$1);\nif(cljs.spec.alpha.invalid_QMARK_(nret)){\nreturn cljs.spec.alpha.explain_1(form__$1,pred__$1,path,via,in$,ret__$2);\n} else {\nvar G__26841 \x3d nret;\nvar G__26842 \x3d forms__$2;\nvar G__26843 \x3d preds__$2;\nret__$1 \x3d G__26841;\nG__24783__$1 \x3d G__26842;\nG__24784__$1 \x3d G__26843;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha24887 \x3d (function (forms,preds,gfn,specs,cform,meta24888){\nthis.forms \x3d forms;\nthis.preds \x3d preds;\nthis.gfn \x3d gfn;\nthis.specs \x3d specs;\nthis.cform \x3d cform;\nthis.meta24888 \x3d meta24888;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24889,meta24888__$1){\nvar self__ \x3d this;\nvar _24889__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24887(self__.forms,self__.preds,self__.gfn,self__.specs,self__.cform,meta24888__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24889){\nvar self__ \x3d this;\nvar _24889__$1 \x3d this;\nreturn self__.meta24888;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (self__.cform.cljs$core$IFn$_invoke$arity$1 ? self__.cform.cljs$core$IFn$_invoke$arity$1(x) : self__.cform.call(null, x));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__24800_SHARP_,p2__24799_SHARP_){\nreturn cljs.spec.alpha.unform(p2__24799_SHARP_,p1__24800_SHARP_);\n}),x,cljs.core.reverse(self__.preds));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.explain_pred_list(self__.forms,self__.preds,path,via,in$,x);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nreturn cljs.spec.alpha.gensub(cljs.core.first(self__.preds),overrides,path,rmap,cljs.core.first(self__.forms));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (cljs.spec.alpha.and_spec_impl.cljs$core$IFn$_invoke$arity$3 ? cljs.spec.alpha.and_spec_impl.cljs$core$IFn$_invoke$arity$3(self__.forms,self__.preds,gfn__$1) : cljs.spec.alpha.and_spec_impl.call(null, self__.forms,self__.preds,gfn__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22and\x22,\x22cljs.spec.alpha/and\x22,-2060279705,null),null,(1),null)),self__.forms)));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22forms\x22,\x22forms\x22,-608443419,null),new cljs.core.Symbol(null,\x22preds\x22,\x22preds\x22,150921777,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22specs\x22,\x22specs\x22,-1227865028,null),new cljs.core.Symbol(null,\x22cform\x22,\x22cform\x22,1319506748,null),new cljs.core.Symbol(null,\x22meta24888\x22,\x22meta24888\x22,1388649442,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha24887\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24887.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha24887\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha24887.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha24887 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha24887(forms,preds,gfn,specs,cform,meta24888){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24887(forms,preds,gfn,specs,cform,meta24888));\n});\n\n\n/**\n * Do not call this directly, use \x27and\x27\n */\ncljs.spec.alpha.and_spec_impl \x3d (function cljs$spec$alpha$and_spec_impl(forms,preds,gfn){\nvar specs \x3d (new cljs.core.Delay((function (){\nreturn cljs.core.mapv.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.specize,preds,forms);\n}),null));\nvar cform \x3d (function (){var G__24814 \x3d cljs.core.count(preds);\nswitch (G__24814) {\ncase (2):\nreturn (function (x){\nvar specs__$1 \x3d cljs.core.deref(specs);\nvar ret \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((0)) : specs__$1.call(null, (0))),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nreturn cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((1)) : specs__$1.call(null, (1))),ret);\n}\n});\n\nbreak;\ncase (3):\nreturn (function (x){\nvar specs__$1 \x3d cljs.core.deref(specs);\nvar ret \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((0)) : specs__$1.call(null, (0))),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nvar ret__$1 \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((1)) : specs__$1.call(null, (1))),ret);\nif(cljs.spec.alpha.invalid_QMARK_(ret__$1)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nreturn cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1((2)) : specs__$1.call(null, (2))),ret__$1);\n}\n}\n});\n\nbreak;\ndefault:\nreturn (function (x){\nvar specs__$1 \x3d cljs.core.deref(specs);\nvar ret \x3d x;\nvar i \x3d (0);\nwhile(true){\nif((i \x3c cljs.core.count(specs__$1))){\nvar nret \x3d cljs.spec.alpha.conform_STAR_((specs__$1.cljs$core$IFn$_invoke$arity$1 ? specs__$1.cljs$core$IFn$_invoke$arity$1(i) : specs__$1.call(null, i)),ret);\nif(cljs.spec.alpha.invalid_QMARK_(nret)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nvar G__26890 \x3d nret;\nvar G__26891 \x3d (i + (1));\nret \x3d G__26890;\ni \x3d G__26891;\ncontinue;\n}\n} else {\nreturn ret;\n}\nbreak;\n}\n});\n\n}\n})();\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24887(forms,preds,gfn,specs,cform,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.spec.alpha.coll_prob \x3d (function cljs$spec$alpha$coll_prob(x,kfn,kform,distinct,count,min_count,max_count,path,via,in$){\nvar pred \x3d (function (){var or__5002__auto__ \x3d kfn;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.coll_QMARK_;\n}\n})();\nvar kform__$1 \x3d (function (){var or__5002__auto__ \x3d kform;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn new cljs.core.Symbol(\x22cljs.core\x22,\x22coll?\x22,\x22cljs.core/coll?\x22,1208130522,null);\n}\n})();\nif((!(cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2(pred,x)))){\nreturn cljs.spec.alpha.explain_1(kform__$1,pred,path,via,in$,x);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d count;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(count,cljs.core.bounded_count(count,x));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22\x3d\x22,\x22cljs.core/\x3d\x22,-1891498332,null),null,(1),null)),(new cljs.core.List(null,count,null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs.core.List(null,cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22count\x22,\x22cljs.core/count\x22,-921270233,null),null,(1),null)),(new cljs.core.List(null,new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null),null,(1),null))))),null,(1),null))], 0)))),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d (function (){var or__5002__auto__ \x3d min_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn max_count;\n}\n})();\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (!(((((function (){var or__5002__auto__ \x3d min_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (0);\n}\n})() \x3c\x3d cljs.core.bounded_count((cljs.core.truth_(max_count)?(max_count + (1)):min_count),x))) \x26\x26 ((cljs.core.bounded_count((cljs.core.truth_(max_count)?(max_count + (1)):min_count),x) \x3c\x3d (function (){var or__5002__auto__ \x3d max_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (9007199254740991);\n}\n})())))));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22\x3c\x3d\x22,\x22cljs.core/\x3c\x3d\x22,1677001748,null),null,(1),null)),(new cljs.core.List(null,(function (){var or__5002__auto__ \x3d min_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (0);\n}\n})(),null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs.core.List(null,cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22count\x22,\x22cljs.core/count\x22,-921270233,null),null,(1),null)),(new cljs.core.List(null,new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null),null,(1),null))))),null,(1),null)),(new cljs.core.List(null,(function (){var or__5002__auto__ \x3d max_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (9007199254740991);\n}\n})(),null,(1),null))], 0)))),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d distinct;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn (((!(cljs.core.empty_QMARK_(x)))) \x26\x26 (cljs.core.not(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.distinct_QMARK_,x))));\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),new cljs.core.Symbol(null,\x22distinct?\x22,\x22distinct?\x22,-1684357959,null),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nreturn null;\n}\n}\n}\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha24957 \x3d (function (forms,preds,gfn,meta24958){\nthis.forms \x3d forms;\nthis.preds \x3d preds;\nthis.gfn \x3d gfn;\nthis.meta24958 \x3d meta24958;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_24959,meta24958__$1){\nvar self__ \x3d this;\nvar _24959__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24957(self__.forms,self__.preds,self__.gfn,meta24958__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_24959){\nvar self__ \x3d this;\nvar _24959__$1 \x3d this;\nreturn self__.meta24958;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar ms \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (p1__24945_SHARP_,p2__24946_SHARP_){\nreturn cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(p1__24945_SHARP_,x,p2__24946_SHARP_);\n}),self__.preds,self__.forms);\nif(cljs.core.truth_(cljs.core.some(cljs.spec.alpha.invalid_QMARK_,ms))){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.merge,ms);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.merge,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__24948_SHARP_){\nreturn cljs.spec.alpha.unform(p1__24948_SHARP_,x);\n}),cljs.core.reverse(self__.preds)));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (p1__24949_SHARP_,p2__24950_SHARP_){\nreturn cljs.spec.alpha.explain_1(p1__24949_SHARP_,p2__24950_SHARP_,path,via,in$,x);\n}),self__.forms,self__.preds));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__24951_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.merge,p1__24951_SHARP_);\n}),cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.spec.gen.alpha.tuple,cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (p1__24952_SHARP_,p2__24953_SHARP_){\nreturn cljs.spec.alpha.gensub(p1__24952_SHARP_,overrides,path,rmap,p2__24953_SHARP_);\n}),self__.preds,self__.forms))], 0));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (cljs.spec.alpha.merge_spec_impl.cljs$core$IFn$_invoke$arity$3 ? cljs.spec.alpha.merge_spec_impl.cljs$core$IFn$_invoke$arity$3(self__.forms,self__.preds,gfn__$1) : cljs.spec.alpha.merge_spec_impl.call(null, self__.forms,self__.preds,gfn__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22merge\x22,\x22cljs.spec.alpha/merge\x22,1420080689,null),null,(1),null)),self__.forms)));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22forms\x22,\x22forms\x22,-608443419,null),new cljs.core.Symbol(null,\x22preds\x22,\x22preds\x22,150921777,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22meta24958\x22,\x22meta24958\x22,62750479,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha24957\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha24957.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha24957\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha24957.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha24957 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha24957(forms,preds,gfn,meta24958){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24957(forms,preds,gfn,meta24958));\n});\n\n\n/**\n * Do not call this directly, use \x27merge\x27\n */\ncljs.spec.alpha.merge_spec_impl \x3d (function cljs$spec$alpha$merge_spec_impl(forms,preds,gfn){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha24957(forms,preds,gfn,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.spec.alpha.empty_coll \x3d new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Symbol(\x22cljs.core\x22,\x22vector?\x22,\x22cljs.core/vector?\x22,-1550392028,null),cljs.core.PersistentVector.EMPTY,new cljs.core.Symbol(\x22cljs.core\x22,\x22set?\x22,\x22cljs.core/set?\x22,-1176684971,null),cljs.core.PersistentHashSet.EMPTY,new cljs.core.Symbol(\x22cljs.core\x22,\x22list?\x22,\x22cljs.core/list?\x22,-684796618,null),cljs.core.List.EMPTY,new cljs.core.Symbol(\x22cljs.core\x22,\x22map?\x22,\x22cljs.core/map?\x22,-1390345523,null),cljs.core.PersistentArrayMap.EMPTY], null);\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha25010 \x3d (function (form,max_count,check_QMARK_,map__24989,gfn,gen_max,pred,cpred,conform_keys,kind_form,addcv,cfns,describe_form,distinct,spec,kfn,gen_into,p__24988,count,min_count,opts,kind,conform_all,conform_into,meta25011){\nthis.form \x3d form;\nthis.max_count \x3d max_count;\nthis.check_QMARK_ \x3d check_QMARK_;\nthis.map__24989 \x3d map__24989;\nthis.gfn \x3d gfn;\nthis.gen_max \x3d gen_max;\nthis.pred \x3d pred;\nthis.cpred \x3d cpred;\nthis.conform_keys \x3d conform_keys;\nthis.kind_form \x3d kind_form;\nthis.addcv \x3d addcv;\nthis.cfns \x3d cfns;\nthis.describe_form \x3d describe_form;\nthis.distinct \x3d distinct;\nthis.spec \x3d spec;\nthis.kfn \x3d kfn;\nthis.gen_into \x3d gen_into;\nthis.p__24988 \x3d p__24988;\nthis.count \x3d count;\nthis.min_count \x3d min_count;\nthis.opts \x3d opts;\nthis.kind \x3d kind;\nthis.conform_all \x3d conform_all;\nthis.conform_into \x3d conform_into;\nthis.meta25011 \x3d meta25011;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25012,meta25011__$1){\nvar self__ \x3d this;\nvar _25012__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25010(self__.form,self__.max_count,self__.check_QMARK_,self__.map__24989,self__.gfn,self__.gen_max,self__.pred,self__.cpred,self__.conform_keys,self__.kind_form,self__.addcv,self__.cfns,self__.describe_form,self__.distinct,self__.spec,self__.kfn,self__.gen_into,self__.p__24988,self__.count,self__.min_count,self__.opts,self__.kind,self__.conform_all,self__.conform_into,meta25011__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25012){\nvar self__ \x3d this;\nvar _25012__$1 \x3d this;\nreturn self__.meta25011;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar spec__$1 \x3d cljs.core.deref(self__.spec);\nif(cljs.core.not((self__.cpred.cljs$core$IFn$_invoke$arity$1 ? self__.cpred.cljs$core$IFn$_invoke$arity$1(x) : self__.cpred.call(null, x)))){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nif(cljs.core.truth_(self__.conform_all)){\nvar vec__25045 \x3d (self__.cfns.cljs$core$IFn$_invoke$arity$1 ? self__.cfns.cljs$core$IFn$_invoke$arity$1(x) : self__.cfns.call(null, x));\nvar init \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25045,(0),null);\nvar add \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25045,(1),null);\nvar complete \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25045,(2),null);\nvar ret \x3d (init.cljs$core$IFn$_invoke$arity$1 ? init.cljs$core$IFn$_invoke$arity$1(x) : init.call(null, x));\nvar i \x3d (0);\nvar G__25053 \x3d cljs.core.seq(x);\nvar vec__25055 \x3d G__25053;\nvar seq__25056 \x3d cljs.core.seq(vec__25055);\nvar first__25057 \x3d cljs.core.first(seq__25056);\nvar seq__25056__$1 \x3d cljs.core.next(seq__25056);\nvar v \x3d first__25057;\nvar vs \x3d seq__25056__$1;\nvar vseq \x3d vec__25055;\nvar ret__$1 \x3d ret;\nvar i__$1 \x3d i;\nvar G__25053__$1 \x3d G__25053;\nwhile(true){\nvar ret__$2 \x3d ret__$1;\nvar i__$2 \x3d i__$1;\nvar vec__25060 \x3d G__25053__$1;\nvar seq__25061 \x3d cljs.core.seq(vec__25060);\nvar first__25062 \x3d cljs.core.first(seq__25061);\nvar seq__25061__$1 \x3d cljs.core.next(seq__25061);\nvar v__$1 \x3d first__25062;\nvar vs__$1 \x3d seq__25061__$1;\nvar vseq__$1 \x3d vec__25060;\nif(vseq__$1){\nvar cv \x3d cljs.spec.alpha.conform_STAR_(spec__$1,v__$1);\nif(cljs.spec.alpha.invalid_QMARK_(cv)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nvar G__26923 \x3d (add.cljs$core$IFn$_invoke$arity$4 ? add.cljs$core$IFn$_invoke$arity$4(ret__$2,i__$2,v__$1,cv) : add.call(null, ret__$2,i__$2,v__$1,cv));\nvar G__26924 \x3d (i__$2 + (1));\nvar G__26925 \x3d vs__$1;\nret__$1 \x3d G__26923;\ni__$1 \x3d G__26924;\nG__25053__$1 \x3d G__26925;\ncontinue;\n}\n} else {\nreturn (complete.cljs$core$IFn$_invoke$arity$1 ? complete.cljs$core$IFn$_invoke$arity$1(ret__$2) : complete.call(null, ret__$2));\n}\nbreak;\n}\n} else {\nif(cljs.core.indexed_QMARK_(x)){\nvar step \x3d (function (){var x__5087__auto__ \x3d (1);\nvar y__5088__auto__ \x3d cljs.core.long$((cljs.core.count(x) / cljs.spec.alpha._STAR_coll_check_limit_STAR_));\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n})();\nvar i \x3d (0);\nwhile(true){\nif((i \x3e\x3d cljs.core.count(x))){\nreturn x;\n} else {\nif(cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$2(spec__$1,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(x,i))){\nvar G__26931 \x3d (i + step);\ni \x3d G__26931;\ncontinue;\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}\nbreak;\n}\n} else {\nvar limit \x3d cljs.spec.alpha._STAR_coll_check_limit_STAR_;\nvar i \x3d (0);\nvar G__25071 \x3d cljs.core.seq(x);\nvar vec__25074 \x3d G__25071;\nvar seq__25075 \x3d cljs.core.seq(vec__25074);\nvar first__25076 \x3d cljs.core.first(seq__25075);\nvar seq__25075__$1 \x3d cljs.core.next(seq__25075);\nvar v \x3d first__25076;\nvar vs \x3d seq__25075__$1;\nvar vseq \x3d vec__25074;\nvar i__$1 \x3d i;\nvar G__25071__$1 \x3d G__25071;\nwhile(true){\nvar i__$2 \x3d i__$1;\nvar vec__25089 \x3d G__25071__$1;\nvar seq__25090 \x3d cljs.core.seq(vec__25089);\nvar first__25091 \x3d cljs.core.first(seq__25090);\nvar seq__25090__$1 \x3d cljs.core.next(seq__25090);\nvar v__$1 \x3d first__25091;\nvar vs__$1 \x3d seq__25090__$1;\nvar vseq__$1 \x3d vec__25089;\nif((((vseq__$1 \x3d\x3d null)) || (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(i__$2,limit)))){\nreturn x;\n} else {\nif(cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$2(spec__$1,v__$1)){\nvar G__26938 \x3d (i__$2 + (1));\nvar G__26939 \x3d vs__$1;\ni__$1 \x3d G__26938;\nG__25071__$1 \x3d G__26939;\ncontinue;\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n\n}\n}\nbreak;\n}\n}\n\n}\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.conform_all)){\nvar spec__$1 \x3d cljs.core.deref(self__.spec);\nvar vec__25113 \x3d (self__.cfns.cljs$core$IFn$_invoke$arity$1 ? self__.cfns.cljs$core$IFn$_invoke$arity$1(x) : self__.cfns.call(null, x));\nvar init \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25113,(0),null);\nvar add \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25113,(1),null);\nvar complete \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25113,(2),null);\nvar ret \x3d (init.cljs$core$IFn$_invoke$arity$1 ? init.cljs$core$IFn$_invoke$arity$1(x) : init.call(null, x));\nvar i \x3d (0);\nvar G__25119 \x3d cljs.core.seq(x);\nvar vec__25120 \x3d G__25119;\nvar seq__25121 \x3d cljs.core.seq(vec__25120);\nvar first__25122 \x3d cljs.core.first(seq__25121);\nvar seq__25121__$1 \x3d cljs.core.next(seq__25121);\nvar v \x3d first__25122;\nvar vs \x3d seq__25121__$1;\nvar vseq \x3d vec__25120;\nvar ret__$1 \x3d ret;\nvar i__$1 \x3d i;\nvar G__25119__$1 \x3d G__25119;\nwhile(true){\nvar ret__$2 \x3d ret__$1;\nvar i__$2 \x3d i__$1;\nvar vec__25125 \x3d G__25119__$1;\nvar seq__25126 \x3d cljs.core.seq(vec__25125);\nvar first__25127 \x3d cljs.core.first(seq__25126);\nvar seq__25126__$1 \x3d cljs.core.next(seq__25126);\nvar v__$1 \x3d first__25127;\nvar vs__$1 \x3d seq__25126__$1;\nvar vseq__$1 \x3d vec__25125;\nif((i__$2 \x3e\x3d cljs.core.count(x))){\nreturn (complete.cljs$core$IFn$_invoke$arity$1 ? complete.cljs$core$IFn$_invoke$arity$1(ret__$2) : complete.call(null, ret__$2));\n} else {\nvar G__26950 \x3d (function (){var G__25131 \x3d ret__$2;\nvar G__25132 \x3d i__$2;\nvar G__25133 \x3d v__$1;\nvar G__25134 \x3d cljs.spec.alpha.unform_STAR_(spec__$1,v__$1);\nreturn (add.cljs$core$IFn$_invoke$arity$4 ? add.cljs$core$IFn$_invoke$arity$4(G__25131,G__25132,G__25133,G__25134) : add.call(null, G__25131,G__25132,G__25133,G__25134));\n})();\nvar G__26951 \x3d (i__$2 + (1));\nvar G__26952 \x3d vs__$1;\nret__$1 \x3d G__26950;\ni__$1 \x3d G__26951;\nG__25119__$1 \x3d G__26952;\ncontinue;\n}\nbreak;\n}\n} else {\nreturn x;\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar or__5002__auto__ \x3d cljs.spec.alpha.coll_prob(x,self__.kind,self__.kind_form,self__.distinct,self__.count,self__.min_count,self__.max_count,path,via,in$);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,(function (){var G__25138 \x3d cljs.core.keep.cljs$core$IFn$_invoke$arity$2(cljs.core.identity,cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (i,v){\nvar k \x3d (self__.kfn.cljs$core$IFn$_invoke$arity$2 ? self__.kfn.cljs$core$IFn$_invoke$arity$2(i,v) : self__.kfn.call(null, i,v));\nif(cljs.core.truth_((self__.check_QMARK_.cljs$core$IFn$_invoke$arity$1 ? self__.check_QMARK_.cljs$core$IFn$_invoke$arity$1(v) : self__.check_QMARK_.call(null, v)))){\nreturn null;\n} else {\nvar prob \x3d cljs.spec.alpha.explain_1(self__.form,self__.pred,path,via,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(in$,k),v);\nreturn prob;\n}\n}),cljs.core.range.cljs$core$IFn$_invoke$arity$0(),x));\nvar fexpr__25137 \x3d (cljs.core.truth_(self__.conform_all)?cljs.core.identity:cljs.core.partial.cljs$core$IFn$_invoke$arity$2(cljs.core.take,cljs.spec.alpha._STAR_coll_error_limit_STAR_));\nreturn (fexpr__25137.cljs$core$IFn$_invoke$arity$1 ? fexpr__25137.cljs$core$IFn$_invoke$arity$1(G__25138) : fexpr__25137.call(null, G__25138));\n})());\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nvar pgen \x3d cljs.spec.alpha.gensub(self__.pred,overrides,path,rmap,self__.form);\nreturn cljs.spec.gen.alpha.bind.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(cljs.core.truth_(self__.gen_into)?cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.gen_into], 0)):(cljs.core.truth_(self__.kind)?cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__24977_SHARP_){\nif(cljs.core.empty_QMARK_(p1__24977_SHARP_)){\nreturn p1__24977_SHARP_;\n} else {\nreturn cljs.core.empty(p1__24977_SHARP_);\n}\n}),cljs.spec.alpha.gensub(self__.kind,overrides,path,rmap,self__.form)], 0)):cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.PersistentVector.EMPTY], 0))\n)),(function (init){\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__24978_SHARP_){\nif(cljs.core.vector_QMARK_(init)){\nreturn p1__24978_SHARP_;\n} else {\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(init,p1__24978_SHARP_);\n}\n}),(cljs.core.truth_(self__.distinct)?(cljs.core.truth_(self__.count)?cljs.spec.gen.alpha.vector_distinct.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([pgen,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22num-elements\x22,\x22num-elements\x22,1960422107),self__.count,new cljs.core.Keyword(null,\x22max-tries\x22,\x22max-tries\x22,-1824441792),(100)], null)], 0)):cljs.spec.gen.alpha.vector_distinct.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([pgen,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22min-elements\x22,\x22min-elements\x22,949370780),(function (){var or__5002__auto__ \x3d self__.min_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (0);\n}\n})(),new cljs.core.Keyword(null,\x22max-elements\x22,\x22max-elements\x22,433034073),(function (){var or__5002__auto__ \x3d self__.max_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar x__5087__auto__ \x3d self__.gen_max;\nvar y__5088__auto__ \x3d ((2) * (function (){var or__5002__auto____$1 \x3d self__.min_count;\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn (0);\n}\n})());\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n}\n})(),new cljs.core.Keyword(null,\x22max-tries\x22,\x22max-tries\x22,-1824441792),(100)], null)], 0))):(cljs.core.truth_(self__.count)?cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([pgen,self__.count], 0)):(cljs.core.truth_((function (){var or__5002__auto__ \x3d self__.min_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn self__.max_count;\n}\n})())?cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([pgen,(function (){var or__5002__auto__ \x3d self__.min_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (0);\n}\n})(),(function (){var or__5002__auto__ \x3d self__.max_count;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar x__5087__auto__ \x3d self__.gen_max;\nvar y__5088__auto__ \x3d ((2) * (function (){var or__5002__auto____$1 \x3d self__.min_count;\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn (0);\n}\n})());\nreturn ((x__5087__auto__ \x3e y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);\n}\n})()], 0)):cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([pgen,(0),self__.gen_max], 0))\n)))], 0));\n})], 0));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.every_impl.cljs$core$IFn$_invoke$arity$4(self__.form,self__.pred,self__.opts,gfn__$1);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar or__5002__auto__ \x3d self__.describe_form;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22every\x22,\x22cljs.spec.alpha/every\x22,123912744,null),null,(1),null)),(new cljs.core.List(null,self__.form,null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(cljs.core.identity,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([self__.opts], 0))], 0))));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 25, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22form\x22,\x22form\x22,16469056,null),new cljs.core.Symbol(null,\x22max-count\x22,\x22max-count\x22,-1115250464,null),new cljs.core.Symbol(null,\x22check?\x22,\x22check?\x22,409539557,null),new cljs.core.Symbol(null,\x22map__24989\x22,\x22map__24989\x22,212007462,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22gen-max\x22,\x22gen-max\x22,846851082,null),new cljs.core.Symbol(null,\x22pred\x22,\x22pred\x22,-727012372,null),new cljs.core.Symbol(null,\x22cpred\x22,\x22cpred\x22,-540353554,null),new cljs.core.Symbol(null,\x22conform-keys\x22,\x22conform-keys\x22,-159510287,null),new cljs.core.Symbol(null,\x22kind-form\x22,\x22kind-form\x22,1155997457,null),new cljs.core.Symbol(null,\x22addcv\x22,\x22addcv\x22,-1552991247,null),new cljs.core.Symbol(null,\x22cfns\x22,\x22cfns\x22,1335482066,null),new cljs.core.Symbol(null,\x22describe-form\x22,\x22describe-form\x22,-1410156588,null),new cljs.core.Symbol(null,\x22distinct\x22,\x22distinct\x22,-148347594,null),new cljs.core.Symbol(null,\x22spec\x22,\x22spec\x22,1988051928,null),new cljs.core.Symbol(null,\x22kfn\x22,\x22kfn\x22,729311001,null),new cljs.core.Symbol(null,\x22gen-into\x22,\x22gen-into\x22,592640985,null),new cljs.core.Symbol(null,\x22p__24988\x22,\x22p__24988\x22,-488259110,null),new cljs.core.Symbol(null,\x22count\x22,\x22count\x22,-514511684,null),new cljs.core.Symbol(null,\x22min-count\x22,\x22min-count\x22,-1059726756,null),new cljs.core.Symbol(null,\x22opts\x22,\x22opts\x22,1795607228,null),new cljs.core.Symbol(null,\x22kind\x22,\x22kind\x22,923265724,null),new cljs.core.Symbol(null,\x22conform-all\x22,\x22conform-all\x22,-980179459,null),new cljs.core.Symbol(null,\x22conform-into\x22,\x22conform-into\x22,-1039113729,null),new cljs.core.Symbol(null,\x22meta25011\x22,\x22meta25011\x22,-1747196271,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha25010\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25010.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha25010\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha25010.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha25010 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha25010(form,max_count,check_QMARK_,map__24989,gfn,gen_max,pred,cpred,conform_keys,kind_form,addcv,cfns,describe_form,distinct,spec,kfn,gen_into,p__24988,count,min_count,opts,kind,conform_all,conform_into,meta25011){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25010(form,max_count,check_QMARK_,map__24989,gfn,gen_max,pred,cpred,conform_keys,kind_form,addcv,cfns,describe_form,distinct,spec,kfn,gen_into,p__24988,count,min_count,opts,kind,conform_all,conform_into,meta25011));\n});\n\n\n/**\n * Do not call this directly, use \x27every\x27, \x27every-kv\x27, \x27coll-of\x27 or \x27map-of\x27\n */\ncljs.spec.alpha.every_impl \x3d (function cljs$spec$alpha$every_impl(var_args){\nvar G__24984 \x3d arguments.length;\nswitch (G__24984) {\ncase 3:\nreturn cljs.spec.alpha.every_impl.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ncase 4:\nreturn cljs.spec.alpha.every_impl.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.every_impl.cljs$core$IFn$_invoke$arity$3 \x3d (function (form,pred,opts){\nreturn cljs.spec.alpha.every_impl.cljs$core$IFn$_invoke$arity$4(form,pred,opts,null);\n}));\n\n(cljs.spec.alpha.every_impl.cljs$core$IFn$_invoke$arity$4 \x3d (function (form,pred,p__24988,gfn){\nvar map__24989 \x3d p__24988;\nvar map__24989__$1 \x3d cljs.core.__destructure_map(map__24989);\nvar opts \x3d map__24989__$1;\nvar max_count \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(null,\x22max-count\x22,\x22max-count\x22,1539185305));\nvar kind_form \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22kind-form\x22,\x22cljs.spec.alpha/kind-form\x22,-1047104697));\nvar gen_max \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__24989__$1,new cljs.core.Keyword(null,\x22gen-max\x22,\x22gen-max\x22,-793680445),(20));\nvar cpred \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22cpred\x22,\x22cljs.spec.alpha/cpred\x22,-693471218));\nvar conform_keys \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(null,\x22conform-keys\x22,\x22conform-keys\x22,-1800041814));\nvar describe_form \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22describe\x22,\x22cljs.spec.alpha/describe\x22,1883026911));\nvar distinct \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(null,\x22distinct\x22,\x22distinct\x22,-1788879121));\nvar kfn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22kfn\x22,\x22cljs.spec.alpha/kfn\x22,672643897));\nvar count \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(null,\x22count\x22,\x22count\x22,2139924085));\nvar min_count \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(null,\x22min-count\x22,\x22min-count\x22,1594709013));\nvar kind \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(null,\x22kind\x22,\x22kind\x22,-717265803));\nvar conform_all \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22conform-all\x22,\x22cljs.spec.alpha/conform-all\x22,45201917));\nvar conform_into \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__24989__$1,new cljs.core.Keyword(null,\x22into\x22,\x22into\x22,-150836029));\nvar gen_into \x3d (cljs.core.truth_(conform_into)?cljs.core.empty(conform_into):cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.spec.alpha.empty_coll,kind_form));\nvar spec \x3d (new cljs.core.Delay((function (){\nreturn cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(pred);\n}),null));\nvar check_QMARK_ \x3d (function (p1__24972_SHARP_){\nreturn cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(spec),p1__24972_SHARP_);\n});\nvar kfn__$1 \x3d (function (){var or__5002__auto__ \x3d kfn;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (function (i,v){\nreturn i;\n});\n}\n})();\nvar addcv \x3d (function (ret,i,v,cv){\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ret,cv);\n});\nvar cfns \x3d (function (x){\nif(((cljs.core.vector_QMARK_(x)) \x26\x26 (((cljs.core.not(conform_into)) || (cljs.core.vector_QMARK_(conform_into)))))){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.identity,(function (ret,i,v,cv){\nif((v \x3d\x3d\x3d cv)){\nreturn ret;\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,i,cv);\n}\n}),cljs.core.identity], null);\n} else {\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.map_QMARK_(x);\nif(and__5000__auto__){\nvar or__5002__auto__ \x3d (function (){var and__5000__auto____$1 \x3d kind;\nif(cljs.core.truth_(and__5000__auto____$1)){\nreturn cljs.core.not(conform_into);\n} else {\nreturn and__5000__auto____$1;\n}\n})();\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.map_QMARK_(conform_into);\n}\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [(cljs.core.truth_(conform_keys)?cljs.core.empty:cljs.core.identity),(function (ret,i,v,cv){\nif((((v \x3d\x3d\x3d cv)) \x26\x26 (cljs.core.not(conform_keys)))){\nreturn ret;\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,cljs.core.nth.cljs$core$IFn$_invoke$arity$2((cljs.core.truth_(conform_keys)?cv:v),(0)),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cv,(1)));\n}\n}),cljs.core.identity], null);\n} else {\nif(((cljs.core.list_QMARK_(conform_into)) || (((cljs.core.seq_QMARK_(conform_into)) || (((cljs.core.not(conform_into)) \x26\x26 (((cljs.core.list_QMARK_(x)) || (cljs.core.seq_QMARK_(x)))))))))){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.empty,addcv,cljs.core.reverse], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [(function (p1__24975_SHARP_){\nreturn cljs.core.empty((function (){var or__5002__auto__ \x3d conform_into;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn p1__24975_SHARP_;\n}\n})());\n}),addcv,cljs.core.identity], null);\n\n}\n}\n}\n});\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25010(form,max_count,check_QMARK_,map__24989__$1,gfn,gen_max,pred,cpred,conform_keys,kind_form,addcv,cfns,describe_form,distinct,spec,kfn__$1,gen_into,p__24988,count,min_count,opts,kind,conform_all,conform_into,cljs.core.PersistentArrayMap.EMPTY));\n}));\n\n(cljs.spec.alpha.every_impl.cljs$lang$maxFixedArity \x3d 4);\n\ncljs.spec.alpha.accept \x3d (function cljs$spec$alpha$accept(x){\nreturn new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),x], null);\n});\ncljs.spec.alpha.accept_QMARK_ \x3d (function cljs$spec$alpha$accept_QMARK_(p__25204){\nvar map__25205 \x3d p__25204;\nvar map__25205__$1 \x3d cljs.core.__destructure_map(map__25205);\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25205__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),op);\n});\ncljs.spec.alpha.pcat_STAR_ \x3d (function cljs$spec$alpha$pcat_STAR_(p__25222){\nvar map__25226 \x3d p__25222;\nvar map__25226__$1 \x3d cljs.core.__destructure_map(map__25226);\nvar vec__25227 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25226__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar seq__25228 \x3d cljs.core.seq(vec__25227);\nvar first__25229 \x3d cljs.core.first(seq__25228);\nvar seq__25228__$1 \x3d cljs.core.next(seq__25228);\nvar p1 \x3d first__25229;\nvar pr \x3d seq__25228__$1;\nvar ps \x3d vec__25227;\nvar vec__25230 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25226__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942));\nvar seq__25231 \x3d cljs.core.seq(vec__25230);\nvar first__25232 \x3d cljs.core.first(seq__25231);\nvar seq__25231__$1 \x3d cljs.core.next(seq__25231);\nvar k1 \x3d first__25232;\nvar kr \x3d seq__25231__$1;\nvar ks \x3d vec__25230;\nvar vec__25233 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25226__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar seq__25234 \x3d cljs.core.seq(vec__25233);\nvar first__25235 \x3d cljs.core.first(seq__25234);\nvar seq__25234__$1 \x3d cljs.core.next(seq__25234);\nvar f1 \x3d first__25235;\nvar fr \x3d seq__25234__$1;\nvar forms \x3d vec__25233;\nvar ret \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25226__$1,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814));\nvar rep_PLUS_ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25226__$1,new cljs.core.Keyword(null,\x22rep+\x22,\x22rep+\x22,-281382396));\nif(cljs.core.every_QMARK_(cljs.core.identity,ps)){\nif(cljs.spec.alpha.accept_QMARK_(p1)){\nvar rp \x3d new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814).cljs$core$IFn$_invoke$arity$1(p1);\nvar ret__$1 \x3d cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ret,(cljs.core.truth_(ks)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k1,rp]):rp));\nif(pr){\nvar G__25249 \x3d new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),pr,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942),kr,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),fr,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),ret__$1], null);\nreturn (cljs.spec.alpha.pcat_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.spec.alpha.pcat_STAR_.cljs$core$IFn$_invoke$arity$1(G__25249) : cljs.spec.alpha.pcat_STAR_.call(null, G__25249));\n} else {\nreturn cljs.spec.alpha.accept(ret__$1);\n}\n} else {\nreturn new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),ps,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),ret,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942),ks,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),forms,new cljs.core.Keyword(null,\x22rep+\x22,\x22rep+\x22,-281382396),rep_PLUS_], null);\n}\n} else {\nreturn null;\n}\n});\ncljs.spec.alpha.pcat \x3d (function cljs$spec$alpha$pcat(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27021 \x3d arguments.length;\nvar i__5727__auto___27022 \x3d (0);\nwhile(true){\nif((i__5727__auto___27022 \x3c len__5726__auto___27021)){\nargs__5732__auto__.push((arguments[i__5727__auto___27022]));\n\nvar G__27023 \x3d (i__5727__auto___27022 + (1));\ni__5727__auto___27022 \x3d G__27023;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.alpha.pcat.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.alpha.pcat.cljs$core$IFn$_invoke$arity$variadic \x3d (function (ps){\nreturn cljs.spec.alpha.pcat_STAR_(new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),ps,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),cljs.core.PersistentVector.EMPTY], null));\n}));\n\n(cljs.spec.alpha.pcat.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.alpha.pcat.cljs$lang$applyTo \x3d (function (seq25256){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq25256));\n}));\n\n/**\n * Do not call this directly, use \x27cat\x27\n */\ncljs.spec.alpha.cat_impl \x3d (function cljs$spec$alpha$cat_impl(ks,ps,forms){\nreturn cljs.spec.alpha.pcat_STAR_(new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942),ks,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),ps,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),forms,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),cljs.core.PersistentArrayMap.EMPTY], null));\n});\ncljs.spec.alpha.rep_STAR_ \x3d (function cljs$spec$alpha$rep_STAR_(p1,p2,ret,splice,form){\nif(cljs.core.truth_(p1)){\nvar r \x3d new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),new cljs.core.Keyword(null,\x22p2\x22,\x22p2\x22,905500641),p2,new cljs.core.Keyword(null,\x22splice\x22,\x22splice\x22,449588165),splice,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),form,new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),cljs.core.random_uuid()], null);\nif(cljs.spec.alpha.accept_QMARK_(p1)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(r,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954),p2,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ret,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814).cljs$core$IFn$_invoke$arity$1(p1))], 0));\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(r,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954),p1,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),ret], 0));\n}\n} else {\nreturn null;\n}\n});\n/**\n * Do not call this directly, use \x27*\x27\n */\ncljs.spec.alpha.rep_impl \x3d (function cljs$spec$alpha$rep_impl(form,p){\nreturn cljs.spec.alpha.rep_STAR_(p,p,cljs.core.PersistentVector.EMPTY,false,form);\n});\n/**\n * Do not call this directly, use \x27+\x27\n */\ncljs.spec.alpha.rep_PLUS_impl \x3d (function cljs$spec$alpha$rep_PLUS_impl(form,p){\nreturn cljs.spec.alpha.pcat_STAR_(new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [p,cljs.spec.alpha.rep_STAR_(p,p,cljs.core.PersistentVector.EMPTY,true,form)], null),new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),cljs.core.vec(cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,form,null,(1),null)),(new cljs.core.List(null,cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22*\x22,\x22cljs.spec.alpha/*\x22,-1238084288,null),null,(1),null)),(new cljs.core.List(null,form,null,(1),null))))),null,(1),null)))))),new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),cljs.core.PersistentVector.EMPTY,new cljs.core.Keyword(null,\x22rep+\x22,\x22rep+\x22,-281382396),form], null));\n});\n/**\n * Do not call this directly, use \x27\x26\x27\n */\ncljs.spec.alpha.amp_impl \x3d (function cljs$spec$alpha$amp_impl(re,re_form,preds,pred_forms){\nreturn new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954),re,new cljs.core.Keyword(null,\x22amp\x22,\x22amp\x22,271690571),re_form,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),preds,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),pred_forms], null);\n});\ncljs.spec.alpha.filter_alt \x3d (function cljs$spec$alpha$filter_alt(ps,ks,forms,f){\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d ks;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn forms;\n}\n})())){\nvar pks \x3d cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__25283_SHARP_){\nvar G__25287 \x3d cljs.core.first(p1__25283_SHARP_);\nreturn (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__25287) : f.call(null, G__25287));\n}),cljs.core.map.cljs$core$IFn$_invoke$arity$4(cljs.core.vector,ps,(function (){var or__5002__auto__ \x3d cljs.core.seq(ks);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})(),(function (){var or__5002__auto__ \x3d cljs.core.seq(forms);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})()));\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.seq(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.first,pks)),(cljs.core.truth_(ks)?cljs.core.seq(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.second,pks)):null),(cljs.core.truth_(forms)?cljs.core.seq(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__25284_SHARP_){\nreturn cljs.core.nth.cljs$core$IFn$_invoke$arity$2(p1__25284_SHARP_,(2));\n}),pks)):null)], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.seq(cljs.core.filter.cljs$core$IFn$_invoke$arity$2(f,ps)),ks,forms], null);\n}\n});\ncljs.spec.alpha.alt_STAR_ \x3d (function cljs$spec$alpha$alt_STAR_(ps,ks,forms){\nvar vec__25305 \x3d cljs.spec.alpha.filter_alt(ps,ks,forms,cljs.core.identity);\nvar vec__25308 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25305,(0),null);\nvar seq__25309 \x3d cljs.core.seq(vec__25308);\nvar first__25310 \x3d cljs.core.first(seq__25309);\nvar seq__25309__$1 \x3d cljs.core.next(seq__25309);\nvar p1 \x3d first__25310;\nvar pr \x3d seq__25309__$1;\nvar ps__$1 \x3d vec__25308;\nvar vec__25311 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25305,(1),null);\nvar k1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25311,(0),null);\nvar ks__$1 \x3d vec__25311;\nvar forms__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25305,(2),null);\nif(cljs.core.truth_(ps__$1)){\nvar ret \x3d new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),ps__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942),ks__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),forms__$1], null);\nif((pr \x3d\x3d null)){\nif(cljs.core.truth_(k1)){\nif(cljs.spec.alpha.accept_QMARK_(p1)){\nreturn cljs.spec.alpha.accept(cljs.spec.alpha.tagged_ret(k1,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814).cljs$core$IFn$_invoke$arity$1(p1)));\n} else {\nreturn ret;\n}\n} else {\nreturn p1;\n}\n} else {\nreturn ret;\n}\n} else {\nreturn null;\n}\n});\ncljs.spec.alpha.alts \x3d (function cljs$spec$alpha$alts(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___27060 \x3d arguments.length;\nvar i__5727__auto___27061 \x3d (0);\nwhile(true){\nif((i__5727__auto___27061 \x3c len__5726__auto___27060)){\nargs__5732__auto__.push((arguments[i__5727__auto___27061]));\n\nvar G__27063 \x3d (i__5727__auto___27061 + (1));\ni__5727__auto___27061 \x3d G__27063;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((0) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((0)),(0),null)):null);\nreturn cljs.spec.alpha.alts.cljs$core$IFn$_invoke$arity$variadic(argseq__5733__auto__);\n});\n\n(cljs.spec.alpha.alts.cljs$core$IFn$_invoke$arity$variadic \x3d (function (ps){\nreturn cljs.spec.alpha.alt_STAR_(ps,null,null);\n}));\n\n(cljs.spec.alpha.alts.cljs$lang$maxFixedArity \x3d (0));\n\n/** @this {Function} */\n(cljs.spec.alpha.alts.cljs$lang$applyTo \x3d (function (seq25314){\nvar self__5712__auto__ \x3d this;\nreturn self__5712__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq25314));\n}));\n\ncljs.spec.alpha.alt2 \x3d (function cljs$spec$alpha$alt2(p1,p2){\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d p1;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn p2;\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn cljs.spec.alpha.alts.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([p1,p2], 0));\n} else {\nvar or__5002__auto__ \x3d p1;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn p2;\n}\n}\n});\n/**\n * Do not call this directly, use \x27alt\x27\n */\ncljs.spec.alpha.alt_impl \x3d (function cljs$spec$alpha$alt_impl(ks,ps,forms){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.alt_STAR_(ps,ks,forms),new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),cljs.core.random_uuid());\n});\n/**\n * Do not call this directly, use \x27?\x27\n */\ncljs.spec.alpha.maybe_impl \x3d (function cljs$spec$alpha$maybe_impl(p,form){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.alt_STAR_(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [p,cljs.spec.alpha.accept(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950))], null),null,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [form,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950)], null)),new cljs.core.Keyword(null,\x22maybe\x22,\x22maybe\x22,-314397560),form);\n});\ncljs.spec.alpha.noret_QMARK_ \x3d (function cljs$spec$alpha$noret_QMARK_(p1,pret){\nvar or__5002__auto__ \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(pret,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950));\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (function (){var and__5000__auto__ \x3d (function (){var G__25379 \x3d new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252).cljs$core$IFn$_invoke$arity$1(cljs.spec.alpha.reg_resolve_BANG_(p1));\nvar fexpr__25378 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),null,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),null], null), null);\nreturn (fexpr__25378.cljs$core$IFn$_invoke$arity$1 ? fexpr__25378.cljs$core$IFn$_invoke$arity$1(G__25379) : fexpr__25378.call(null, G__25379));\n})();\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.empty_QMARK_(pret);\n} else {\nreturn and__5000__auto__;\n}\n})();\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn null;\n}\n}\n});\ncljs.spec.alpha.accept_nil_QMARK_ \x3d (function cljs$spec$alpha$accept_nil_QMARK_(p){\nvar map__25389 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25389__$1 \x3d cljs.core.__destructure_map(map__25389);\nvar p__$1 \x3d map__25389__$1;\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25389__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar ps \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25389__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar p1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25389__$1,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954));\nvar p2 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25389__$1,new cljs.core.Keyword(null,\x22p2\x22,\x22p2\x22,905500641));\nvar forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25389__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar G__25391 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25391)){\nreturn true;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25391)){\nreturn null;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25391)){\nvar and__5000__auto__ \x3d (cljs.spec.alpha.accept_nil_QMARK_.cljs$core$IFn$_invoke$arity$1 ? cljs.spec.alpha.accept_nil_QMARK_.cljs$core$IFn$_invoke$arity$1(p1) : cljs.spec.alpha.accept_nil_QMARK_.call(null, p1));\nif(cljs.core.truth_(and__5000__auto__)){\nvar ret \x3d cljs.spec.alpha.and_preds(cljs.spec.alpha.preturn(p1),ps,cljs.core.next(forms));\nreturn (!(cljs.spec.alpha.invalid_QMARK_(ret)));\n} else {\nreturn and__5000__auto__;\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25391)){\nvar or__5002__auto__ \x3d (p1 \x3d\x3d\x3d p2);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn (cljs.spec.alpha.accept_nil_QMARK_.cljs$core$IFn$_invoke$arity$1 ? cljs.spec.alpha.accept_nil_QMARK_.cljs$core$IFn$_invoke$arity$1(p1) : cljs.spec.alpha.accept_nil_QMARK_.call(null, p1));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25391)){\nreturn cljs.core.every_QMARK_(cljs.spec.alpha.accept_nil_QMARK_,ps);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25391)){\nreturn cljs.core.some(cljs.spec.alpha.accept_nil_QMARK_,ps);\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25391)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n});\ncljs.spec.alpha.preturn \x3d (function cljs$spec$alpha$preturn(p){\nvar map__25405 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25405__$1 \x3d cljs.core.__destructure_map(map__25405);\nvar p__$1 \x3d map__25405__$1;\nvar vec__25406 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25405__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar seq__25407 \x3d cljs.core.seq(vec__25406);\nvar first__25408 \x3d cljs.core.first(seq__25407);\nvar seq__25407__$1 \x3d cljs.core.next(seq__25407);\nvar p0 \x3d first__25408;\nvar pr \x3d seq__25407__$1;\nvar ps \x3d vec__25406;\nvar vec__25409 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25405__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942));\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25409,(0),null);\nvar ks \x3d vec__25409;\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25405__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar p1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25405__$1,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954));\nvar ret \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25405__$1,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814));\nvar forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25405__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar G__25415 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25415)){\nreturn ret;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25415)){\nreturn null;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25415)){\nvar pret \x3d (cljs.spec.alpha.preturn.cljs$core$IFn$_invoke$arity$1 ? cljs.spec.alpha.preturn.cljs$core$IFn$_invoke$arity$1(p1) : cljs.spec.alpha.preturn.call(null, p1));\nif(cljs.core.truth_(cljs.spec.alpha.noret_QMARK_(p1,pret))){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950);\n} else {\nreturn cljs.spec.alpha.and_preds(pret,ps,forms);\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25415)){\nreturn cljs.spec.alpha.add_ret(p1,ret,k);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25415)){\nreturn cljs.spec.alpha.add_ret(p0,ret,k);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25415)){\nvar vec__25418 \x3d cljs.spec.alpha.filter_alt(ps,ks,forms,cljs.spec.alpha.accept_nil_QMARK_);\nvar vec__25421 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25418,(0),null);\nvar p0__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25421,(0),null);\nvar vec__25424 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25418,(1),null);\nvar k0 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25424,(0),null);\nvar r \x3d (((p0__$1 \x3d\x3d null))?new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950):(cljs.spec.alpha.preturn.cljs$core$IFn$_invoke$arity$1 ? cljs.spec.alpha.preturn.cljs$core$IFn$_invoke$arity$1(p0__$1) : cljs.spec.alpha.preturn.call(null, p0__$1)));\nif(cljs.core.truth_(k0)){\nreturn cljs.spec.alpha.tagged_ret(k0,r);\n} else {\nreturn r;\n}\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25415)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n});\ncljs.spec.alpha.op_unform \x3d (function cljs$spec$alpha$op_unform(p,x){\nvar map__25443 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25443__$1 \x3d cljs.core.__destructure_map(map__25443);\nvar p__$1 \x3d map__25443__$1;\nvar vec__25444 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar seq__25445 \x3d cljs.core.seq(vec__25444);\nvar first__25446 \x3d cljs.core.first(seq__25445);\nvar seq__25445__$1 \x3d cljs.core.next(seq__25445);\nvar p0 \x3d first__25446;\nvar pr \x3d seq__25445__$1;\nvar ps \x3d vec__25444;\nvar vec__25448 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942));\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25448,(0),null);\nvar ks \x3d vec__25448;\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar p1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954));\nvar ret \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814));\nvar forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar rep_PLUS_ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(null,\x22rep+\x22,\x22rep+\x22,-281382396));\nvar maybe \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25443__$1,new cljs.core.Keyword(null,\x22maybe\x22,\x22maybe\x22,-314397560));\nvar kps \x3d cljs.core.zipmap(ks,ps);\nvar G__25453 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25453)){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [ret], null);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25453)){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.alpha.unform(p__$1,x)], null);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25453)){\nvar px \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__25439_SHARP_,p2__25438_SHARP_){\nreturn cljs.spec.alpha.unform(p2__25438_SHARP_,p1__25439_SHARP_);\n}),x,cljs.core.reverse(ps));\nreturn (cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2(p1,px) : cljs.spec.alpha.op_unform.call(null, p1,px));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25453)){\nreturn cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic((function (p1__25440_SHARP_){\nreturn (cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2(p1,p1__25440_SHARP_) : cljs.spec.alpha.op_unform.call(null, p1,p1__25440_SHARP_));\n}),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([x], 0));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25453)){\nif(cljs.core.truth_(rep_PLUS_)){\nreturn cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic((function (p1__25441_SHARP_){\nreturn (cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2(p0,p1__25441_SHARP_) : cljs.spec.alpha.op_unform.call(null, p0,p1__25441_SHARP_));\n}),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([x], 0));\n} else {\nreturn cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic((function (k__$1){\nif(cljs.core.contains_QMARK_(x,k__$1)){\nvar G__25468 \x3d (kps.cljs$core$IFn$_invoke$arity$1 ? kps.cljs$core$IFn$_invoke$arity$1(k__$1) : kps.call(null, k__$1));\nvar G__25469 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(x,k__$1);\nreturn (cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2(G__25468,G__25469) : cljs.spec.alpha.op_unform.call(null, G__25468,G__25469));\n} else {\nreturn null;\n}\n}),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([ks], 0));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25453)){\nif(cljs.core.truth_(maybe)){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.spec.alpha.unform(p0,x)], null);\n} else {\nvar vec__25471 \x3d x;\nvar k__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25471,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25471,(1),null);\nvar G__25474 \x3d (kps.cljs$core$IFn$_invoke$arity$1 ? kps.cljs$core$IFn$_invoke$arity$1(k__$1) : kps.call(null, k__$1));\nvar G__25475 \x3d v;\nreturn (cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.op_unform.cljs$core$IFn$_invoke$arity$2(G__25474,G__25475) : cljs.spec.alpha.op_unform.call(null, G__25474,G__25475));\n}\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25453)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n});\ncljs.spec.alpha.add_ret \x3d (function cljs$spec$alpha$add_ret(p,r,k){\nvar map__25480 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25480__$1 \x3d cljs.core.__destructure_map(map__25480);\nvar p__$1 \x3d map__25480__$1;\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25480__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar ps \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25480__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar splice \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25480__$1,new cljs.core.Keyword(null,\x22splice\x22,\x22splice\x22,449588165));\nvar prop \x3d (function (){\nvar ret \x3d cljs.spec.alpha.preturn(p__$1);\nif(cljs.core.empty_QMARK_(ret)){\nreturn r;\n} else {\nvar G__25483 \x3d r;\nvar G__25484 \x3d (cljs.core.truth_(k)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,ret]):ret);\nvar fexpr__25482 \x3d (cljs.core.truth_(splice)?cljs.core.into:cljs.core.conj);\nreturn (fexpr__25482.cljs$core$IFn$_invoke$arity$2 ? fexpr__25482.cljs$core$IFn$_invoke$arity$2(G__25483,G__25484) : fexpr__25482.call(null, G__25483,G__25484));\n}\n});\nvar G__25486 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25486)){\nreturn r;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25486)){\nvar ret \x3d cljs.spec.alpha.preturn(p__$1);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ret,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950))){\nreturn r;\n} else {\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(r,(cljs.core.truth_(k)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,ret]):ret));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25486)){\nvar ret \x3d cljs.spec.alpha.preturn(p__$1);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ret,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950))){\nreturn r;\n} else {\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(r,(cljs.core.truth_(k)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,ret]):ret));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25486)){\nvar ret \x3d cljs.spec.alpha.preturn(p__$1);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ret,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950))){\nreturn r;\n} else {\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(r,(cljs.core.truth_(k)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,ret]):ret));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25486)){\nreturn prop();\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25486)){\nreturn prop();\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25486)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n});\ncljs.spec.alpha.deriv \x3d (function cljs$spec$alpha$deriv(p,x){\nvar map__25501 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25501__$1 \x3d cljs.core.__destructure_map(map__25501);\nvar p__$1 \x3d map__25501__$1;\nvar forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar p2 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22p2\x22,\x22p2\x22,905500641));\nvar vec__25502 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar seq__25503 \x3d cljs.core.seq(vec__25502);\nvar first__25504 \x3d cljs.core.first(seq__25503);\nvar seq__25503__$1 \x3d cljs.core.next(seq__25503);\nvar p0 \x3d first__25504;\nvar pr \x3d seq__25503__$1;\nvar ps \x3d vec__25502;\nvar ret \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814));\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar splice \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22splice\x22,\x22splice\x22,449588165));\nvar vec__25505 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942));\nvar seq__25506 \x3d cljs.core.seq(vec__25505);\nvar first__25507 \x3d cljs.core.first(seq__25506);\nvar seq__25506__$1 \x3d cljs.core.next(seq__25506);\nvar k0 \x3d first__25507;\nvar kr \x3d seq__25506__$1;\nvar ks \x3d vec__25505;\nvar amp \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22amp\x22,\x22amp\x22,271690571));\nvar p1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25501__$1,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954));\nif(cljs.core.truth_(p__$1)){\nvar G__25513 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25513)){\nreturn null;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25513)){\nvar ret__$1 \x3d cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(p__$1,x,p__$1);\nif(cljs.spec.alpha.invalid_QMARK_(ret__$1)){\nreturn null;\n} else {\nreturn cljs.spec.alpha.accept(ret__$1);\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25513)){\nvar temp__5804__auto__ \x3d (cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2(p1,x) : cljs.spec.alpha.deriv.call(null, p1,x));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar p1__$1 \x3d temp__5804__auto__;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252).cljs$core$IFn$_invoke$arity$1(p1__$1))){\nvar ret__$1 \x3d cljs.spec.alpha.and_preds(cljs.spec.alpha.preturn(p1__$1),ps,cljs.core.next(forms));\nif(cljs.spec.alpha.invalid_QMARK_(ret__$1)){\nreturn null;\n} else {\nreturn cljs.spec.alpha.accept(ret__$1);\n}\n} else {\nreturn cljs.spec.alpha.amp_impl(p1__$1,amp,ps,forms);\n}\n} else {\nreturn null;\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25513)){\nreturn cljs.spec.alpha.alt2(cljs.spec.alpha.pcat_STAR_(new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),cljs.core.cons((cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2(p0,x) : cljs.spec.alpha.deriv.call(null, p0,x)),pr),new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942),ks,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),forms,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),ret], null)),(cljs.core.truth_(cljs.spec.alpha.accept_nil_QMARK_(p0))?(function (){var G__25535 \x3d cljs.spec.alpha.pcat_STAR_(new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046),pr,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942),kr,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350),cljs.core.next(forms),new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),cljs.spec.alpha.add_ret(p0,ret,k0)], null));\nvar G__25536 \x3d x;\nreturn (cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2(G__25535,G__25536) : cljs.spec.alpha.deriv.call(null, G__25535,G__25536));\n})():null));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25513)){\nreturn cljs.spec.alpha.alt_STAR_(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__25498_SHARP_){\nreturn (cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2(p1__25498_SHARP_,x) : cljs.spec.alpha.deriv.call(null, p1__25498_SHARP_,x));\n}),ps),ks,forms);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25513)){\nreturn cljs.spec.alpha.alt2(cljs.spec.alpha.rep_STAR_((cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2(p1,x) : cljs.spec.alpha.deriv.call(null, p1,x)),p2,ret,splice,forms),(cljs.core.truth_(cljs.spec.alpha.accept_nil_QMARK_(p1))?(function (){var G__25553 \x3d cljs.spec.alpha.rep_STAR_(p2,p2,cljs.spec.alpha.add_ret(p1,ret,null),splice,forms);\nvar G__25554 \x3d x;\nreturn (cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.deriv.cljs$core$IFn$_invoke$arity$2(G__25553,G__25554) : cljs.spec.alpha.deriv.call(null, G__25553,G__25554));\n})():null));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25513)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n} else {\nreturn null;\n}\n});\ncljs.spec.alpha.op_describe \x3d (function cljs$spec$alpha$op_describe(p){\nvar map__25558 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25558__$1 \x3d cljs.core.__destructure_map(map__25558);\nvar p__$1 \x3d map__25558__$1;\nvar ps \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar rep_PLUS_ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22rep+\x22,\x22rep+\x22,-281382396));\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar splice \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22splice\x22,\x22splice\x22,449588165));\nvar ks \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942));\nvar maybe \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22maybe\x22,\x22maybe\x22,-314397560));\nvar amp \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22amp\x22,\x22amp\x22,271690571));\nvar p1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25558__$1,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954));\nif(cljs.core.truth_(p__$1)){\nvar G__25561 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25561)){\nreturn null;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25561)){\nreturn p__$1;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25561)){\nreturn cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3(new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22\x26\x22,\x22cljs.spec.alpha/\x26\x22,1635809823,null),amp,forms);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25561)){\nif(cljs.core.truth_(rep_PLUS_)){\nreturn (new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22+\x22,\x22cljs.spec.alpha/+\x22,2101263265,null),(new cljs.core.List(null,rep_PLUS_,null,(1),null)),(2),null));\n} else {\nreturn cljs.core.cons(new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22cat\x22,\x22cljs.spec.alpha/cat\x22,-1471398329,null),cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(cljs.core.vector,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var or__5002__auto__ \x3d cljs.core.seq(ks);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22_\x22,\x22_\x22,1453416199));\n}\n})(),forms], 0)));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25561)){\nif(cljs.core.truth_(maybe)){\nreturn (new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22?\x22,\x22cljs.spec.alpha/?\x22,1605136319,null),(new cljs.core.List(null,maybe,null,(1),null)),(2),null));\n} else {\nreturn cljs.core.cons(new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,-2130750332,null),cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(cljs.core.vector,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([ks,forms], 0)));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25561)){\nreturn (new cljs.core.List(null,(cljs.core.truth_(splice)?new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22+\x22,\x22cljs.spec.alpha/+\x22,2101263265,null):new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22*\x22,\x22cljs.spec.alpha/*\x22,-1238084288,null)),(new cljs.core.List(null,forms,null,(1),null)),(2),null));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25561)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n} else {\nreturn null;\n}\n});\ncljs.spec.alpha.op_explain \x3d (function cljs$spec$alpha$op_explain(form,p,path,via,in$,input){\nvar vec__25577 \x3d input;\nvar x \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25577,(0),null);\nvar input__$1 \x3d vec__25577;\nvar map__25580 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25580__$1 \x3d cljs.core.__destructure_map(map__25580);\nvar p__$1 \x3d map__25580__$1;\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25580__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar ps \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25580__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar ks \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25580__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942));\nvar forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25580__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar splice \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25580__$1,new cljs.core.Keyword(null,\x22splice\x22,\x22splice\x22,449588165));\nvar p1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25580__$1,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954));\nvar p2 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25580__$1,new cljs.core.Keyword(null,\x22p2\x22,\x22p2\x22,905500641));\nvar via__$1 \x3d (function (){var temp__5802__auto__ \x3d cljs.spec.alpha.spec_name(p__$1);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar name \x3d temp__5802__auto__;\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(via,name);\n} else {\nreturn via;\n}\n})();\nvar insufficient \x3d (function (path__$1,form__$1){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path__$1,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),\x22Insufficient input\x22,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),form__$1,new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),cljs.core.List.EMPTY,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via__$1,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n});\nif(cljs.core.truth_(p__$1)){\nvar G__25588 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25588)){\nreturn null;\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25588)){\nif(cljs.core.empty_QMARK_(input__$1)){\nreturn insufficient(path,form);\n} else {\nreturn cljs.spec.alpha.explain_1(form,p__$1,path,via__$1,in$,x);\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25588)){\nif(cljs.core.empty_QMARK_(input__$1)){\nif(cljs.core.truth_(cljs.spec.alpha.accept_nil_QMARK_(p1))){\nreturn cljs.spec.alpha.explain_pred_list(forms,ps,path,via__$1,in$,cljs.spec.alpha.preturn(p1));\n} else {\nreturn insufficient(path,new cljs.core.Keyword(null,\x22amp\x22,\x22amp\x22,271690571).cljs$core$IFn$_invoke$arity$1(p__$1));\n}\n} else {\nvar temp__5802__auto__ \x3d cljs.spec.alpha.deriv(p1,x);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar p1__$1 \x3d temp__5802__auto__;\nreturn cljs.spec.alpha.explain_pred_list(forms,ps,path,via__$1,in$,cljs.spec.alpha.preturn(p1__$1));\n} else {\nvar G__25589 \x3d new cljs.core.Keyword(null,\x22amp\x22,\x22amp\x22,271690571).cljs$core$IFn$_invoke$arity$1(p__$1);\nvar G__25590 \x3d p1;\nvar G__25591 \x3d path;\nvar G__25592 \x3d via__$1;\nvar G__25593 \x3d in$;\nvar G__25594 \x3d input__$1;\nreturn (cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6 ? cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6(G__25589,G__25590,G__25591,G__25592,G__25593,G__25594) : cljs.spec.alpha.op_explain.call(null, G__25589,G__25590,G__25591,G__25592,G__25593,G__25594));\n}\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25588)){\nvar pkfs \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$4(cljs.core.vector,ps,(function (){var or__5002__auto__ \x3d cljs.core.seq(ks);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})(),(function (){var or__5002__auto__ \x3d cljs.core.seq(forms);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})());\nvar vec__25596 \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((1),cljs.core.count(pkfs)))?cljs.core.first(pkfs):cljs.core.first(cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p__25611){\nvar vec__25616 \x3d p__25611;\nvar p__$2 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25616,(0),null);\nreturn cljs.spec.alpha.accept_nil_QMARK_(p__$2);\n}),pkfs)));\nvar pred \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25596,(0),null);\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25596,(1),null);\nvar form__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25596,(2),null);\nvar path__$1 \x3d (cljs.core.truth_(k)?cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k):path);\nvar form__$2 \x3d (function (){var or__5002__auto__ \x3d form__$1;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.spec.alpha.op_describe(pred);\n}\n})();\nif(((cljs.core.empty_QMARK_(input__$1)) \x26\x26 (cljs.core.not(pred)))){\nreturn insufficient(path__$1,form__$2);\n} else {\nreturn (cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6 ? cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6(form__$2,pred,path__$1,via__$1,in$,input__$1) : cljs.spec.alpha.op_explain.call(null, form__$2,pred,path__$1,via__$1,in$,input__$1));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25588)){\nif(cljs.core.empty_QMARK_(input__$1)){\nreturn insufficient(path,cljs.spec.alpha.op_describe(p__$1));\n} else {\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,cljs.core.map.cljs$core$IFn$_invoke$arity$4((function (k,form__$1,pred){\nvar G__25624 \x3d (function (){var or__5002__auto__ \x3d form__$1;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn cljs.spec.alpha.op_describe(pred);\n}\n})();\nvar G__25625 \x3d pred;\nvar G__25626 \x3d (cljs.core.truth_(k)?cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k):path);\nvar G__25627 \x3d via__$1;\nvar G__25628 \x3d in$;\nvar G__25629 \x3d input__$1;\nreturn (cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6 ? cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6(G__25624,G__25625,G__25626,G__25627,G__25628,G__25629) : cljs.spec.alpha.op_explain.call(null, G__25624,G__25625,G__25626,G__25627,G__25628,G__25629));\n}),(function (){var or__5002__auto__ \x3d cljs.core.seq(ks);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})(),(function (){var or__5002__auto__ \x3d cljs.core.seq(forms);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})(),ps));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25588)){\nvar G__25632 \x3d (((p1 \x3d\x3d\x3d p2))?forms:cljs.spec.alpha.op_describe(p1));\nvar G__25633 \x3d p1;\nvar G__25634 \x3d path;\nvar G__25635 \x3d via__$1;\nvar G__25636 \x3d in$;\nvar G__25637 \x3d input__$1;\nreturn (cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6 ? cljs.spec.alpha.op_explain.cljs$core$IFn$_invoke$arity$6(G__25632,G__25633,G__25634,G__25635,G__25636,G__25637) : cljs.spec.alpha.op_explain.call(null, G__25632,G__25633,G__25634,G__25635,G__25636,G__25637));\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25588)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n} else {\nreturn null;\n}\n});\ncljs.spec.alpha.re_gen \x3d (function cljs$spec$alpha$re_gen(p,overrides,path,rmap,f){\nvar origp \x3d p;\nvar map__25647 \x3d cljs.spec.alpha.reg_resolve_BANG_(p);\nvar map__25647__$1 \x3d cljs.core.__destructure_map(map__25647);\nvar p__$1 \x3d map__25647__$1;\nvar ps \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22ps\x22,\x22ps\x22,292358046));\nvar forms \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350));\nvar p2 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22p2\x22,\x22p2\x22,905500641));\nvar ret \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814));\nvar gfn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22gfn\x22,\x22cljs.spec.alpha/gfn\x22,-593120375));\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252));\nvar splice \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22splice\x22,\x22splice\x22,449588165));\nvar ks \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22ks\x22,\x22ks\x22,1900203942));\nvar p1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22p1\x22,\x22p1\x22,-936759954));\nvar id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__25647__$1,new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092));\nvar rmap__$1 \x3d (cljs.core.truth_(id)?cljs.spec.alpha.inck(rmap,id):rmap);\nvar ggens \x3d (function (ps__$1,ks__$1,forms__$1){\nvar gen \x3d (function (p__$2,k,f__$1){\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d rmap__$1;\nif(cljs.core.truth_(and__5000__auto__)){\nvar and__5000__auto____$1 \x3d id;\nif(cljs.core.truth_(and__5000__auto____$1)){\nvar and__5000__auto____$2 \x3d k;\nif(cljs.core.truth_(and__5000__auto____$2)){\nreturn cljs.spec.alpha.recur_limit_QMARK_(rmap__$1,id,path,k);\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())){\nreturn null;\n} else {\nif(cljs.core.truth_(id)){\nreturn cljs.spec.gen.alpha.delay_impl((new cljs.core.Delay((function (){\nvar G__25682 \x3d p__$2;\nvar G__25683 \x3d overrides;\nvar G__25684 \x3d (cljs.core.truth_(k)?cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k):path);\nvar G__25685 \x3d rmap__$1;\nvar G__25686 \x3d (function (){var or__5002__auto__ \x3d f__$1;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn p__$2;\n}\n})();\nreturn (cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5 ? cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5(G__25682,G__25683,G__25684,G__25685,G__25686) : cljs.spec.alpha.re_gen.call(null, G__25682,G__25683,G__25684,G__25685,G__25686));\n}),null)));\n} else {\nvar G__25692 \x3d p__$2;\nvar G__25693 \x3d overrides;\nvar G__25694 \x3d (cljs.core.truth_(k)?cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,k):path);\nvar G__25695 \x3d rmap__$1;\nvar G__25696 \x3d (function (){var or__5002__auto__ \x3d f__$1;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn p__$2;\n}\n})();\nreturn (cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5 ? cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5(G__25692,G__25693,G__25694,G__25695,G__25696) : cljs.spec.alpha.re_gen.call(null, G__25692,G__25693,G__25694,G__25695,G__25696));\n}\n}\n});\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$4(gen,ps__$1,(function (){var or__5002__auto__ \x3d cljs.core.seq(ks__$1);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})(),(function (){var or__5002__auto__ \x3d cljs.core.seq(forms__$1);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nreturn cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null);\n}\n})());\n});\nvar or__5002__auto__ \x3d (function (){var temp__5804__auto__ \x3d (function (){var or__5002__auto__ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(overrides,cljs.spec.alpha.spec_name(origp));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(overrides,cljs.spec.alpha.spec_name(p__$1));\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(overrides,path);\n}\n}\n})();\nif(cljs.core.truth_(temp__5804__auto__)){\nvar gfn__$1 \x3d temp__5804__auto__;\nvar G__25707 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22accept\x22,\x22accept\x22,1874130431),G__25707)){\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.vector,(gfn__$1.cljs$core$IFn$_invoke$arity$0 ? gfn__$1.cljs$core$IFn$_invoke$arity$0() : gfn__$1.call(null, ))], 0));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25707)){\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.vector,(gfn__$1.cljs$core$IFn$_invoke$arity$0 ? gfn__$1.cljs$core$IFn$_invoke$arity$0() : gfn__$1.call(null, ))], 0));\n} else {\nreturn (gfn__$1.cljs$core$IFn$_invoke$arity$0 ? gfn__$1.cljs$core$IFn$_invoke$arity$0() : gfn__$1.call(null, ));\n\n}\n}\n} else {\nreturn null;\n}\n})();\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar or__5002__auto____$1 \x3d (cljs.core.truth_(gfn)?(gfn.cljs$core$IFn$_invoke$arity$0 ? gfn.cljs$core$IFn$_invoke$arity$0() : gfn.call(null, )):null);\nif(cljs.core.truth_(or__5002__auto____$1)){\nreturn or__5002__auto____$1;\n} else {\nif(cljs.core.truth_(p__$1)){\nvar G__25711 \x3d op;\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22accept\x22,\x22cljs.spec.alpha/accept\x22,370988198),G__25711)){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ret,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950))){\nreturn cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.PersistentVector.EMPTY], 0));\n} else {\nreturn cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [ret], null)], 0));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(null,G__25711)){\nvar temp__5804__auto__ \x3d cljs.spec.alpha.gensub(p__$1,overrides,path,rmap__$1,f);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar g \x3d temp__5804__auto__;\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.vector,g], 0));\n} else {\nreturn null;\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22amp\x22,\x22cljs.spec.alpha/amp\x22,831147508),G__25711)){\nvar G__25723 \x3d p1;\nvar G__25724 \x3d overrides;\nvar G__25725 \x3d path;\nvar G__25726 \x3d rmap__$1;\nvar G__25727 \x3d cljs.spec.alpha.op_describe(p1);\nreturn (cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5 ? cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5(G__25723,G__25724,G__25725,G__25726,G__25727) : cljs.spec.alpha.re_gen.call(null, G__25723,G__25724,G__25725,G__25726,G__25727));\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623),G__25711)){\nvar gens \x3d ggens(ps,ks,forms);\nif(cljs.core.every_QMARK_(cljs.core.identity,gens)){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.spec.gen.alpha.cat,gens);\n} else {\nreturn null;\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22alt\x22,\x22cljs.spec.alpha/alt\x22,523685437),G__25711)){\nvar gens \x3d cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,ggens(ps,ks,forms));\nif(cljs.core.empty_QMARK_(gens)){\nreturn null;\n} else {\nreturn cljs.spec.gen.alpha.one_of.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([gens], 0));\n}\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22rep\x22,\x22cljs.spec.alpha/rep\x22,1483217317),G__25711)){\nif(cljs.spec.alpha.recur_limit_QMARK_(rmap__$1,id,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [id], null),id)){\nreturn cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.PersistentVector.EMPTY], 0));\n} else {\nvar temp__5804__auto__ \x3d (cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5 ? cljs.spec.alpha.re_gen.cljs$core$IFn$_invoke$arity$5(p2,overrides,path,rmap__$1,forms) : cljs.spec.alpha.re_gen.call(null, p2,overrides,path,rmap__$1,forms));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar g \x3d temp__5804__auto__;\nreturn cljs.spec.gen.alpha.fmap.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (p1__25643_SHARP_){\nreturn cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,p1__25643_SHARP_);\n}),cljs.spec.gen.alpha.vector.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([g], 0))], 0));\n} else {\nreturn null;\n}\n}\n} else {\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__25711)].join(\x27\x27)));\n\n}\n}\n}\n}\n}\n}\n} else {\nreturn null;\n}\n}\n}\n});\ncljs.spec.alpha.re_conform \x3d (function cljs$spec$alpha$re_conform(p,p__25748){\nwhile(true){\nvar vec__25750 \x3d p__25748;\nvar seq__25751 \x3d cljs.core.seq(vec__25750);\nvar first__25752 \x3d cljs.core.first(seq__25751);\nvar seq__25751__$1 \x3d cljs.core.next(seq__25751);\nvar x \x3d first__25752;\nvar xs \x3d seq__25751__$1;\nvar data \x3d vec__25750;\nif(cljs.core.empty_QMARK_(data)){\nif(cljs.core.truth_(cljs.spec.alpha.accept_nil_QMARK_(p))){\nvar ret \x3d cljs.spec.alpha.preturn(p);\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ret,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950))){\nreturn null;\n} else {\nreturn ret;\n}\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n} else {\nvar temp__5802__auto__ \x3d cljs.spec.alpha.deriv(p,x);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar dp \x3d temp__5802__auto__;\nvar G__27269 \x3d dp;\nvar G__27270 \x3d xs;\np \x3d G__27269;\np__25748 \x3d G__27270;\ncontinue;\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}\nbreak;\n}\n});\ncljs.spec.alpha.re_explain \x3d (function cljs$spec$alpha$re_explain(path,via,in$,re,input){\nvar p \x3d re;\nvar G__25758 \x3d input;\nvar vec__25759 \x3d G__25758;\nvar seq__25760 \x3d cljs.core.seq(vec__25759);\nvar first__25761 \x3d cljs.core.first(seq__25760);\nvar seq__25760__$1 \x3d cljs.core.next(seq__25760);\nvar x \x3d first__25761;\nvar xs \x3d seq__25760__$1;\nvar data \x3d vec__25759;\nvar i \x3d (0);\nvar p__$1 \x3d p;\nvar G__25758__$1 \x3d G__25758;\nvar i__$1 \x3d i;\nwhile(true){\nvar p__$2 \x3d p__$1;\nvar vec__25765 \x3d G__25758__$1;\nvar seq__25766 \x3d cljs.core.seq(vec__25765);\nvar first__25767 \x3d cljs.core.first(seq__25766);\nvar seq__25766__$1 \x3d cljs.core.next(seq__25766);\nvar x__$1 \x3d first__25767;\nvar xs__$1 \x3d seq__25766__$1;\nvar data__$1 \x3d vec__25765;\nvar i__$2 \x3d i__$1;\nif(cljs.core.empty_QMARK_(data__$1)){\nif(cljs.core.truth_(cljs.spec.alpha.accept_nil_QMARK_(p__$2))){\nreturn null;\n} else {\nreturn cljs.spec.alpha.op_explain(cljs.spec.alpha.op_describe(p__$2),p__$2,path,via,in$,null);\n}\n} else {\nvar temp__5802__auto__ \x3d cljs.spec.alpha.deriv(p__$2,x__$1);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar dp \x3d temp__5802__auto__;\nvar G__27279 \x3d dp;\nvar G__27280 \x3d xs__$1;\nvar G__27281 \x3d (i__$2 + (1));\np__$1 \x3d G__27279;\nG__25758__$1 \x3d G__27280;\ni__$1 \x3d G__27281;\ncontinue;\n} else {\nif(cljs.spec.alpha.accept_QMARK_(p__$2)){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22op\x22,\x22cljs.spec.alpha/op\x22,-1269055252).cljs$core$IFn$_invoke$arity$1(p__$2),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pcat\x22,\x22cljs.spec.alpha/pcat\x22,26406623))){\nreturn cljs.spec.alpha.op_explain(cljs.spec.alpha.op_describe(p__$2),p__$2,path,via,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(in$,i__$2),cljs.core.seq(data__$1));\n} else {\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),\x22Extra input\x22,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),cljs.spec.alpha.op_describe(re),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),data__$1,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(in$,i__$2)], null)], null);\n}\n} else {\nvar or__5002__auto__ \x3d cljs.spec.alpha.op_explain(cljs.spec.alpha.op_describe(p__$2),p__$2,path,via,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(in$,i__$2),cljs.core.seq(data__$1));\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),\x22Extra input\x22,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),cljs.spec.alpha.op_describe(p__$2),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),data__$1,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(in$,i__$2)], null)], null);\n}\n}\n}\n}\nbreak;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha25774 \x3d (function (re,gfn,meta25775){\nthis.re \x3d re;\nthis.gfn \x3d gfn;\nthis.meta25775 \x3d meta25775;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25776,meta25775__$1){\nvar self__ \x3d this;\nvar _25776__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25774(self__.re,self__.gfn,meta25775__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25776){\nvar self__ \x3d this;\nvar _25776__$1 \x3d this;\nreturn self__.meta25775;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((((x \x3d\x3d null)) || (cljs.core.sequential_QMARK_(x)))){\nreturn cljs.spec.alpha.re_conform(self__.re,cljs.core.seq(x));\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.op_unform(self__.re,x);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((((x \x3d\x3d null)) || (cljs.core.sequential_QMARK_(x)))){\nreturn cljs.spec.alpha.re_explain(path,via,in$,self__.re,cljs.core.seq(x));\n} else {\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22fn\x22,\x22cljs.core/fn\x22,-1065745098,null),null,(1),null)),(new cljs.core.List(null,cljs.core.vec(cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$1((new cljs.core.List(null,new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null),null,(1),null)))))),null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs.core.List(null,cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22or\x22,\x22cljs.core/or\x22,1201033885,null),null,(1),null)),(new cljs.core.List(null,cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22nil?\x22,\x22cljs.core/nil?\x22,945071861,null),null,(1),null)),(new cljs.core.List(null,new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null),null,(1),null))))),null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs.core.List(null,cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.core\x22,\x22sequential?\x22,\x22cljs.core/sequential?\x22,1777854658,null),null,(1),null)),(new cljs.core.List(null,new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null),null,(1),null))))),null,(1),null))], 0)))),null,(1),null))], 0)))),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nreturn cljs.spec.alpha.re_gen(self__.re,overrides,path,rmap,cljs.spec.alpha.op_describe(self__.re));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (cljs.spec.alpha.regex_spec_impl.cljs$core$IFn$_invoke$arity$2 ? cljs.spec.alpha.regex_spec_impl.cljs$core$IFn$_invoke$arity$2(self__.re,gfn__$1) : cljs.spec.alpha.regex_spec_impl.call(null, self__.re,gfn__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.op_describe(self__.re);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22re\x22,\x22re\x22,1869207729,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22meta25775\x22,\x22meta25775\x22,467110891,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha25774\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25774.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha25774\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha25774.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha25774 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha25774(re,gfn,meta25775){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25774(re,gfn,meta25775));\n});\n\n\n/**\n * Do not call this directly, use \x27spec\x27 with a regex op argument\n */\ncljs.spec.alpha.regex_spec_impl \x3d (function cljs$spec$alpha$regex_spec_impl(re,gfn){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25774(re,gfn,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.spec.alpha.call_valid_QMARK_ \x3d (function cljs$spec$alpha$call_valid_QMARK_(f,specs,args){\nvar cargs \x3d cljs.spec.alpha.conform(new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576).cljs$core$IFn$_invoke$arity$1(specs),args);\nif(cljs.spec.alpha.invalid_QMARK_(cargs)){\nreturn null;\n} else {\nvar ret \x3d cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,args);\nvar cret \x3d cljs.spec.alpha.conform(new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814).cljs$core$IFn$_invoke$arity$1(specs),ret);\nvar and__5000__auto__ \x3d (!(cljs.spec.alpha.invalid_QMARK_(cret)));\nif(and__5000__auto__){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22fn\x22,\x22fn\x22,-1175266204).cljs$core$IFn$_invoke$arity$1(specs))){\nreturn cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22fn\x22,\x22fn\x22,-1175266204).cljs$core$IFn$_invoke$arity$1(specs),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),cargs,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),cret], null));\n} else {\nreturn true;\n}\n} else {\nreturn and__5000__auto__;\n}\n}\n});\n/**\n * returns f if valid, else smallest\n */\ncljs.spec.alpha.validate_fn \x3d (function cljs$spec$alpha$validate_fn(f,specs,iters){\nvar g \x3d cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576).cljs$core$IFn$_invoke$arity$1(specs));\nvar prop \x3d cljs.spec.gen.alpha.for_all_STAR_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [g], null),(function (p1__25799_SHARP_){\nreturn cljs.spec.alpha.call_valid_QMARK_(f,specs,p1__25799_SHARP_);\n})], 0));\nvar ret \x3d cljs.spec.gen.alpha.quick_check.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([iters,prop], 0));\nvar temp__5802__auto__ \x3d new cljs.core.Keyword(null,\x22smallest\x22,\x22smallest\x22,-152623883).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22shrunk\x22,\x22shrunk\x22,-2041664412).cljs$core$IFn$_invoke$arity$1(ret));\nif(cljs.core.truth_(temp__5802__auto__)){\nvar vec__25800 \x3d temp__5802__auto__;\nvar smallest \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25800,(0),null);\nreturn smallest;\n} else {\nreturn f;\n}\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.ILookup}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha25806 \x3d (function (argspec,aform,retspec,rform,fnspec,fform,gfn,specs,meta25807){\nthis.argspec \x3d argspec;\nthis.aform \x3d aform;\nthis.retspec \x3d retspec;\nthis.rform \x3d rform;\nthis.fnspec \x3d fnspec;\nthis.fform \x3d fform;\nthis.gfn \x3d gfn;\nthis.specs \x3d specs;\nthis.meta25807 \x3d meta25807;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393472;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25808,meta25807__$1){\nvar self__ \x3d this;\nvar _25808__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25806(self__.argspec,self__.aform,self__.retspec,self__.rform,self__.fnspec,self__.fform,self__.gfn,self__.specs,meta25807__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25808){\nvar self__ \x3d this;\nvar _25808__$1 \x3d this;\nreturn self__.meta25807;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this$,k){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$2(self__.specs,k);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (_,k,not_found){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.specs,k,not_found);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,f){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.ifn_QMARK_(f)){\nif((f \x3d\x3d\x3d cljs.spec.alpha.validate_fn(f,self__.specs,cljs.spec.alpha._STAR_fspec_iterations_STAR_))){\nreturn f;\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n} else {\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,f){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn f;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,f){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.ifn_QMARK_(f)){\nvar args \x3d cljs.spec.alpha.validate_fn(f,self__.specs,(100));\nif((f \x3d\x3d\x3d args)){\nreturn null;\n} else {\nvar ret \x3d (function (){try{return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,args);\n}catch (e25829){if((e25829 instanceof Error)){\nvar t \x3d e25829;\nreturn t;\n} else {\nthrow e25829;\n\n}\n}})();\nif((ret instanceof Error)){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),cljs.core.list(new cljs.core.Symbol(null,\x22apply\x22,\x22apply\x22,-1334050276,null),new cljs.core.Symbol(null,\x22fn\x22,\x22fn\x22,465265323,null)),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),args,new cljs.core.Keyword(null,\x22reason\x22,\x22reason\x22,-2070751759),ret.message,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n} else {\nvar cret \x3d cljs.spec.alpha.dt.cljs$core$IFn$_invoke$arity$3(self__.retspec,ret,self__.rform);\nif(cljs.spec.alpha.invalid_QMARK_(cret)){\nreturn cljs.spec.alpha.explain_1(self__.rform,self__.retspec,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814)),via,in$,ret);\n} else {\nif(cljs.core.truth_(self__.fnspec)){\nvar cargs \x3d cljs.spec.alpha.conform(self__.argspec,args);\nreturn cljs.spec.alpha.explain_1(self__.fform,self__.fnspec,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,new cljs.core.Keyword(null,\x22fn\x22,\x22fn\x22,-1175266204)),via,in$,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),cargs,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),cret], null));\n} else {\nreturn null;\n}\n}\n}\n}\n} else {\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),path,new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),new cljs.core.Symbol(null,\x22ifn?\x22,\x22ifn?\x22,-2106461064,null),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),f,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null)], null);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,___$1,___$2){\nvar self__ \x3d this;\nvar ___$3 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nreturn cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function() { \nvar G__27343__delegate \x3d function (args){\nif(cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2(self__.argspec,args)){\n} else {\nthrow (new Error([\x22Assert failed: \x22,(function (){var sb__5647__auto__ \x3d (new goog.string.StringBuffer());\nvar _STAR_print_newline_STAR__orig_val__25851_27345 \x3d cljs.core._STAR_print_newline_STAR_;\nvar _STAR_print_fn_STAR__orig_val__25852_27346 \x3d cljs.core._STAR_print_fn_STAR_;\nvar _STAR_print_newline_STAR__temp_val__25853_27347 \x3d true;\nvar _STAR_print_fn_STAR__temp_val__25854_27348 \x3d (function (x__5648__auto__){\nreturn sb__5647__auto__.append(x__5648__auto__);\n});\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__temp_val__25853_27347);\n\n(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__temp_val__25854_27348);\n\ntry{cljs.spec.alpha.explain(self__.argspec,args);\n}finally {(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__orig_val__25852_27346);\n\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__orig_val__25851_27345);\n}\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb__5647__auto__);\n})(),\x22\\n\x22,\x22(pvalid? argspec args)\x22].join(\x27\x27)));\n}\n\nreturn cljs.spec.gen.alpha.generate(cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$2(self__.retspec,overrides));\n};\nvar G__27343 \x3d function (var_args){\nvar args \x3d null;\nif (arguments.length \x3e 0) {\nvar G__27351__i \x3d 0, G__27351__a \x3d new Array(arguments.length -  0);\nwhile (G__27351__i \x3c G__27351__a.length) {G__27351__a[G__27351__i] \x3d arguments[G__27351__i + 0]; ++G__27351__i;}\n  args \x3d new cljs.core.IndexedSeq(G__27351__a,0,null);\n} \nreturn G__27343__delegate.call(this,args);};\nG__27343.cljs$lang$maxFixedArity \x3d 0;\nG__27343.cljs$lang$applyTo \x3d (function (arglist__27352){\nvar args \x3d cljs.core.seq(arglist__27352);\nreturn G__27343__delegate(args);\n});\nG__27343.cljs$core$IFn$_invoke$arity$variadic \x3d G__27343__delegate;\nreturn G__27343;\n})()\n], 0));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (cljs.spec.alpha.fspec_impl.cljs$core$IFn$_invoke$arity$7 ? cljs.spec.alpha.fspec_impl.cljs$core$IFn$_invoke$arity$7(self__.argspec,self__.aform,self__.retspec,self__.rform,self__.fnspec,self__.fform,gfn__$1) : cljs.spec.alpha.fspec_impl.call(null, self__.argspec,self__.aform,self__.retspec,self__.rform,self__.fnspec,self__.fform,gfn__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22fspec\x22,\x22cljs.spec.alpha/fspec\x22,-1289128341,null),null,(1),null)),(new cljs.core.List(null,new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),null,(1),null)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(new cljs.core.List(null,self__.aform,null,(1),null)),(new cljs.core.List(null,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),null,(1),null)),(new cljs.core.List(null,self__.rform,null,(1),null)),(new cljs.core.List(null,new cljs.core.Keyword(null,\x22fn\x22,\x22fn\x22,-1175266204),null,(1),null)),(new cljs.core.List(null,self__.fform,null,(1),null))], 0))));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22argspec\x22,\x22argspec\x22,-1207762746,null),new cljs.core.Symbol(null,\x22aform\x22,\x22aform\x22,531303525,null),new cljs.core.Symbol(null,\x22retspec\x22,\x22retspec\x22,-920025354,null),new cljs.core.Symbol(null,\x22rform\x22,\x22rform\x22,-1420499912,null),new cljs.core.Symbol(null,\x22fnspec\x22,\x22fnspec\x22,-1865712406,null),new cljs.core.Symbol(null,\x22fform\x22,\x22fform\x22,-176049972,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22specs\x22,\x22specs\x22,-1227865028,null),new cljs.core.Symbol(null,\x22meta25807\x22,\x22meta25807\x22,-602404347,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha25806\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25806.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha25806\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha25806.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha25806 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha25806(argspec,aform,retspec,rform,fnspec,fform,gfn,specs,meta25807){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25806(argspec,aform,retspec,rform,fnspec,fform,gfn,specs,meta25807));\n});\n\n\n/**\n * Do not call this directly, use \x27fspec\x27\n */\ncljs.spec.alpha.fspec_impl \x3d (function cljs$spec$alpha$fspec_impl(argspec,aform,retspec,rform,fnspec,fform,gfn){\nvar specs \x3d new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),argspec,new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),retspec,new cljs.core.Keyword(null,\x22fn\x22,\x22fn\x22,-1175266204),fnspec], null);\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25806(argspec,aform,retspec,rform,fnspec,fform,gfn,specs,cljs.core.PersistentArrayMap.EMPTY));\n});\ncljs.spec.alpha.def_impl(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22kvs-\x3emap\x22,\x22cljs.spec.alpha/kvs-\x3emap\x22,579713455),cljs.core.list(new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22conformer\x22,\x22cljs.spec.alpha/conformer\x22,2140085535,null),cljs.core.list(new cljs.core.Symbol(null,\x22fn*\x22,\x22fn*\x22,-752876845,null),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22p1__25900#\x22,\x22p1__25900#\x22,267621115,null)], null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22zipmap\x22,\x22cljs.core/zipmap\x22,-1902130674,null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22map\x22,\x22cljs.core/map\x22,-338988913,null),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22k\x22,\x22cljs.spec.alpha/k\x22,-1602615178),new cljs.core.Symbol(null,\x22p1__25900#\x22,\x22p1__25900#\x22,267621115,null)),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22map\x22,\x22cljs.core/map\x22,-338988913,null),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22v\x22,\x22cljs.spec.alpha/v\x22,552625740),new cljs.core.Symbol(null,\x22p1__25900#\x22,\x22p1__25900#\x22,267621115,null)))),cljs.core.list(new cljs.core.Symbol(null,\x22fn*\x22,\x22fn*\x22,-752876845,null),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22p1__25901#\x22,\x22p1__25901#\x22,-1746094871,null)], null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22map\x22,\x22cljs.core/map\x22,-338988913,null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22fn\x22,\x22cljs.core/fn\x22,-1065745098,null),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22k\x22,\x22k\x22,-505765866,null),new cljs.core.Symbol(null,\x22v\x22,\x22v\x22,1661996586,null)], null)], null),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22k\x22,\x22cljs.spec.alpha/k\x22,-1602615178),new cljs.core.Symbol(null,\x22k\x22,\x22k\x22,-505765866,null),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22v\x22,\x22cljs.spec.alpha/v\x22,552625740),new cljs.core.Symbol(null,\x22v\x22,\x22v\x22,1661996586,null)], null)),new cljs.core.Symbol(null,\x22p1__25901#\x22,\x22p1__25901#\x22,-1746094871,null)))),cljs.spec.alpha.spec_impl.cljs$core$IFn$_invoke$arity$5(cljs.core.list(new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22conformer\x22,\x22cljs.spec.alpha/conformer\x22,2140085535,null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22fn\x22,\x22cljs.core/fn\x22,-1065745098,null),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null)], null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22zipmap\x22,\x22cljs.core/zipmap\x22,-1902130674,null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22map\x22,\x22cljs.core/map\x22,-338988913,null),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22k\x22,\x22cljs.spec.alpha/k\x22,-1602615178),new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null)),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22map\x22,\x22cljs.core/map\x22,-338988913,null),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22v\x22,\x22cljs.spec.alpha/v\x22,552625740),new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null)))),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22fn\x22,\x22cljs.core/fn\x22,-1065745098,null),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null)], null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22map\x22,\x22cljs.core/map\x22,-338988913,null),cljs.core.list(new cljs.core.Symbol(\x22cljs.core\x22,\x22fn\x22,\x22cljs.core/fn\x22,-1065745098,null),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22k\x22,\x22k\x22,-505765866,null),new cljs.core.Symbol(null,\x22v\x22,\x22v\x22,1661996586,null)], null)], null),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22k\x22,\x22cljs.spec.alpha/k\x22,-1602615178),new cljs.core.Symbol(null,\x22k\x22,\x22k\x22,-505765866,null),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22v\x22,\x22cljs.spec.alpha/v\x22,552625740),new cljs.core.Symbol(null,\x22v\x22,\x22v\x22,1661996586,null)], null)),new cljs.core.Symbol(null,\x22%\x22,\x22%\x22,-950237169,null)))),(function (p1__25900_SHARP_){\nreturn cljs.core.zipmap(cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22k\x22,\x22cljs.spec.alpha/k\x22,-1602615178),p1__25900_SHARP_),cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22v\x22,\x22cljs.spec.alpha/v\x22,552625740),p1__25900_SHARP_));\n}),null,true,(function (p1__25901_SHARP_){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p__25928){\nvar vec__25930 \x3d p__25928;\nvar k \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25930,(0),null);\nvar v \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__25930,(1),null);\nreturn new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22k\x22,\x22cljs.spec.alpha/k\x22,-1602615178),k,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22v\x22,\x22cljs.spec.alpha/v\x22,552625740),v], null);\n}),p1__25901_SHARP_);\n})));\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha25933 \x3d (function (spec,meta25934){\nthis.spec \x3d spec;\nthis.meta25934 \x3d meta25934;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_25935,meta25934__$1){\nvar self__ \x3d this;\nvar _25935__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25933(self__.spec,meta25934__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_25935){\nvar self__ \x3d this;\nvar _25935__$1 \x3d this;\nreturn self__.meta25934;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar ret \x3d cljs.spec.alpha.conform_STAR_(cljs.core.deref(self__.spec),x);\nif(cljs.spec.alpha.invalid_QMARK_(ret)){\nreturn new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22invalid\x22,\x22cljs.spec.alpha/invalid\x22,-1220295119);\n} else {\nreturn x;\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.unform_STAR_(cljs.core.deref(self__.spec),x);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.explain_STAR_(cljs.core.deref(self__.spec),path,via,in$,x);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.spec.alpha.gen_STAR_(cljs.core.deref(self__.spec),overrides,path,rmap);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nvar G__26008 \x3d cljs.spec.alpha.with_gen_STAR_(cljs.core.deref(self__.spec),gfn);\nreturn (cljs.spec.alpha.nonconforming.cljs$core$IFn$_invoke$arity$1 ? cljs.spec.alpha.nonconforming.cljs$core$IFn$_invoke$arity$1(G__26008) : cljs.spec.alpha.nonconforming.call(null, G__26008));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22nonconforming\x22,\x22cljs.spec.alpha/nonconforming\x22,-1009218508,null),null,(1),null)),(new cljs.core.List(null,cljs.spec.alpha.describe_STAR_(cljs.core.deref(self__.spec)),null,(1),null)))));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22spec\x22,\x22spec\x22,1988051928,null),new cljs.core.Symbol(null,\x22meta25934\x22,\x22meta25934\x22,957806833,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha25933\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha25933.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha25933\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha25933.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha25933 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha25933(spec,meta25934){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25933(spec,meta25934));\n});\n\n\n/**\n * takes a spec and returns a spec that has the same properties except\n *   \x27conform\x27 returns the original (not the conformed) value. Note, will specize regex ops.\n */\ncljs.spec.alpha.nonconforming \x3d (function cljs$spec$alpha$nonconforming(spec){\nvar spec__$1 \x3d (new cljs.core.Delay((function (){\nreturn cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$1(spec);\n}),null));\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha25933(spec__$1,cljs.core.PersistentArrayMap.EMPTY));\n});\n\n/**\n* @constructor\n * @implements {cljs.spec.alpha.Spec}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.spec.alpha.Specize}\n * @implements {cljs.core.IWithMeta}\n*/\ncljs.spec.alpha.t_cljs$spec$alpha26034 \x3d (function (form,pred,gfn,spec,meta26035){\nthis.form \x3d form;\nthis.pred \x3d pred;\nthis.gfn \x3d gfn;\nthis.spec \x3d spec;\nthis.meta26035 \x3d meta26035;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 393216;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (_26036,meta26035__$1){\nvar self__ \x3d this;\nvar _26036__$1 \x3d this;\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha26034(self__.form,self__.pred,self__.gfn,self__.spec,meta26035__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (_26036){\nvar self__ \x3d this;\nvar _26036__$1 \x3d this;\nreturn self__.meta26035;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Specize$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$1 \x3d (function (s){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Specize$specize_STAR_$arity$2 \x3d (function (s,_){\nvar self__ \x3d this;\nvar s__$1 \x3d this;\nreturn s__$1;\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Spec$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Spec$conform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((x \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.spec.alpha.conform_STAR_(cljs.core.deref(self__.spec),x);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Spec$unform_STAR_$arity$2 \x3d (function (_,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif((x \x3d\x3d null)){\nreturn null;\n} else {\nreturn cljs.spec.alpha.unform_STAR_(cljs.core.deref(self__.spec),x);\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Spec$explain_STAR_$arity$5 \x3d (function (_,path,via,in$,x){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(((cljs.spec.alpha.pvalid_QMARK_.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(self__.spec),x)) || ((x \x3d\x3d null)))){\nreturn null;\n} else {\nreturn cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.spec.alpha.explain_1(self__.form,self__.pred,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pred\x22,\x22cljs.spec.alpha/pred\x22,-798342594)),via,in$,x),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22nil\x22,\x22cljs.spec.alpha/nil\x22,1733813950)),new cljs.core.Keyword(null,\x22pred\x22,\x22pred\x22,1927423397),new cljs.core.Symbol(null,\x22nil?\x22,\x22nil?\x22,1612038930,null),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),x,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336),via,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865),in$], null));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Spec$gen_STAR_$arity$4 \x3d (function (_,overrides,path,rmap){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nif(cljs.core.truth_(self__.gfn)){\nreturn (self__.gfn.cljs$core$IFn$_invoke$arity$0 ? self__.gfn.cljs$core$IFn$_invoke$arity$0() : self__.gfn.call(null, ));\n} else {\nreturn cljs.spec.gen.alpha.frequency.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(1),cljs.spec.gen.alpha.delay_impl((new cljs.core.Delay((function (){\nreturn cljs.spec.gen.alpha.return$.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([null], 0));\n}),null)))], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(9),cljs.spec.gen.alpha.delay_impl((new cljs.core.Delay((function (){\nreturn cljs.spec.alpha.gensub(self__.pred,overrides,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(path,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22pred\x22,\x22cljs.spec.alpha/pred\x22,-798342594)),rmap,self__.form);\n}),null)))], null)], null)], 0));\n}\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Spec$with_gen_STAR_$arity$2 \x3d (function (_,gfn__$1){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn (cljs.spec.alpha.nilable_impl.cljs$core$IFn$_invoke$arity$3 ? cljs.spec.alpha.nilable_impl.cljs$core$IFn$_invoke$arity$3(self__.form,self__.pred,gfn__$1) : cljs.spec.alpha.nilable_impl.call(null, self__.form,self__.pred,gfn__$1));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.prototype.cljs$spec$alpha$Spec$describe_STAR_$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2((new cljs.core.List(null,new cljs.core.Symbol(\x22cljs.spec.alpha\x22,\x22nilable\x22,\x22cljs.spec.alpha/nilable\x22,1628308748,null),null,(1),null)),(new cljs.core.List(null,self__.form,null,(1),null)))));\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22form\x22,\x22form\x22,16469056,null),new cljs.core.Symbol(null,\x22pred\x22,\x22pred\x22,-727012372,null),new cljs.core.Symbol(null,\x22gfn\x22,\x22gfn\x22,-1862918295,null),new cljs.core.Symbol(null,\x22spec\x22,\x22spec\x22,1988051928,null),new cljs.core.Symbol(null,\x22meta26035\x22,\x22meta26035\x22,-835629090,null)], null);\n}));\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.cljs$lang$type \x3d true);\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.cljs$lang$ctorStr \x3d \x22cljs.spec.alpha/t_cljs$spec$alpha26034\x22);\n\n(cljs.spec.alpha.t_cljs$spec$alpha26034.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22cljs.spec.alpha/t_cljs$spec$alpha26034\x22);\n}));\n\n/**\n * Positional factory function for cljs.spec.alpha/t_cljs$spec$alpha26034.\n */\ncljs.spec.alpha.__GT_t_cljs$spec$alpha26034 \x3d (function cljs$spec$alpha$__GT_t_cljs$spec$alpha26034(form,pred,gfn,spec,meta26035){\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha26034(form,pred,gfn,spec,meta26035));\n});\n\n\n/**\n * Do not call this directly, use \x27nilable\x27\n */\ncljs.spec.alpha.nilable_impl \x3d (function cljs$spec$alpha$nilable_impl(form,pred,gfn){\nvar spec \x3d (new cljs.core.Delay((function (){\nreturn cljs.spec.alpha.specize.cljs$core$IFn$_invoke$arity$2(pred,form);\n}),null));\nreturn (new cljs.spec.alpha.t_cljs$spec$alpha26034(form,pred,gfn,spec,cljs.core.PersistentArrayMap.EMPTY));\n});\n/**\n * generates a number (default 10) of values compatible with spec and maps conform over them,\n *   returning a sequence of [val conformed-val] tuples. Optionally takes\n *   a generator overrides map as per gen\n */\ncljs.spec.alpha.exercise \x3d (function cljs$spec$alpha$exercise(var_args){\nvar G__26125 \x3d arguments.length;\nswitch (G__26125) {\ncase 1:\nreturn cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ncase 3:\nreturn cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$1 \x3d (function (spec){\nreturn cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$2(spec,(10));\n}));\n\n(cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$2 \x3d (function (spec,n){\nreturn cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$3(spec,n,null);\n}));\n\n(cljs.spec.alpha.exercise.cljs$core$IFn$_invoke$arity$3 \x3d (function (spec,n,overrides){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__26116_SHARP_){\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[p1__26116_SHARP_,cljs.spec.alpha.conform(spec,p1__26116_SHARP_)],null));\n}),cljs.spec.gen.alpha.sample.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.spec.alpha.gen.cljs$core$IFn$_invoke$arity$2(spec,overrides),n], 0)));\n}));\n\n(cljs.spec.alpha.exercise.cljs$lang$maxFixedArity \x3d 3);\n\n/**\n * Return true if inst at or after start and before end\n */\ncljs.spec.alpha.inst_in_range_QMARK_ \x3d (function cljs$spec$alpha$inst_in_range_QMARK_(start,end,inst){\nvar and__5000__auto__ \x3d cljs.core.inst_QMARK_(inst);\nif(and__5000__auto__){\nvar t \x3d cljs.core.inst_ms(inst);\nreturn (((cljs.core.inst_ms(start) \x3c\x3d t)) \x26\x26 ((t \x3c cljs.core.inst_ms(end))));\n} else {\nreturn and__5000__auto__;\n}\n});\n/**\n * Return true if start \x3c\x3d val, val \x3c end and val is a fixed\n *   precision integer.\n */\ncljs.spec.alpha.int_in_range_QMARK_ \x3d (function cljs$spec$alpha$int_in_range_QMARK_(start,end,val){\nif(cljs.core.integer_QMARK_(val)){\nreturn (((start \x3c\x3d val)) \x26\x26 ((val \x3c end)));\n} else {\nif((val instanceof cljs.spec.alpha.goog$module$goog$math$Long)){\nvar and__5000__auto__ \x3d start.lessThanOrEqual(val);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn val.lessThan(end);\n} else {\nreturn and__5000__auto__;\n}\n} else {\nif((val instanceof goog.math.Integer)){\nvar and__5000__auto__ \x3d start.lessThanOrEqual(val);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn val.lessThan(end);\n} else {\nreturn and__5000__auto__;\n}\n} else {\nreturn false;\n\n}\n}\n}\n});\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec.alpha !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec.alpha._STAR_compile_asserts_STAR_ !\x3d\x3d \x27undefined\x27)){\n} else {\n/**\n * If true, compiler will enable spec asserts, which are then\n * subject to runtime control via check-asserts? If false, compiler\n * will eliminate all spec assert overhead. See \x27assert\x27.\n * Initially set to the negation of the \x27:elide-asserts\x27 compiler option.\n * Defaults to true.\n */\ncljs.spec.alpha._STAR_compile_asserts_STAR_ \x3d true;\n}\nif((typeof cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec.alpha !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof cljs.spec.alpha._STAR_runtime_asserts_STAR_ !\x3d\x3d \x27undefined\x27)){\n} else {\ncljs.spec.alpha._STAR_runtime_asserts_STAR_ \x3d false;\n}\n/**\n * Returns the value set by check-asserts.\n */\ncljs.spec.alpha.check_asserts_QMARK_ \x3d (function cljs$spec$alpha$check_asserts_QMARK_(){\nreturn cljs.spec.alpha._STAR_runtime_asserts_STAR_;\n});\n/**\n * Enable or disable spec asserts that have been compiled\n * with \x27*compile-asserts*\x27 true.  See \x27assert\x27.\n * Initially set to boolean value of cljs.spec.alpha/*runtime-asserts*.\n * Defaults to false.\n */\ncljs.spec.alpha.check_asserts \x3d (function cljs$spec$alpha$check_asserts(flag){\nreturn (cljs.spec.alpha._STAR_runtime_asserts_STAR_ \x3d flag);\n});\n/**\n * Do not call this directly, use \x27assert\x27.\n */\ncljs.spec.alpha.assert_STAR_ \x3d (function cljs$spec$alpha$assert_STAR_(spec,x){\nif(cljs.spec.alpha.valid_QMARK_.cljs$core$IFn$_invoke$arity$2(spec,x)){\nreturn x;\n} else {\nvar ed \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.spec.alpha.explain_data_STAR_(spec,cljs.core.PersistentVector.EMPTY,cljs.core.PersistentVector.EMPTY,cljs.core.PersistentVector.EMPTY,x),new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22failure\x22,\x22cljs.spec.alpha/failure\x22,188258592),new cljs.core.Keyword(null,\x22assertion-failed\x22,\x22assertion-failed\x22,-970534477))], 0));\nthrow (new Error([\x22Spec assertion failed\\n\x22,(function (){var sb__5647__auto__ \x3d (new goog.string.StringBuffer());\nvar _STAR_print_newline_STAR__orig_val__26166_27425 \x3d cljs.core._STAR_print_newline_STAR_;\nvar _STAR_print_fn_STAR__orig_val__26167_27426 \x3d cljs.core._STAR_print_fn_STAR_;\nvar _STAR_print_newline_STAR__temp_val__26168_27427 \x3d true;\nvar _STAR_print_fn_STAR__temp_val__26169_27428 \x3d (function (x__5648__auto__){\nreturn sb__5647__auto__.append(x__5648__auto__);\n});\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__temp_val__26168_27427);\n\n(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__temp_val__26169_27428);\n\ntry{cljs.spec.alpha.explain_out(ed);\n}finally {(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__orig_val__26167_27426);\n\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__orig_val__26166_27425);\n}\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb__5647__auto__);\n})()].join(\x27\x27)));\n}\n});\n");
SHADOW_ENV.evalLoad("shadow.remote.runtime.writer.js", true, "goog.provide(\x27shadow.remote.runtime.writer\x27);\n\n/**\n* @constructor\n * @implements {cljs.core.IWriter}\n*/\nshadow.remote.runtime.writer.LimitWriter \x3d (function (sb,limit){\nthis.sb \x3d sb;\nthis.limit \x3d limit;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 1073741824;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 0;\n});\n(shadow.remote.runtime.writer.LimitWriter.prototype.getString \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nreturn self__.sb.toString();\n}));\n\n(shadow.remote.runtime.writer.LimitWriter.prototype.cljs$core$IWriter$_write$arity$2 \x3d (function (_,s){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nself__.sb.append(s);\n\nif((self__.sb.getLength() \x3e\x3d self__.limit)){\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2([\x22The limit of \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.limit),\x22 bytes was reached while printing.\x22].join(\x27\x27),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Keyword(\x22shadow.remote.runtime.writer\x22,\x22limit-reached\x22,\x22shadow.remote.runtime.writer/limit-reached\x22,1304350996),new cljs.core.Keyword(null,\x22limit\x22,\x22limit\x22,-1355822363),self__.limit], null));\n} else {\nreturn null;\n}\n}));\n\n(shadow.remote.runtime.writer.LimitWriter.prototype.cljs$core$IWriter$_flush$arity$1 \x3d (function (_){\nvar self__ \x3d this;\nvar ___$1 \x3d this;\nreturn null;\n}));\n\n(shadow.remote.runtime.writer.LimitWriter.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(new cljs.core.Symbol(null,\x22sb\x22,\x22sb\x22,-1249746442,null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223),new cljs.core.Symbol(null,\x22StringBuffer\x22,\x22StringBuffer\x22,864531538,null)], null)),new cljs.core.Symbol(null,\x22limit\x22,\x22limit\x22,284709164,null)], null);\n}));\n\n(shadow.remote.runtime.writer.LimitWriter.cljs$lang$type \x3d true);\n\n(shadow.remote.runtime.writer.LimitWriter.cljs$lang$ctorStr \x3d \x22shadow.remote.runtime.writer/LimitWriter\x22);\n\n(shadow.remote.runtime.writer.LimitWriter.cljs$lang$ctorPrWriter \x3d (function (this__5287__auto__,writer__5288__auto__,opt__5289__auto__){\nreturn cljs.core._write(writer__5288__auto__,\x22shadow.remote.runtime.writer/LimitWriter\x22);\n}));\n\n/**\n * Positional factory function for shadow.remote.runtime.writer/LimitWriter.\n */\nshadow.remote.runtime.writer.__GT_LimitWriter \x3d (function shadow$remote$runtime$writer$__GT_LimitWriter(sb,limit){\nreturn (new shadow.remote.runtime.writer.LimitWriter(sb,limit));\n});\n\nshadow.remote.runtime.writer.pr_str_limit \x3d (function shadow$remote$runtime$writer$pr_str_limit(obj,limit){\nvar sb \x3d (new goog.string.StringBuffer());\nvar writer \x3d (new shadow.remote.runtime.writer.LimitWriter(sb,limit));\ntry{cljs.core.pr_writer(obj,writer,cljs.core.pr_opts());\n\nreturn [\x220,\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb.toString())].join(\x27\x27);\n}catch (e21738){var e \x3d e21738;\nif((!(cljs.core.keyword_identical_QMARK_(new cljs.core.Keyword(\x22shadow.remote.runtime.writer\x22,\x22limit-reached\x22,\x22shadow.remote.runtime.writer/limit-reached\x22,1304350996),new cljs.core.Keyword(null,\x22tag\x22,\x22tag\x22,-1290361223).cljs$core$IFn$_invoke$arity$1(cljs.core.ex_data(e)))))){\nthrow e;\n} else {\nreturn [\x221,\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((function (){var s \x3d sb.toString();\nif((s.length \x3e limit)){\nreturn cljs.core.subs.cljs$core$IFn$_invoke$arity$3(s,(0),limit);\n} else {\nreturn s;\n}\n})())].join(\x27\x27);\n}\n}});\nshadow.remote.runtime.writer.limit_writer \x3d (function shadow$remote$runtime$writer$limit_writer(limit){\nvar sb \x3d (new goog.string.StringBuffer());\nreturn (new shadow.remote.runtime.writer.LimitWriter(sb,limit));\n});\nshadow.remote.runtime.writer.get_string \x3d (function shadow$remote$runtime$writer$get_string(lw){\nreturn lw.getString();\n});\n");
SHADOW_ENV.evalLoad("goog.string.stringformat.js", true, "goog.provide(\x22goog.string.format\x22);\ngoog.require(\x22goog.string\x22);\ngoog.string.format \x3d function(formatString, var_args) {\n  function replacerDemuxer(match, flags, width, dotp, precision, type, offset, wholeString) {\n    if (type \x3d\x3d \x22%\x22) {\n      return \x22%\x22;\n    }\n    const value \x3d args.shift();\n    if (typeof value \x3d\x3d \x22undefined\x22) {\n      throw new Error(\x22[goog.string.format] Not enough arguments\x22);\n    }\n    arguments[0] \x3d value;\n    return goog.string.format.demuxes_[type].apply(null, arguments);\n  }\n  const args \x3d Array.prototype.slice.call(arguments);\n  const template \x3d args.shift();\n  if (typeof template \x3d\x3d \x22undefined\x22) {\n    throw new Error(\x22[goog.string.format] Template required\x22);\n  }\n  const formatRe \x3d /%([0\\- \\+]*)(\\d+)?(\\.(\\d+))?([%sfdiu])/g;\n  return template.replace(formatRe, replacerDemuxer);\n};\ngoog.string.format.demuxes_ \x3d {};\ngoog.string.format.demuxes_[\x22s\x22] \x3d function(value, flags, width, dotp, precision, type, offset, wholeString) {\n  let replacement \x3d value;\n  if (isNaN(width) || width \x3d\x3d \x22\x22 || replacement.length \x3e\x3d Number(width)) {\n    return replacement;\n  }\n  if (flags.indexOf(\x22-\x22, 0) \x3e -1) {\n    replacement \x3d replacement + goog.string.repeat(\x22 \x22, Number(width) - replacement.length);\n  } else {\n    replacement \x3d goog.string.repeat(\x22 \x22, Number(width) - replacement.length) + replacement;\n  }\n  return replacement;\n};\ngoog.string.format.demuxes_[\x22f\x22] \x3d function(value, flags, width, dotp, precision, type, offset, wholeString) {\n  let replacement \x3d value.toString();\n  if (!(isNaN(precision) || precision \x3d\x3d \x22\x22)) {\n    replacement \x3d parseFloat(value).toFixed(precision);\n  }\n  let sign;\n  if (Number(value) \x3c 0) {\n    sign \x3d \x22-\x22;\n  } else if (flags.indexOf(\x22+\x22) \x3e\x3d 0) {\n    sign \x3d \x22+\x22;\n  } else if (flags.indexOf(\x22 \x22) \x3e\x3d 0) {\n    sign \x3d \x22 \x22;\n  } else {\n    sign \x3d \x22\x22;\n  }\n  if (Number(value) \x3e\x3d 0) {\n    replacement \x3d sign + replacement;\n  }\n  if (isNaN(width) || replacement.length \x3e\x3d Number(width)) {\n    return replacement;\n  }\n  replacement \x3d isNaN(precision) ? Math.abs(Number(value)).toString() : Math.abs(Number(value)).toFixed(precision);\n  const padCount \x3d Number(width) - replacement.length - sign.length;\n  if (flags.indexOf(\x22-\x22, 0) \x3e\x3d 0) {\n    replacement \x3d sign + replacement + goog.string.repeat(\x22 \x22, padCount);\n  } else {\n    const paddingChar \x3d flags.indexOf(\x220\x22, 0) \x3e\x3d 0 ? \x220\x22 : \x22 \x22;\n    replacement \x3d sign + goog.string.repeat(paddingChar, padCount) + replacement;\n  }\n  return replacement;\n};\ngoog.string.format.demuxes_[\x22d\x22] \x3d function(value, flags, width, dotp, precision, type, offset, wholeString) {\n  return goog.string.format.demuxes_[\x22f\x22](parseInt(value, 10), flags, width, dotp, 0, type, offset, wholeString);\n};\ngoog.string.format.demuxes_[\x22i\x22] \x3d goog.string.format.demuxes_[\x22d\x22];\ngoog.string.format.demuxes_[\x22u\x22] \x3d goog.string.format.demuxes_[\x22d\x22];\n");
SHADOW_ENV.evalLoad("cljs.repl.js", true, "goog.provide(\x27cljs.repl\x27);\ncljs.repl.print_doc \x3d (function cljs$repl$print_doc(p__26307){\nvar map__26308 \x3d p__26307;\nvar map__26308__$1 \x3d cljs.core.__destructure_map(map__26308);\nvar m \x3d map__26308__$1;\nvar n \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26308__$1,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760));\nvar nm \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26308__$1,new cljs.core.Keyword(null,\x22name\x22,\x22name\x22,1843675177));\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22-------------------------\x22], 0));\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22spec\x22,\x22spec\x22,347520401).cljs$core$IFn$_invoke$arity$1(m);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn [(function (){var temp__5804__auto__ \x3d new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760).cljs$core$IFn$_invoke$arity$1(m);\nif(cljs.core.truth_(temp__5804__auto__)){\nvar ns \x3d temp__5804__auto__;\nreturn [cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns),\x22/\x22].join(\x27\x27);\n} else {\nreturn null;\n}\n})(),cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22name\x22,\x22name\x22,1843675177).cljs$core$IFn$_invoke$arity$1(m))].join(\x27\x27);\n}\n})()], 0));\n\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22protocol\x22,\x22protocol\x22,652470118).cljs$core$IFn$_invoke$arity$1(m))){\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22Protocol\x22], 0));\n} else {\n}\n\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350).cljs$core$IFn$_invoke$arity$1(m))){\nvar seq__26321_26812 \x3d cljs.core.seq(new cljs.core.Keyword(null,\x22forms\x22,\x22forms\x22,2045992350).cljs$core$IFn$_invoke$arity$1(m));\nvar chunk__26322_26813 \x3d null;\nvar count__26323_26814 \x3d (0);\nvar i__26324_26815 \x3d (0);\nwhile(true){\nif((i__26324_26815 \x3c count__26323_26814)){\nvar f_26816 \x3d chunk__26322_26813.cljs$core$IIndexed$_nth$arity$2(null, i__26324_26815);\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22  \x22,f_26816], 0));\n\n\nvar G__26817 \x3d seq__26321_26812;\nvar G__26818 \x3d chunk__26322_26813;\nvar G__26819 \x3d count__26323_26814;\nvar G__26820 \x3d (i__26324_26815 + (1));\nseq__26321_26812 \x3d G__26817;\nchunk__26322_26813 \x3d G__26818;\ncount__26323_26814 \x3d G__26819;\ni__26324_26815 \x3d G__26820;\ncontinue;\n} else {\nvar temp__5804__auto___26823 \x3d cljs.core.seq(seq__26321_26812);\nif(temp__5804__auto___26823){\nvar seq__26321_26824__$1 \x3d temp__5804__auto___26823;\nif(cljs.core.chunked_seq_QMARK_(seq__26321_26824__$1)){\nvar c__5525__auto___26825 \x3d cljs.core.chunk_first(seq__26321_26824__$1);\nvar G__26826 \x3d cljs.core.chunk_rest(seq__26321_26824__$1);\nvar G__26827 \x3d c__5525__auto___26825;\nvar G__26828 \x3d cljs.core.count(c__5525__auto___26825);\nvar G__26829 \x3d (0);\nseq__26321_26812 \x3d G__26826;\nchunk__26322_26813 \x3d G__26827;\ncount__26323_26814 \x3d G__26828;\ni__26324_26815 \x3d G__26829;\ncontinue;\n} else {\nvar f_26834 \x3d cljs.core.first(seq__26321_26824__$1);\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22  \x22,f_26834], 0));\n\n\nvar G__26835 \x3d cljs.core.next(seq__26321_26824__$1);\nvar G__26836 \x3d null;\nvar G__26837 \x3d (0);\nvar G__26838 \x3d (0);\nseq__26321_26812 \x3d G__26835;\nchunk__26322_26813 \x3d G__26836;\ncount__26323_26814 \x3d G__26837;\ni__26324_26815 \x3d G__26838;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22arglists\x22,\x22arglists\x22,1661989754).cljs$core$IFn$_invoke$arity$1(m))){\nvar arglists_26839 \x3d new cljs.core.Keyword(null,\x22arglists\x22,\x22arglists\x22,1661989754).cljs$core$IFn$_invoke$arity$1(m);\nif(cljs.core.truth_((function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22macro\x22,\x22macro\x22,-867863404).cljs$core$IFn$_invoke$arity$1(m);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn new cljs.core.Keyword(null,\x22repl-special-function\x22,\x22repl-special-function\x22,1262603725).cljs$core$IFn$_invoke$arity$1(m);\n}\n})())){\ncljs.core.prn.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([arglists_26839], 0));\n} else {\ncljs.core.prn.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Symbol(null,\x22quote\x22,\x22quote\x22,1377916282,null),cljs.core.first(arglists_26839)))?cljs.core.second(arglists_26839):arglists_26839)], 0));\n}\n} else {\n}\n}\n\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22special-form\x22,\x22special-form\x22,-1326536374).cljs$core$IFn$_invoke$arity$1(m))){\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22Special Form\x22], 0));\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,new cljs.core.Keyword(null,\x22doc\x22,\x22doc\x22,1913296891).cljs$core$IFn$_invoke$arity$1(m)], 0));\n\nif(cljs.core.contains_QMARK_(m,new cljs.core.Keyword(null,\x22url\x22,\x22url\x22,276297046))){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22url\x22,\x22url\x22,276297046).cljs$core$IFn$_invoke$arity$1(m))){\nreturn cljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22\\n  Please see http://clojure.org/\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22url\x22,\x22url\x22,276297046).cljs$core$IFn$_invoke$arity$1(m))].join(\x27\x27)], 0));\n} else {\nreturn null;\n}\n} else {\nreturn cljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22\\n  Please see http://clojure.org/special_forms#\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22name\x22,\x22name\x22,1843675177).cljs$core$IFn$_invoke$arity$1(m))].join(\x27\x27)], 0));\n}\n} else {\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22macro\x22,\x22macro\x22,-867863404).cljs$core$IFn$_invoke$arity$1(m))){\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22Macro\x22], 0));\n} else {\n}\n\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22spec\x22,\x22spec\x22,347520401).cljs$core$IFn$_invoke$arity$1(m))){\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22Spec\x22], 0));\n} else {\n}\n\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22repl-special-function\x22,\x22repl-special-function\x22,1262603725).cljs$core$IFn$_invoke$arity$1(m))){\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22REPL Special Function\x22], 0));\n} else {\n}\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,new cljs.core.Keyword(null,\x22doc\x22,\x22doc\x22,1913296891).cljs$core$IFn$_invoke$arity$1(m)], 0));\n\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22protocol\x22,\x22protocol\x22,652470118).cljs$core$IFn$_invoke$arity$1(m))){\nvar seq__26353_26844 \x3d cljs.core.seq(new cljs.core.Keyword(null,\x22methods\x22,\x22methods\x22,453930866).cljs$core$IFn$_invoke$arity$1(m));\nvar chunk__26354_26845 \x3d null;\nvar count__26355_26846 \x3d (0);\nvar i__26356_26847 \x3d (0);\nwhile(true){\nif((i__26356_26847 \x3c count__26355_26846)){\nvar vec__26441_26848 \x3d chunk__26354_26845.cljs$core$IIndexed$_nth$arity$2(null, i__26356_26847);\nvar name_26849 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26441_26848,(0),null);\nvar map__26444_26850 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26441_26848,(1),null);\nvar map__26444_26851__$1 \x3d cljs.core.__destructure_map(map__26444_26850);\nvar doc_26852 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26444_26851__$1,new cljs.core.Keyword(null,\x22doc\x22,\x22doc\x22,1913296891));\nvar arglists_26853 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26444_26851__$1,new cljs.core.Keyword(null,\x22arglists\x22,\x22arglists\x22,1661989754));\ncljs.core.println();\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,name_26849], 0));\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,arglists_26853], 0));\n\nif(cljs.core.truth_(doc_26852)){\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,doc_26852], 0));\n} else {\n}\n\n\nvar G__26857 \x3d seq__26353_26844;\nvar G__26858 \x3d chunk__26354_26845;\nvar G__26859 \x3d count__26355_26846;\nvar G__26860 \x3d (i__26356_26847 + (1));\nseq__26353_26844 \x3d G__26857;\nchunk__26354_26845 \x3d G__26858;\ncount__26355_26846 \x3d G__26859;\ni__26356_26847 \x3d G__26860;\ncontinue;\n} else {\nvar temp__5804__auto___26861 \x3d cljs.core.seq(seq__26353_26844);\nif(temp__5804__auto___26861){\nvar seq__26353_26862__$1 \x3d temp__5804__auto___26861;\nif(cljs.core.chunked_seq_QMARK_(seq__26353_26862__$1)){\nvar c__5525__auto___26863 \x3d cljs.core.chunk_first(seq__26353_26862__$1);\nvar G__26864 \x3d cljs.core.chunk_rest(seq__26353_26862__$1);\nvar G__26865 \x3d c__5525__auto___26863;\nvar G__26866 \x3d cljs.core.count(c__5525__auto___26863);\nvar G__26867 \x3d (0);\nseq__26353_26844 \x3d G__26864;\nchunk__26354_26845 \x3d G__26865;\ncount__26355_26846 \x3d G__26866;\ni__26356_26847 \x3d G__26867;\ncontinue;\n} else {\nvar vec__26480_26868 \x3d cljs.core.first(seq__26353_26862__$1);\nvar name_26869 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26480_26868,(0),null);\nvar map__26484_26870 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26480_26868,(1),null);\nvar map__26484_26871__$1 \x3d cljs.core.__destructure_map(map__26484_26870);\nvar doc_26872 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26484_26871__$1,new cljs.core.Keyword(null,\x22doc\x22,\x22doc\x22,1913296891));\nvar arglists_26873 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26484_26871__$1,new cljs.core.Keyword(null,\x22arglists\x22,\x22arglists\x22,1661989754));\ncljs.core.println();\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,name_26869], 0));\n\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,arglists_26873], 0));\n\nif(cljs.core.truth_(doc_26872)){\ncljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22 \x22,doc_26872], 0));\n} else {\n}\n\n\nvar G__26876 \x3d cljs.core.next(seq__26353_26862__$1);\nvar G__26877 \x3d null;\nvar G__26878 \x3d (0);\nvar G__26879 \x3d (0);\nseq__26353_26844 \x3d G__26876;\nchunk__26354_26845 \x3d G__26877;\ncount__26355_26846 \x3d G__26878;\ni__26356_26847 \x3d G__26879;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n} else {\n}\n\nif(cljs.core.truth_(n)){\nvar temp__5804__auto__ \x3d cljs.spec.alpha.get_spec(cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.ns_name(n)),cljs.core.name(nm)));\nif(cljs.core.truth_(temp__5804__auto__)){\nvar fnspec \x3d temp__5804__auto__;\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22Spec\x22], 0));\n\nvar seq__26537 \x3d cljs.core.seq(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22args\x22,\x22args\x22,1315556576),new cljs.core.Keyword(null,\x22ret\x22,\x22ret\x22,-468222814),new cljs.core.Keyword(null,\x22fn\x22,\x22fn\x22,-1175266204)], null));\nvar chunk__26538 \x3d null;\nvar count__26539 \x3d (0);\nvar i__26540 \x3d (0);\nwhile(true){\nif((i__26540 \x3c count__26539)){\nvar role \x3d chunk__26538.cljs$core$IIndexed$_nth$arity$2(null, i__26540);\nvar temp__5804__auto___26887__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(fnspec,role);\nif(cljs.core.truth_(temp__5804__auto___26887__$1)){\nvar spec_26888 \x3d temp__5804__auto___26887__$1;\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22\\n \x22,cljs.core.name(role),\x22:\x22].join(\x27\x27),cljs.spec.alpha.describe(spec_26888)], 0));\n} else {\n}\n\n\nvar G__26892 \x3d seq__26537;\nvar G__26893 \x3d chunk__26538;\nvar G__26894 \x3d count__26539;\nvar G__26895 \x3d (i__26540 + (1));\nseq__26537 \x3d G__26892;\nchunk__26538 \x3d G__26893;\ncount__26539 \x3d G__26894;\ni__26540 \x3d G__26895;\ncontinue;\n} else {\nvar temp__5804__auto____$1 \x3d cljs.core.seq(seq__26537);\nif(temp__5804__auto____$1){\nvar seq__26537__$1 \x3d temp__5804__auto____$1;\nif(cljs.core.chunked_seq_QMARK_(seq__26537__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__26537__$1);\nvar G__26896 \x3d cljs.core.chunk_rest(seq__26537__$1);\nvar G__26897 \x3d c__5525__auto__;\nvar G__26898 \x3d cljs.core.count(c__5525__auto__);\nvar G__26899 \x3d (0);\nseq__26537 \x3d G__26896;\nchunk__26538 \x3d G__26897;\ncount__26539 \x3d G__26898;\ni__26540 \x3d G__26899;\ncontinue;\n} else {\nvar role \x3d cljs.core.first(seq__26537__$1);\nvar temp__5804__auto___26900__$2 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(fnspec,role);\nif(cljs.core.truth_(temp__5804__auto___26900__$2)){\nvar spec_26901 \x3d temp__5804__auto___26900__$2;\ncljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([[\x22\\n \x22,cljs.core.name(role),\x22:\x22].join(\x27\x27),cljs.spec.alpha.describe(spec_26901)], 0));\n} else {\n}\n\n\nvar G__26902 \x3d cljs.core.next(seq__26537__$1);\nvar G__26903 \x3d null;\nvar G__26904 \x3d (0);\nvar G__26905 \x3d (0);\nseq__26537 \x3d G__26902;\nchunk__26538 \x3d G__26903;\ncount__26539 \x3d G__26904;\ni__26540 \x3d G__26905;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n}\n});\n/**\n * Constructs a data representation for a Error with keys:\n *  :cause - root cause message\n *  :phase - error phase\n *  :via - cause chain, with cause keys:\n *           :type - exception class symbol\n *           :message - exception message\n *           :data - ex-data\n *           :at - top stack element\n *  :trace - root cause stack elements\n */\ncljs.repl.Error__GT_map \x3d (function cljs$repl$Error__GT_map(o){\nreturn cljs.core.Throwable__GT_map(o);\n});\n/**\n * Returns an analysis of the phase, error, cause, and location of an error that occurred\n *   based on Throwable data, as returned by Throwable-\x3emap. All attributes other than phase\n *   are optional:\n *  :clojure.error/phase - keyword phase indicator, one of:\n *    :read-source :compile-syntax-check :compilation :macro-syntax-check :macroexpansion\n *    :execution :read-eval-result :print-eval-result\n *  :clojure.error/source - file name (no path)\n *  :clojure.error/line - integer line number\n *  :clojure.error/column - integer column number\n *  :clojure.error/symbol - symbol being expanded/compiled/invoked\n *  :clojure.error/class - cause exception class symbol\n *  :clojure.error/cause - cause exception message\n *  :clojure.error/spec - explain-data for spec error\n */\ncljs.repl.ex_triage \x3d (function cljs$repl$ex_triage(datafied_throwable){\nvar map__26611 \x3d datafied_throwable;\nvar map__26611__$1 \x3d cljs.core.__destructure_map(map__26611);\nvar via \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26611__$1,new cljs.core.Keyword(null,\x22via\x22,\x22via\x22,-1904457336));\nvar trace \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26611__$1,new cljs.core.Keyword(null,\x22trace\x22,\x22trace\x22,-1082747415));\nvar phase \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__26611__$1,new cljs.core.Keyword(null,\x22phase\x22,\x22phase\x22,575722892),new cljs.core.Keyword(null,\x22execution\x22,\x22execution\x22,253283524));\nvar map__26612 \x3d cljs.core.last(via);\nvar map__26612__$1 \x3d cljs.core.__destructure_map(map__26612);\nvar type \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26612__$1,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348));\nvar message \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26612__$1,new cljs.core.Keyword(null,\x22message\x22,\x22message\x22,-406056002));\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26612__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\nvar map__26615 \x3d data;\nvar map__26615__$1 \x3d cljs.core.__destructure_map(map__26615);\nvar problems \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26615__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22problems\x22,\x22cljs.spec.alpha/problems\x22,447400814));\nvar fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26615__$1,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22fn\x22,\x22cljs.spec.alpha/fn\x22,408600443));\nvar caller \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26615__$1,new cljs.core.Keyword(\x22cljs.spec.test.alpha\x22,\x22caller\x22,\x22cljs.spec.test.alpha/caller\x22,-398302390));\nvar map__26616 \x3d new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377).cljs$core$IFn$_invoke$arity$1(cljs.core.first(via));\nvar map__26616__$1 \x3d cljs.core.__destructure_map(map__26616);\nvar top_data \x3d map__26616__$1;\nvar source \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26616__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397));\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3((function (){var G__26645 \x3d phase;\nvar G__26645__$1 \x3d (((G__26645 instanceof cljs.core.Keyword))?G__26645.fqn:null);\nswitch (G__26645__$1) {\ncase \x22read-source\x22:\nvar map__26647 \x3d data;\nvar map__26647__$1 \x3d cljs.core.__destructure_map(map__26647);\nvar line \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26647__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22line\x22,\x22clojure.error/line\x22,-1816287471));\nvar column \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26647__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22column\x22,\x22clojure.error/column\x22,304721553));\nvar G__26650 \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377).cljs$core$IFn$_invoke$arity$1(cljs.core.second(via)),top_data], 0));\nvar G__26650__$1 \x3d (cljs.core.truth_(source)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26650,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397),source):G__26650);\nvar G__26650__$2 \x3d (cljs.core.truth_((function (){var fexpr__26652 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [\x22NO_SOURCE_PATH\x22,null,\x22NO_SOURCE_FILE\x22,null], null), null);\nreturn (fexpr__26652.cljs$core$IFn$_invoke$arity$1 ? fexpr__26652.cljs$core$IFn$_invoke$arity$1(source) : fexpr__26652.call(null, source));\n})())?cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(G__26650__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397)):G__26650__$1);\nif(cljs.core.truth_(message)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26650__$2,new cljs.core.Keyword(\x22clojure.error\x22,\x22cause\x22,\x22clojure.error/cause\x22,-1879175742),message);\n} else {\nreturn G__26650__$2;\n}\n\nbreak;\ncase \x22compile-syntax-check\x22:\ncase \x22compilation\x22:\ncase \x22macro-syntax-check\x22:\ncase \x22macroexpansion\x22:\nvar G__26653 \x3d top_data;\nvar G__26653__$1 \x3d (cljs.core.truth_(source)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26653,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397),source):G__26653);\nvar G__26653__$2 \x3d (cljs.core.truth_((function (){var fexpr__26655 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [\x22NO_SOURCE_PATH\x22,null,\x22NO_SOURCE_FILE\x22,null], null), null);\nreturn (fexpr__26655.cljs$core$IFn$_invoke$arity$1 ? fexpr__26655.cljs$core$IFn$_invoke$arity$1(source) : fexpr__26655.call(null, source));\n})())?cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(G__26653__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397)):G__26653__$1);\nvar G__26653__$3 \x3d (cljs.core.truth_(type)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26653__$2,new cljs.core.Keyword(\x22clojure.error\x22,\x22class\x22,\x22clojure.error/class\x22,278435890),type):G__26653__$2);\nvar G__26653__$4 \x3d (cljs.core.truth_(message)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26653__$3,new cljs.core.Keyword(\x22clojure.error\x22,\x22cause\x22,\x22clojure.error/cause\x22,-1879175742),message):G__26653__$3);\nif(cljs.core.truth_(problems)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26653__$4,new cljs.core.Keyword(\x22clojure.error\x22,\x22spec\x22,\x22clojure.error/spec\x22,2055032595),data);\n} else {\nreturn G__26653__$4;\n}\n\nbreak;\ncase \x22read-eval-result\x22:\ncase \x22print-eval-result\x22:\nvar vec__26662 \x3d cljs.core.first(trace);\nvar source__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26662,(0),null);\nvar method \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26662,(1),null);\nvar file \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26662,(2),null);\nvar line \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26662,(3),null);\nvar G__26670 \x3d top_data;\nvar G__26670__$1 \x3d (cljs.core.truth_(line)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26670,new cljs.core.Keyword(\x22clojure.error\x22,\x22line\x22,\x22clojure.error/line\x22,-1816287471),line):G__26670);\nvar G__26670__$2 \x3d (cljs.core.truth_(file)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26670__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397),file):G__26670__$1);\nvar G__26670__$3 \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d source__$1;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn method;\n} else {\nreturn and__5000__auto__;\n}\n})())?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26670__$2,new cljs.core.Keyword(\x22clojure.error\x22,\x22symbol\x22,\x22clojure.error/symbol\x22,1544821994),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[source__$1,method],null))):G__26670__$2);\nvar G__26670__$4 \x3d (cljs.core.truth_(type)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26670__$3,new cljs.core.Keyword(\x22clojure.error\x22,\x22class\x22,\x22clojure.error/class\x22,278435890),type):G__26670__$3);\nif(cljs.core.truth_(message)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26670__$4,new cljs.core.Keyword(\x22clojure.error\x22,\x22cause\x22,\x22clojure.error/cause\x22,-1879175742),message);\n} else {\nreturn G__26670__$4;\n}\n\nbreak;\ncase \x22execution\x22:\nvar vec__26685 \x3d cljs.core.first(trace);\nvar source__$1 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26685,(0),null);\nvar method \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26685,(1),null);\nvar file \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26685,(2),null);\nvar line \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__26685,(3),null);\nvar file__$1 \x3d cljs.core.first(cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p1__26605_SHARP_){\nvar or__5002__auto__ \x3d (p1__26605_SHARP_ \x3d\x3d null);\nif(or__5002__auto__){\nreturn or__5002__auto__;\n} else {\nvar fexpr__26692 \x3d new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [\x22NO_SOURCE_PATH\x22,null,\x22NO_SOURCE_FILE\x22,null], null), null);\nreturn (fexpr__26692.cljs$core$IFn$_invoke$arity$1 ? fexpr__26692.cljs$core$IFn$_invoke$arity$1(p1__26605_SHARP_) : fexpr__26692.call(null, p1__26605_SHARP_));\n}\n}),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22file\x22,\x22file\x22,-1269645878).cljs$core$IFn$_invoke$arity$1(caller),file], null)));\nvar err_line \x3d (function (){var or__5002__auto__ \x3d new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235).cljs$core$IFn$_invoke$arity$1(caller);\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn line;\n}\n})();\nvar G__26693 \x3d new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(\x22clojure.error\x22,\x22class\x22,\x22clojure.error/class\x22,278435890),type], null);\nvar G__26693__$1 \x3d (cljs.core.truth_(err_line)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26693,new cljs.core.Keyword(\x22clojure.error\x22,\x22line\x22,\x22clojure.error/line\x22,-1816287471),err_line):G__26693);\nvar G__26693__$2 \x3d (cljs.core.truth_(message)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26693__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22cause\x22,\x22clojure.error/cause\x22,-1879175742),message):G__26693__$1);\nvar G__26693__$3 \x3d (cljs.core.truth_((function (){var or__5002__auto__ \x3d fn;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar and__5000__auto__ \x3d source__$1;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn method;\n} else {\nreturn and__5000__auto__;\n}\n}\n})())?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26693__$2,new cljs.core.Keyword(\x22clojure.error\x22,\x22symbol\x22,\x22clojure.error/symbol\x22,1544821994),(function (){var or__5002__auto__ \x3d fn;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[source__$1,method],null));\n}\n})()):G__26693__$2);\nvar G__26693__$4 \x3d (cljs.core.truth_(file__$1)?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26693__$3,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397),file__$1):G__26693__$3);\nif(cljs.core.truth_(problems)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__26693__$4,new cljs.core.Keyword(\x22clojure.error\x22,\x22spec\x22,\x22clojure.error/spec\x22,2055032595),data);\n} else {\nreturn G__26693__$4;\n}\n\nbreak;\ndefault:\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__26645__$1)].join(\x27\x27)));\n\n}\n})(),new cljs.core.Keyword(\x22clojure.error\x22,\x22phase\x22,\x22clojure.error/phase\x22,275140358),phase);\n});\n/**\n * Returns a string from exception data, as produced by ex-triage.\n *   The first line summarizes the exception phase and location.\n *   The subsequent lines describe the cause.\n */\ncljs.repl.ex_str \x3d (function cljs$repl$ex_str(p__26704){\nvar map__26705 \x3d p__26704;\nvar map__26705__$1 \x3d cljs.core.__destructure_map(map__26705);\nvar triage_data \x3d map__26705__$1;\nvar phase \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22phase\x22,\x22clojure.error/phase\x22,275140358));\nvar source \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22source\x22,\x22clojure.error/source\x22,-2011936397));\nvar line \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22line\x22,\x22clojure.error/line\x22,-1816287471));\nvar column \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22column\x22,\x22clojure.error/column\x22,304721553));\nvar symbol \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22symbol\x22,\x22clojure.error/symbol\x22,1544821994));\nvar class$ \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22class\x22,\x22clojure.error/class\x22,278435890));\nvar cause \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22cause\x22,\x22clojure.error/cause\x22,-1879175742));\nvar spec \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__26705__$1,new cljs.core.Keyword(\x22clojure.error\x22,\x22spec\x22,\x22clojure.error/spec\x22,2055032595));\nvar loc \x3d [cljs.core.str.cljs$core$IFn$_invoke$arity$1((function (){var or__5002__auto__ \x3d source;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn \x22\x3ccljs repl\x3e\x22;\n}\n})()),\x22:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1((function (){var or__5002__auto__ \x3d line;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (1);\n}\n})()),(cljs.core.truth_(column)?[\x22:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(column)].join(\x27\x27):\x22\x22)].join(\x27\x27);\nvar class_name \x3d cljs.core.name((function (){var or__5002__auto__ \x3d class$;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn \x22\x22;\n}\n})());\nvar simple_class \x3d class_name;\nvar cause_type \x3d ((cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [\x22RuntimeException\x22,null,\x22Exception\x22,null], null), null),simple_class))?\x22\x22:[\x22 (\x22,simple_class,\x22)\x22].join(\x27\x27));\nvar format \x3d goog.string.format;\nvar G__26730 \x3d phase;\nvar G__26730__$1 \x3d (((G__26730 instanceof cljs.core.Keyword))?G__26730.fqn:null);\nswitch (G__26730__$1) {\ncase \x22read-source\x22:\nreturn (format.cljs$core$IFn$_invoke$arity$3 ? format.cljs$core$IFn$_invoke$arity$3(\x22Syntax error reading source at (%s).\\n%s\\n\x22,loc,cause) : format.call(null, \x22Syntax error reading source at (%s).\\n%s\\n\x22,loc,cause));\n\nbreak;\ncase \x22macro-syntax-check\x22:\nvar G__26734 \x3d \x22Syntax error macroexpanding %sat (%s).\\n%s\x22;\nvar G__26735 \x3d (cljs.core.truth_(symbol)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(symbol),\x22 \x22].join(\x27\x27):\x22\x22);\nvar G__26736 \x3d loc;\nvar G__26737 \x3d (cljs.core.truth_(spec)?(function (){var sb__5647__auto__ \x3d (new goog.string.StringBuffer());\nvar _STAR_print_newline_STAR__orig_val__26741_26945 \x3d cljs.core._STAR_print_newline_STAR_;\nvar _STAR_print_fn_STAR__orig_val__26742_26946 \x3d cljs.core._STAR_print_fn_STAR_;\nvar _STAR_print_newline_STAR__temp_val__26743_26947 \x3d true;\nvar _STAR_print_fn_STAR__temp_val__26744_26948 \x3d (function (x__5648__auto__){\nreturn sb__5647__auto__.append(x__5648__auto__);\n});\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__temp_val__26743_26947);\n\n(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__temp_val__26744_26948);\n\ntry{cljs.spec.alpha.explain_out(cljs.core.update.cljs$core$IFn$_invoke$arity$3(spec,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22problems\x22,\x22cljs.spec.alpha/problems\x22,447400814),(function (probs){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__26702_SHARP_){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(p1__26702_SHARP_,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865));\n}),probs);\n}))\n);\n}finally {(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__orig_val__26742_26946);\n\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__orig_val__26741_26945);\n}\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb__5647__auto__);\n})():(format.cljs$core$IFn$_invoke$arity$2 ? format.cljs$core$IFn$_invoke$arity$2(\x22%s\\n\x22,cause) : format.call(null, \x22%s\\n\x22,cause)));\nreturn (format.cljs$core$IFn$_invoke$arity$4 ? format.cljs$core$IFn$_invoke$arity$4(G__26734,G__26735,G__26736,G__26737) : format.call(null, G__26734,G__26735,G__26736,G__26737));\n\nbreak;\ncase \x22macroexpansion\x22:\nvar G__26757 \x3d \x22Unexpected error%s macroexpanding %sat (%s).\\n%s\\n\x22;\nvar G__26758 \x3d cause_type;\nvar G__26759 \x3d (cljs.core.truth_(symbol)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(symbol),\x22 \x22].join(\x27\x27):\x22\x22);\nvar G__26760 \x3d loc;\nvar G__26761 \x3d cause;\nreturn (format.cljs$core$IFn$_invoke$arity$5 ? format.cljs$core$IFn$_invoke$arity$5(G__26757,G__26758,G__26759,G__26760,G__26761) : format.call(null, G__26757,G__26758,G__26759,G__26760,G__26761));\n\nbreak;\ncase \x22compile-syntax-check\x22:\nvar G__26765 \x3d \x22Syntax error%s compiling %sat (%s).\\n%s\\n\x22;\nvar G__26766 \x3d cause_type;\nvar G__26767 \x3d (cljs.core.truth_(symbol)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(symbol),\x22 \x22].join(\x27\x27):\x22\x22);\nvar G__26768 \x3d loc;\nvar G__26769 \x3d cause;\nreturn (format.cljs$core$IFn$_invoke$arity$5 ? format.cljs$core$IFn$_invoke$arity$5(G__26765,G__26766,G__26767,G__26768,G__26769) : format.call(null, G__26765,G__26766,G__26767,G__26768,G__26769));\n\nbreak;\ncase \x22compilation\x22:\nvar G__26770 \x3d \x22Unexpected error%s compiling %sat (%s).\\n%s\\n\x22;\nvar G__26771 \x3d cause_type;\nvar G__26772 \x3d (cljs.core.truth_(symbol)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(symbol),\x22 \x22].join(\x27\x27):\x22\x22);\nvar G__26773 \x3d loc;\nvar G__26774 \x3d cause;\nreturn (format.cljs$core$IFn$_invoke$arity$5 ? format.cljs$core$IFn$_invoke$arity$5(G__26770,G__26771,G__26772,G__26773,G__26774) : format.call(null, G__26770,G__26771,G__26772,G__26773,G__26774));\n\nbreak;\ncase \x22read-eval-result\x22:\nreturn (format.cljs$core$IFn$_invoke$arity$5 ? format.cljs$core$IFn$_invoke$arity$5(\x22Error reading eval result%s at %s (%s).\\n%s\\n\x22,cause_type,symbol,loc,cause) : format.call(null, \x22Error reading eval result%s at %s (%s).\\n%s\\n\x22,cause_type,symbol,loc,cause));\n\nbreak;\ncase \x22print-eval-result\x22:\nreturn (format.cljs$core$IFn$_invoke$arity$5 ? format.cljs$core$IFn$_invoke$arity$5(\x22Error printing return value%s at %s (%s).\\n%s\\n\x22,cause_type,symbol,loc,cause) : format.call(null, \x22Error printing return value%s at %s (%s).\\n%s\\n\x22,cause_type,symbol,loc,cause));\n\nbreak;\ncase \x22execution\x22:\nif(cljs.core.truth_(spec)){\nvar G__26778 \x3d \x22Execution error - invalid arguments to %s at (%s).\\n%s\x22;\nvar G__26779 \x3d symbol;\nvar G__26780 \x3d loc;\nvar G__26781 \x3d (function (){var sb__5647__auto__ \x3d (new goog.string.StringBuffer());\nvar _STAR_print_newline_STAR__orig_val__26785_26969 \x3d cljs.core._STAR_print_newline_STAR_;\nvar _STAR_print_fn_STAR__orig_val__26786_26970 \x3d cljs.core._STAR_print_fn_STAR_;\nvar _STAR_print_newline_STAR__temp_val__26787_26971 \x3d true;\nvar _STAR_print_fn_STAR__temp_val__26788_26972 \x3d (function (x__5648__auto__){\nreturn sb__5647__auto__.append(x__5648__auto__);\n});\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__temp_val__26787_26971);\n\n(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__temp_val__26788_26972);\n\ntry{cljs.spec.alpha.explain_out(cljs.core.update.cljs$core$IFn$_invoke$arity$3(spec,new cljs.core.Keyword(\x22cljs.spec.alpha\x22,\x22problems\x22,\x22cljs.spec.alpha/problems\x22,447400814),(function (probs){\nreturn cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__26703_SHARP_){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(p1__26703_SHARP_,new cljs.core.Keyword(null,\x22in\x22,\x22in\x22,-1531184865));\n}),probs);\n}))\n);\n}finally {(cljs.core._STAR_print_fn_STAR_ \x3d _STAR_print_fn_STAR__orig_val__26786_26970);\n\n(cljs.core._STAR_print_newline_STAR_ \x3d _STAR_print_newline_STAR__orig_val__26785_26969);\n}\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb__5647__auto__);\n})();\nreturn (format.cljs$core$IFn$_invoke$arity$4 ? format.cljs$core$IFn$_invoke$arity$4(G__26778,G__26779,G__26780,G__26781) : format.call(null, G__26778,G__26779,G__26780,G__26781));\n} else {\nvar G__26795 \x3d \x22Execution error%s at %s(%s).\\n%s\\n\x22;\nvar G__26796 \x3d cause_type;\nvar G__26797 \x3d (cljs.core.truth_(symbol)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(symbol),\x22 \x22].join(\x27\x27):\x22\x22);\nvar G__26798 \x3d loc;\nvar G__26799 \x3d cause;\nreturn (format.cljs$core$IFn$_invoke$arity$5 ? format.cljs$core$IFn$_invoke$arity$5(G__26795,G__26796,G__26797,G__26798,G__26799) : format.call(null, G__26795,G__26796,G__26797,G__26798,G__26799));\n}\n\nbreak;\ndefault:\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__26730__$1)].join(\x27\x27)));\n\n}\n});\ncljs.repl.error__GT_str \x3d (function cljs$repl$error__GT_str(error){\nreturn cljs.repl.ex_str(cljs.repl.ex_triage(cljs.repl.Error__GT_map(error)));\n});\n");
SHADOW_ENV.evalLoad("shadow.remote.runtime.obj_support.js", true, "goog.provide(\x27shadow.remote.runtime.obj_support\x27);\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n*/\nshadow.remote.runtime.obj_support.Reference \x3d (function (obj,extra,__meta,__extmap,__hash){\nthis.obj \x3d obj;\nthis.extra \x3d extra;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k27711,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__27735 \x3d k27711;\nvar G__27735__$1 \x3d (((G__27735 instanceof cljs.core.Keyword))?G__27735.fqn:null);\nswitch (G__27735__$1) {\ncase \x22obj\x22:\nreturn self__.obj;\n\nbreak;\ncase \x22extra\x22:\nreturn self__.extra;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k27711,else__5303__auto__);\n\n}\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__27741){\nvar vec__27744 \x3d p__27741;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27744,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__27744,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#shadow.remote.runtime.obj-support.Reference{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),self__.obj],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067),self__.extra],null))], null),self__.__extmap));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__27710){\nvar self__ \x3d this;\nvar G__27710__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__27710__$1,2,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new shadow.remote.runtime.obj_support.Reference(self__.obj,self__.extra,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (2 + cljs.core.count(self__.__extmap));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (1775716890 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this27712,other27713){\nvar self__ \x3d this;\nvar this27712__$1 \x3d this;\nreturn (((!((other27713 \x3d\x3d null)))) \x26\x26 ((((this27712__$1.constructor \x3d\x3d\x3d other27713.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this27712__$1.obj,other27713.obj)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this27712__$1.extra,other27713.extra)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this27712__$1.__extmap,other27713.__extmap)))))))));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067),null,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new shadow.remote.runtime.obj_support.Reference(self__.obj,self__.extra,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k27711){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__27800 \x3d k27711;\nvar G__27800__$1 \x3d (((G__27800 instanceof cljs.core.Keyword))?G__27800.fqn:null);\nswitch (G__27800__$1) {\ncase \x22obj\x22:\ncase \x22extra\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k27711);\n\n}\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__27710){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__27811 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__27813 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__27811.cljs$core$IFn$_invoke$arity$2 ? pred__27811.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),expr__27813) : pred__27811.call(null, new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),expr__27813)))){\nreturn (new shadow.remote.runtime.obj_support.Reference(G__27710,self__.extra,self__.__meta,self__.__extmap,null));\n} else {\nif(cljs.core.truth_((pred__27811.cljs$core$IFn$_invoke$arity$2 ? pred__27811.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067),expr__27813) : pred__27811.call(null, new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067),expr__27813)))){\nreturn (new shadow.remote.runtime.obj_support.Reference(self__.obj,G__27710,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new shadow.remote.runtime.obj_support.Reference(self__.obj,self__.extra,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__27710),null));\n}\n}\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),self__.obj,null)),(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067),self__.extra,null))], null),self__.__extmap));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__27710){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new shadow.remote.runtime.obj_support.Reference(self__.obj,self__.extra,G__27710,self__.__extmap,self__.__hash));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(shadow.remote.runtime.obj_support.Reference.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22obj\x22,\x22obj\x22,-1672671807,null),new cljs.core.Symbol(null,\x22extra\x22,\x22extra\x22,-1041866702,null)], null);\n}));\n\n(shadow.remote.runtime.obj_support.Reference.cljs$lang$type \x3d true);\n\n(shadow.remote.runtime.obj_support.Reference.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22shadow.remote.runtime.obj-support/Reference\x22,null,(1),null));\n}));\n\n(shadow.remote.runtime.obj_support.Reference.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22shadow.remote.runtime.obj-support/Reference\x22);\n}));\n\n/**\n * Positional factory function for shadow.remote.runtime.obj-support/Reference.\n */\nshadow.remote.runtime.obj_support.__GT_Reference \x3d (function shadow$remote$runtime$obj_support$__GT_Reference(obj,extra){\nreturn (new shadow.remote.runtime.obj_support.Reference(obj,extra,null,null,null));\n});\n\n/**\n * Factory function for shadow.remote.runtime.obj-support/Reference, taking a map of keywords to field values.\n */\nshadow.remote.runtime.obj_support.map__GT_Reference \x3d (function shadow$remote$runtime$obj_support$map__GT_Reference(G__27717){\nvar extmap__5342__auto__ \x3d (function (){var G__27848 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__27717,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067)], 0));\nif(cljs.core.record_QMARK_(G__27717)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__27848);\n} else {\nreturn G__27848;\n}\n})();\nreturn (new shadow.remote.runtime.obj_support.Reference(new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962).cljs$core$IFn$_invoke$arity$1(G__27717),new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067).cljs$core$IFn$_invoke$arity$1(G__27717),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\nshadow.remote.runtime.obj_support.obj_ref \x3d (function shadow$remote$runtime$obj_support$obj_ref(var_args){\nvar G__27861 \x3d arguments.length;\nswitch (G__27861) {\ncase 1:\nreturn shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$1 \x3d (function (obj){\nreturn shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$2(obj,null);\n}));\n\n(shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$2 \x3d (function (obj,extra){\nif((!((obj \x3d\x3d null)))){\nreturn (new shadow.remote.runtime.obj_support.Reference(obj,extra,null,null,null));\n} else {\nreturn null;\n}\n}));\n\n(shadow.remote.runtime.obj_support.obj_ref.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.remote.runtime.obj_support.obj_ref_QMARK_ \x3d (function shadow$remote$runtime$obj_support$obj_ref_QMARK_(result){\nreturn (result instanceof shadow.remote.runtime.obj_support.Reference);\n});\nshadow.remote.runtime.obj_support.now \x3d (function shadow$remote$runtime$obj_support$now(){\nreturn Date.now();\n});\nshadow.remote.runtime.obj_support.next_oid \x3d (function shadow$remote$runtime$obj_support$next_oid(){\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.random_uuid());\n});\nshadow.remote.runtime.obj_support.register_STAR_ \x3d (function shadow$remote$runtime$obj_support$register_STAR_(state,oid,obj,obj_info){\nvar ts \x3d shadow.remote.runtime.obj_support.now();\nvar entry \x3d new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962),obj,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377),clojure.datafy.datafy(obj),new cljs.core.Keyword(null,\x22obj-info\x22,\x22obj-info\x22,-373842651),obj_info,new cljs.core.Keyword(null,\x22added-at\x22,\x22added-at\x22,-352499434),ts,new cljs.core.Keyword(null,\x22access-at\x22,\x22access-at\x22,-1487162729),ts,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid], null);\nreturn cljs.core.assoc_in(state,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),oid], null),entry);\n});\nshadow.remote.runtime.obj_support.obj_type_string \x3d (function shadow$remote$runtime$obj_support$obj_type_string(obj){\nif((obj \x3d\x3d null)){\nreturn \x22nil\x22;\n} else {\nreturn cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.type(obj)], 0));\n}\n});\nshadow.remote.runtime.obj_support.get_data_type \x3d (function shadow$remote$runtime$obj_support$get_data_type(summary,p__27899){\nvar map__27900 \x3d p__27899;\nvar map__27900__$1 \x3d cljs.core.__destructure_map(map__27900);\nvar entry \x3d map__27900__$1;\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27900__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\ntry{if((data \x3d\x3d null)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22nil\x22,\x22nil\x22,99600501));\n} else {\nif(typeof data \x3d\x3d\x3d \x27string\x27){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22string\x22,\x22string\x22,-1989541586),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data-count\x22,\x22data-count\x22,1898198662),((data).length)], 0));\n} else {\nif(cljs.core.boolean_QMARK_(data)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22boolean\x22,\x22boolean\x22,-1919418404));\n} else {\nif(typeof data \x3d\x3d\x3d \x27number\x27){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22number\x22,\x22number\x22,1570378438));\n} else {\nif((data instanceof cljs.core.Keyword)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22keyword\x22,\x22keyword\x22,811389747));\n} else {\nif((data instanceof cljs.core.Symbol)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22symbol\x22,\x22symbol\x22,-1038572696));\n} else {\nif(cljs.core.map_QMARK_(data)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22map\x22,\x22map\x22,1371690461),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data-count\x22,\x22data-count\x22,1898198662),cljs.core.count(data)], 0));\n} else {\nif(cljs.core.vector_QMARK_(data)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22vec\x22,\x22vec\x22,-657847931),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data-count\x22,\x22data-count\x22,1898198662),cljs.core.count(data)], 0));\n} else {\nif(cljs.core.set_QMARK_(data)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22set\x22,\x22set\x22,304602554),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data-count\x22,\x22data-count\x22,1898198662),cljs.core.count(data)], 0));\n} else {\nif(cljs.core.list_QMARK_(data)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22list\x22,\x22list\x22,765357683),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data-count\x22,\x22data-count\x22,1898198662),cljs.core.count(data)], 0));\n} else {\nif(cljs.core.seq_QMARK_(data)){\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22seq\x22,\x22seq\x22,-1817803783));\n} else {\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22unsupported\x22,\x22unsupported\x22,-1045607016));\n\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}\n}catch (e27905){var e \x3d e27905;\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(summary,new cljs.core.Keyword(null,\x22data-type\x22,\x22data-type\x22,-326421468),new cljs.core.Keyword(null,\x22unsupported\x22,\x22unsupported\x22,-1045607016),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22data-type-fail\x22,\x22data-type-fail\x22,1917235450),true], 0));\n}});\nshadow.remote.runtime.obj_support.merge_source_info \x3d (function shadow$remote$runtime$obj_support$merge_source_info(summary,p__27921){\nvar map__27922 \x3d p__27921;\nvar map__27922__$1 \x3d cljs.core.__destructure_map(map__27922);\nvar obj_info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27922__$1,new cljs.core.Keyword(null,\x22obj-info\x22,\x22obj-info\x22,-373842651));\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([summary,cljs.core.select_keys(obj_info,new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095),new cljs.core.Keyword(null,\x22label\x22,\x22label\x22,1718410804)], null))], 0));\n});\nshadow.remote.runtime.obj_support.inspect_entry_BANG_ \x3d (function shadow$remote$runtime$obj_support$inspect_entry_BANG_(p__27923,p__27924){\nvar map__27925 \x3d p__27923;\nvar map__27925__$1 \x3d cljs.core.__destructure_map(map__27925);\nvar this$ \x3d map__27925__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27925__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar map__27926 \x3d p__27924;\nvar map__27926__$1 \x3d cljs.core.__destructure_map(map__27926);\nvar entry \x3d map__27926__$1;\nvar obj \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27926__$1,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962));\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27926__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\nvar added_at \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27926__$1,new cljs.core.Keyword(null,\x22added-at\x22,\x22added-at\x22,-352499434));\nvar $ \x3d shadow.remote.runtime.obj_support.merge_source_info(shadow.remote.runtime.obj_support.get_data_type(new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22added-at\x22,\x22added-at\x22,-352499434),added_at,new cljs.core.Keyword(null,\x22datafied\x22,\x22datafied\x22,2076148104),(!((data \x3d\x3d\x3d obj))),new cljs.core.Keyword(null,\x22obj-type\x22,\x22obj-type\x22,-1658555496),shadow.remote.runtime.obj_support.obj_type_string(obj),new cljs.core.Keyword(null,\x22preview\x22,\x22preview\x22,451279890),shadow.remote.runtime.writer.pr_str_limit(obj,(250)),new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.PersistentHashSet.EMPTY], null),entry),entry);\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (summary,inspect_fn){\nreturn (inspect_fn.cljs$core$IFn$_invoke$arity$2 ? inspect_fn.cljs$core$IFn$_invoke$arity$2(summary,entry) : inspect_fn.call(null, summary,entry));\n}),$,new cljs.core.Keyword(null,\x22inspectors\x22,\x22inspectors\x22,-426448246).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref)));\n});\nshadow.remote.runtime.obj_support.obj_describe_STAR_ \x3d (function shadow$remote$runtime$obj_support$obj_describe_STAR_(p__27928,oid){\nvar map__27929 \x3d p__27928;\nvar map__27929__$1 \x3d cljs.core.__destructure_map(map__27929);\nvar this$ \x3d map__27929__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27929__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar temp__5808__auto__ \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(state_ref),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),oid], null));\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar entry \x3d temp__5808__auto__;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc_in,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),oid,new cljs.core.Keyword(null,\x22access-at\x22,\x22access-at\x22,-1487162729)], null),shadow.remote.runtime.obj_support.now());\n\nreturn shadow.remote.runtime.obj_support.inspect_entry_BANG_(this$,entry);\n}\n});\nshadow.remote.runtime.obj_support.handler_with_object \x3d (function shadow$remote$runtime$obj_support$handler_with_object(handler_fn){\nreturn (function (p__27931,p__27932){\nvar map__27933 \x3d p__27931;\nvar map__27933__$1 \x3d cljs.core.__destructure_map(map__27933);\nvar this$ \x3d map__27933__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27933__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27933__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar map__27934 \x3d p__27932;\nvar map__27934__$1 \x3d cljs.core.__destructure_map(map__27934);\nvar msg \x3d map__27934__$1;\nvar op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27934__$1,new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955));\nvar oid \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27934__$1,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334));\nvar entry \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(state_ref),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),oid], null));\nif(cljs.core.not(entry)){\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22obj-not-found\x22,\x22obj-not-found\x22,1577257696),new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid], null));\n} else {\ntry{cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc_in,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),oid,new cljs.core.Keyword(null,\x22access-at\x22,\x22access-at\x22,-1487162729)], null),shadow.remote.runtime.obj_support.now());\n\nvar result \x3d (handler_fn.cljs$core$IFn$_invoke$arity$3 ? handler_fn.cljs$core$IFn$_invoke$arity$3(this$,entry,msg) : handler_fn.call(null, this$,entry,msg));\nif((!(shadow.remote.runtime.obj_support.obj_ref_QMARK_(result)))){\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22obj-result\x22,\x22obj-result\x22,-486300152),new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid,new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211),result], null));\n} else {\nvar new_oid \x3d (function (){var G__27944 \x3d this$;\nvar G__27945 \x3d new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962).cljs$core$IFn$_invoke$arity$1(result);\nvar G__27946 \x3d cljs.core.PersistentArrayMap.EMPTY;\nreturn (shadow.remote.runtime.obj_support.register.cljs$core$IFn$_invoke$arity$3 ? shadow.remote.runtime.obj_support.register.cljs$core$IFn$_invoke$arity$3(G__27944,G__27945,G__27946) : shadow.remote.runtime.obj_support.register.call(null, G__27944,G__27945,G__27946));\n})();\nvar reply_msg \x3d (function (){var G__27948 \x3d new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22obj-result-ref\x22,\x22obj-result-ref\x22,1537374891),new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid,new cljs.core.Keyword(null,\x22ref-oid\x22,\x22ref-oid\x22,-526648644),new_oid], null);\nvar G__27948__$1 \x3d (cljs.core.truth_(new cljs.core.Keyword(null,\x22summary\x22,\x22summary\x22,380847952).cljs$core$IFn$_invoke$arity$1(msg))?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(G__27948,new cljs.core.Keyword(null,\x22summary\x22,\x22summary\x22,380847952),shadow.remote.runtime.obj_support.obj_describe_STAR_(this$,new_oid)):G__27948);\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067).cljs$core$IFn$_invoke$arity$1(result))){\nreturn cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([G__27948__$1,new cljs.core.Keyword(null,\x22extra\x22,\x22extra\x22,1612569067).cljs$core$IFn$_invoke$arity$1(result)], 0));\n} else {\nreturn G__27948__$1;\n}\n})();\nreturn shadow.remote.runtime.shared.reply(runtime,msg,reply_msg);\n}\n}catch (e27936){var e \x3d e27936;\nconsole.warn(\x22action-request-action failed\x22,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962).cljs$core$IFn$_invoke$arity$1(entry),e);\n\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22obj-request-failed\x22,\x22obj-request-failed\x22,-1782005406),new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid,new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),msg,new cljs.core.Keyword(null,\x22ex-oid\x22,\x22ex-oid\x22,-650256737),(function (){var G__27939 \x3d this$;\nvar G__27940 \x3d e;\nvar G__27941 \x3d new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),msg], null);\nreturn (shadow.remote.runtime.obj_support.register.cljs$core$IFn$_invoke$arity$3 ? shadow.remote.runtime.obj_support.register.cljs$core$IFn$_invoke$arity$3(G__27939,G__27940,G__27941) : shadow.remote.runtime.obj_support.register.call(null, G__27939,G__27940,G__27941));\n})()], null));\n}}\n});\n});\nshadow.remote.runtime.obj_support.obj_get_value \x3d shadow.remote.runtime.obj_support.handler_with_object((function (this$,p__27950,msg){\nvar map__27951 \x3d p__27950;\nvar map__27951__$1 \x3d cljs.core.__destructure_map(map__27951);\nvar entry \x3d map__27951__$1;\nvar obj \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27951__$1,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962));\nreturn obj;\n}));\nshadow.remote.runtime.obj_support.default_max_print_size \x3d (((1) * (1024)) * (1024));\nshadow.remote.runtime.obj_support.pick_target \x3d (function shadow$remote$runtime$obj_support$pick_target(entry,msg){\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22original\x22,\x22original\x22,-445386197).cljs$core$IFn$_invoke$arity$1(msg))){\nreturn new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962).cljs$core$IFn$_invoke$arity$1(entry);\n} else {\nreturn new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377).cljs$core$IFn$_invoke$arity$1(entry);\n}\n});\nshadow.remote.runtime.obj_support.obj_edn \x3d shadow.remote.runtime.obj_support.handler_with_object((function (this$,entry,p__27956){\nvar map__27957 \x3d p__27956;\nvar map__27957__$1 \x3d cljs.core.__destructure_map(map__27957);\nvar msg \x3d map__27957__$1;\nvar limit \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__27957__$1,new cljs.core.Keyword(null,\x22limit\x22,\x22limit\x22,-1355822363),shadow.remote.runtime.obj_support.default_max_print_size);\nvar target \x3d shadow.remote.runtime.obj_support.pick_target(entry,msg);\nvar lw \x3d shadow.remote.runtime.writer.limit_writer(limit);\ncljs.core.pr_writer(target,lw,cljs.core.pr_opts());\n\nreturn shadow.remote.runtime.writer.get_string(lw);\n}));\nshadow.remote.runtime.obj_support.obj_pprint \x3d shadow.remote.runtime.obj_support.handler_with_object((function (this$,entry,p__27963){\nvar map__27964 \x3d p__27963;\nvar map__27964__$1 \x3d cljs.core.__destructure_map(map__27964);\nvar msg \x3d map__27964__$1;\nvar limit \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__27964__$1,new cljs.core.Keyword(null,\x22limit\x22,\x22limit\x22,-1355822363),shadow.remote.runtime.obj_support.default_max_print_size);\nvar target \x3d shadow.remote.runtime.obj_support.pick_target(entry,msg);\nvar lw \x3d shadow.remote.runtime.writer.limit_writer(limit);\ncljs.pprint.pprint.cljs$core$IFn$_invoke$arity$2(target,lw);\n\nreturn shadow.remote.runtime.writer.get_string(lw);\n}));\nshadow.remote.runtime.obj_support.obj_edn_limit \x3d shadow.remote.runtime.obj_support.handler_with_object((function (this$,entry,p__27966){\nvar map__27967 \x3d p__27966;\nvar map__27967__$1 \x3d cljs.core.__destructure_map(map__27967);\nvar msg \x3d map__27967__$1;\nvar limit \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27967__$1,new cljs.core.Keyword(null,\x22limit\x22,\x22limit\x22,-1355822363));\nreturn shadow.remote.runtime.writer.pr_str_limit(shadow.remote.runtime.obj_support.pick_target(entry,msg),limit);\n}));\nshadow.remote.runtime.obj_support.obj_str \x3d shadow.remote.runtime.obj_support.handler_with_object((function (this$,p__27977,msg){\nvar map__27978 \x3d p__27977;\nvar map__27978__$1 \x3d cljs.core.__destructure_map(map__27978);\nvar entry \x3d map__27978__$1;\nvar obj \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27978__$1,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962));\nreturn cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj);\n}));\nshadow.remote.runtime.obj_support.obj_ex_str \x3d shadow.remote.runtime.obj_support.handler_with_object((function (this$,p__27991,msg){\nvar map__27992 \x3d p__27991;\nvar map__27992__$1 \x3d cljs.core.__destructure_map(map__27992);\nvar entry \x3d map__27992__$1;\nvar ex \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__27992__$1,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962));\nif((ex instanceof Error)){\nreturn cljs.repl.error__GT_str(ex);\n} else {\nreturn [\x22Execution error:\\n\x22,\x22  \x22,cljs.core.subs.cljs$core$IFn$_invoke$arity$2(shadow.remote.runtime.writer.pr_str_limit(ex,(200)),(2)),\x22\\n\x22,\x22\\n\x22].join(\x27\x27);\n}\n}));\nshadow.remote.runtime.obj_support.exception_QMARK_ \x3d (function shadow$remote$runtime$obj_support$exception_QMARK_(x){\nreturn true;\n});\nshadow.remote.runtime.obj_support.simple_value_QMARK_ \x3d (function shadow$remote$runtime$obj_support$simple_value_QMARK_(val){\nreturn (((val \x3d\x3d null)) || (((cljs.core.boolean_QMARK_(val)) || (((typeof val \x3d\x3d\x3d \x27number\x27) || ((((val instanceof cljs.core.Keyword)) || ((((((val instanceof cljs.core.Symbol)) \x26\x26 ((cljs.core.meta(val) \x3d\x3d null)))) || (((((typeof val \x3d\x3d\x3d \x27string\x27) \x26\x26 (((64) \x3e cljs.core.count(val))))) || (((cljs.core.coll_QMARK_(val)) \x26\x26 (((cljs.core.empty_QMARK_(val)) \x26\x26 ((cljs.core.meta(val) \x3d\x3d null)))))))))))))))));\n});\nshadow.remote.runtime.obj_support.rank_predicates \x3d new cljs.core.PersistentVector(null, 9, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.nil_QMARK_,cljs.core.boolean_QMARK_,cljs.core.number_QMARK_,cljs.core.string_QMARK_,cljs.core.keyword_QMARK_,cljs.core.symbol_QMARK_,cljs.core.vector_QMARK_,cljs.core.map_QMARK_,cljs.core.list_QMARK_], null);\nshadow.remote.runtime.obj_support.rank_val \x3d (function shadow$remote$runtime$obj_support$rank_val(val){\nreturn cljs.core.reduce_kv((function (res,idx,pred){\nif(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(val) : pred.call(null, val)))){\nreturn cljs.core.reduced(idx);\n} else {\nreturn res;\n}\n}),(-1),shadow.remote.runtime.obj_support.rank_predicates);\n});\nshadow.remote.runtime.obj_support.smart_comp \x3d (function shadow$remote$runtime$obj_support$smart_comp(a,b){\ntry{return cljs.core.compare(a,b);\n}catch (e28050){if((e28050 instanceof Error)){\nvar e \x3d e28050;\nvar ar \x3d shadow.remote.runtime.obj_support.rank_val(a);\nvar br \x3d shadow.remote.runtime.obj_support.rank_val(b);\nreturn cljs.core.compare(ar,br);\n} else {\nthrow e28050;\n\n}\n}});\nshadow.remote.runtime.obj_support.attempt_to_sort \x3d (function shadow$remote$runtime$obj_support$attempt_to_sort(coll){\nreturn cljs.core.vec((function (){try{return cljs.core.sort.cljs$core$IFn$_invoke$arity$2(shadow.remote.runtime.obj_support.smart_comp,coll);\n}catch (e28052){var e \x3d e28052;\nreturn coll;\n}})());\n});\nshadow.remote.runtime.obj_support.cache_view_order \x3d (function shadow$remote$runtime$obj_support$cache_view_order(state_ref,p__28056,coll){\nvar map__28057 \x3d p__28056;\nvar map__28057__$1 \x3d cljs.core.__destructure_map(map__28057);\nvar oid \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28057__$1,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334));\nvar view_order \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28057__$1,new cljs.core.Keyword(null,\x22view-order\x22,\x22view-order\x22,566761574));\nvar or__5002__auto__ \x3d view_order;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nvar view_order__$1 \x3d shadow.remote.runtime.obj_support.attempt_to_sort(coll);\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc_in,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),oid,new cljs.core.Keyword(null,\x22view-order\x22,\x22view-order\x22,566761574)], null),view_order__$1);\n\nreturn view_order__$1;\n}\n});\nshadow.remote.runtime.obj_support.obj_nav \x3d shadow.remote.runtime.obj_support.handler_with_object((function (p__28058,p__28059,p__28060){\nvar map__28062 \x3d p__28058;\nvar map__28062__$1 \x3d cljs.core.__destructure_map(map__28062);\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28062__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar map__28063 \x3d p__28059;\nvar map__28063__$1 \x3d cljs.core.__destructure_map(map__28063);\nvar entry \x3d map__28063__$1;\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28063__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\nvar map__28064 \x3d p__28060;\nvar map__28064__$1 \x3d cljs.core.__destructure_map(map__28064);\nvar msg \x3d map__28064__$1;\nvar idx \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28064__$1,new cljs.core.Keyword(null,\x22idx\x22,\x22idx\x22,1053688473));\nif(((cljs.core.vector_QMARK_(data)) || (cljs.core.list_QMARK_(data)))){\nvar val \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(data,idx);\nvar nav \x3d clojure.datafy.nav(data,idx,val);\nreturn shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$2(nav,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22nav?\x22,\x22nav?\x22,1269039770),cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(val,nav)], null));\n} else {\nif(cljs.core.map_QMARK_(data)){\nvar view_order \x3d shadow.remote.runtime.obj_support.cache_view_order(state_ref,entry,cljs.core.keys(data));\nvar key \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(view_order,idx);\nvar val \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(data,key);\nvar nav \x3d clojure.datafy.nav(data,key,val);\nreturn shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$2(nav,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22nav?\x22,\x22nav?\x22,1269039770),cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(val,nav)], null));\n} else {\nif(cljs.core.set_QMARK_(data)){\nvar view_order \x3d shadow.remote.runtime.obj_support.cache_view_order(state_ref,entry,data);\nvar val \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(view_order,idx);\nvar nav \x3d clojure.datafy.nav(data,idx,val);\nreturn shadow.remote.runtime.obj_support.obj_ref.cljs$core$IFn$_invoke$arity$2(nav,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22nav?\x22,\x22nav?\x22,1269039770),cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(val,nav)], null));\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22nav not supported?\x22,entry);\n\n}\n}\n}\n}));\nshadow.remote.runtime.obj_support.obj_fragment \x3d shadow.remote.runtime.obj_support.handler_with_object((function (p__28068,p__28069,p__28070){\nvar map__28071 \x3d p__28068;\nvar map__28071__$1 \x3d cljs.core.__destructure_map(map__28071);\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28071__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar map__28072 \x3d p__28069;\nvar map__28072__$1 \x3d cljs.core.__destructure_map(map__28072);\nvar entry \x3d map__28072__$1;\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28072__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\nvar map__28073 \x3d p__28070;\nvar map__28073__$1 \x3d cljs.core.__destructure_map(map__28073);\nvar msg \x3d map__28073__$1;\nvar start \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28073__$1,new cljs.core.Keyword(null,\x22start\x22,\x22start\x22,-355208981));\nvar num \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28073__$1,new cljs.core.Keyword(null,\x22num\x22,\x22num\x22,1985240673));\nvar val_limit \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__28073__$1,new cljs.core.Keyword(null,\x22val-limit\x22,\x22val-limit\x22,1428666181),(100));\nif(cljs.core.map_QMARK_(data)){\nvar map__28075 \x3d msg;\nvar map__28075__$1 \x3d cljs.core.__destructure_map(map__28075);\nvar key_limit \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__28075__$1,new cljs.core.Keyword(null,\x22key-limit\x22,\x22key-limit\x22,259239169),(100));\nvar view_order \x3d shadow.remote.runtime.obj_support.cache_view_order(state_ref,entry,cljs.core.keys(data));\nvar end \x3d (function (){var x__5090__auto__ \x3d cljs.core.count(view_order);\nvar y__5091__auto__ \x3d (start + num);\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})();\nvar idxs \x3d cljs.core.range.cljs$core$IFn$_invoke$arity$2(start,end);\nvar fragment \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,idx){\nvar key \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(view_order,idx);\nvar val \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(data,key);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,idx,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22key\x22,\x22key\x22,-1516042587),(function (){try{return shadow.remote.runtime.writer.pr_str_limit(key,key_limit);\n}catch (e28077){var e \x3d e28077;\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [true,\x22... print failed ...\x22], null);\n}})(),new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),(function (){try{return shadow.remote.runtime.writer.pr_str_limit(val,val_limit);\n}catch (e28081){var e \x3d e28081;\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [true,\x22... print failed ...\x22], null);\n}})()], null));\n}),cljs.core.PersistentArrayMap.EMPTY,idxs);\nreturn fragment;\n} else {\nif(cljs.core.vector_QMARK_(data)){\nvar end \x3d (function (){var x__5090__auto__ \x3d cljs.core.count(data);\nvar y__5091__auto__ \x3d (start + num);\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})();\nvar idxs \x3d cljs.core.range.cljs$core$IFn$_invoke$arity$2(start,end);\nvar fragment \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,idx){\nvar val \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(data,idx);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,idx,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),shadow.remote.runtime.writer.pr_str_limit(val,val_limit)], null));\n}),cljs.core.PersistentArrayMap.EMPTY,idxs);\nreturn fragment;\n} else {\nif(cljs.core.list_QMARK_(data)){\nvar end \x3d (function (){var x__5090__auto__ \x3d cljs.core.count(data);\nvar y__5091__auto__ \x3d (start + num);\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})();\nvar idxs \x3d cljs.core.range.cljs$core$IFn$_invoke$arity$2(start,end);\nvar fragment \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,idx){\nvar val \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(data,idx);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,idx,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),shadow.remote.runtime.writer.pr_str_limit(val,val_limit)], null));\n}),cljs.core.PersistentArrayMap.EMPTY,idxs);\nreturn fragment;\n} else {\nif(cljs.core.set_QMARK_(data)){\nvar view_order \x3d shadow.remote.runtime.obj_support.cache_view_order(state_ref,entry,data);\nvar end \x3d (function (){var x__5090__auto__ \x3d cljs.core.count(view_order);\nvar y__5091__auto__ \x3d (start + num);\nreturn ((x__5090__auto__ \x3c y__5091__auto__) ? x__5090__auto__ : y__5091__auto__);\n})();\nvar idxs \x3d cljs.core.range.cljs$core$IFn$_invoke$arity$2(start,end);\nvar fragment \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,idx){\nvar val \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$2(view_order,idx);\nreturn cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,idx,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22val\x22,\x22val\x22,128701612),shadow.remote.runtime.writer.pr_str_limit(val,val_limit)], null));\n}),cljs.core.PersistentArrayMap.EMPTY,idxs);\nreturn fragment;\n} else {\nreturn null;\n}\n}\n}\n}\n}));\nshadow.remote.runtime.obj_support.obj_request \x3d (function shadow$remote$runtime$obj_support$obj_request(this$,p__28091){\nvar map__28092 \x3d p__28091;\nvar map__28092__$1 \x3d cljs.core.__destructure_map(map__28092);\nvar msg \x3d map__28092__$1;\nvar request_op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28092__$1,new cljs.core.Keyword(null,\x22request-op\x22,\x22request-op\x22,1472997246));\nvar real_handler \x3d (function (){var G__28097 \x3d request_op;\nvar G__28097__$1 \x3d (((G__28097 instanceof cljs.core.Keyword))?G__28097.fqn:null);\nswitch (G__28097__$1) {\ncase \x22str\x22:\nreturn shadow.remote.runtime.obj_support.obj_str;\n\nbreak;\ncase \x22ex-str\x22:\nreturn shadow.remote.runtime.obj_support.obj_ex_str;\n\nbreak;\ncase \x22edn\x22:\nreturn shadow.remote.runtime.obj_support.obj_edn;\n\nbreak;\ncase \x22edn-limit\x22:\nreturn shadow.remote.runtime.obj_support.obj_edn;\n\nbreak;\ncase \x22pprint\x22:\nreturn this$;\n\nbreak;\ncase \x22nav\x22:\nreturn this$;\n\nbreak;\ncase \x22fragment\x22:\nreturn shadow.remote.runtime.obj_support.obj_fragment;\n\nbreak;\ndefault:\nthrow (new Error([\x22No matching clause: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__28097__$1)].join(\x27\x27)));\n\n}\n})();\nreturn (real_handler.cljs$core$IFn$_invoke$arity$2 ? real_handler.cljs$core$IFn$_invoke$arity$2(this$,msg) : real_handler.call(null, this$,msg));\n});\nshadow.remote.runtime.obj_support.obj_describe \x3d (function shadow$remote$runtime$obj_support$obj_describe(p__28120,p__28121){\nvar map__28122 \x3d p__28120;\nvar map__28122__$1 \x3d cljs.core.__destructure_map(map__28122);\nvar this$ \x3d map__28122__$1;\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28122__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar map__28123 \x3d p__28121;\nvar map__28123__$1 \x3d cljs.core.__destructure_map(map__28123);\nvar msg \x3d map__28123__$1;\nvar oid \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28123__$1,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334));\nvar temp__5802__auto__ \x3d shadow.remote.runtime.obj_support.obj_describe_STAR_(this$,oid);\nif(cljs.core.truth_(temp__5802__auto__)){\nvar summary \x3d temp__5802__auto__;\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22obj-summary\x22,\x22obj-summary\x22,-1372191064),new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid,new cljs.core.Keyword(null,\x22summary\x22,\x22summary\x22,380847952),summary], null));\n} else {\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22obj-not-found\x22,\x22obj-not-found\x22,1577257696),new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid], null));\n}\n});\nshadow.remote.runtime.obj_support.obj_forget \x3d (function shadow$remote$runtime$obj_support$obj_forget(p__28127,p__28128){\nvar map__28129 \x3d p__28127;\nvar map__28129__$1 \x3d cljs.core.__destructure_map(map__28129);\nvar svc \x3d map__28129__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28129__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar map__28130 \x3d p__28128;\nvar map__28130__$1 \x3d cljs.core.__destructure_map(map__28130);\nvar msg \x3d map__28130__$1;\nvar oid \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28130__$1,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(state_ref,cljs.core.update,new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),cljs.core.dissoc,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([oid], 0));\n});\nshadow.remote.runtime.obj_support.obj_forget_all \x3d (function shadow$remote$runtime$obj_support$obj_forget_all(p__28134,msg){\nvar map__28135 \x3d p__28134;\nvar map__28135__$1 \x3d cljs.core.__destructure_map(map__28135);\nvar svc \x3d map__28135__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28135__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc,new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),cljs.core.PersistentArrayMap.EMPTY);\n});\nshadow.remote.runtime.obj_support.basic_gc_BANG_ \x3d (function shadow$remote$runtime$obj_support$basic_gc_BANG_(state){\nvar objs_to_drop \x3d cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),cljs.core.drop.cljs$core$IFn$_invoke$arity$2((100),cljs.core.reverse(cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22access-at\x22,\x22access-at\x22,-1487162729),cljs.core.vals(new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734).cljs$core$IFn$_invoke$arity$1(state))))));\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (state__$1,oid){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(state__$1,new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),cljs.core.dissoc,oid);\n}),state,objs_to_drop);\n});\nshadow.remote.runtime.obj_support.add_inspector \x3d (function shadow$remote$runtime$obj_support$add_inspector(p__28157,inspect_fn){\nvar map__28160 \x3d p__28157;\nvar map__28160__$1 \x3d cljs.core.__destructure_map(map__28160);\nvar this$ \x3d map__28160__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28160__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nif(cljs.core.fn_QMARK_(inspect_fn)){\n} else {\nthrow (new Error(\x22Assert failed: (fn? inspect-fn)\x22));\n}\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(state_ref,cljs.core.update,new cljs.core.Keyword(null,\x22inspectors\x22,\x22inspectors\x22,-426448246),cljs.core.conj,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([inspect_fn], 0));\n\nreturn this$;\n});\nshadow.remote.runtime.obj_support.start \x3d (function shadow$remote$runtime$obj_support$start(runtime){\nvar state_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(null,\x22inspectors\x22,\x22inspectors\x22,-426448246),cljs.core.PersistentHashSet.EMPTY,new cljs.core.Keyword(null,\x22id-seq-ref\x22,\x22id-seq-ref\x22,-98357047),(0)], null));\nvar svc \x3d shadow.remote.runtime.obj_support.add_inspector(shadow.remote.runtime.obj_support.add_inspector(shadow.remote.runtime.obj_support.add_inspector(shadow.remote.runtime.obj_support.add_inspector(shadow.remote.runtime.obj_support.add_inspector(shadow.remote.runtime.obj_support.add_inspector(shadow.remote.runtime.obj_support.add_inspector(shadow.remote.runtime.obj_support.add_inspector(new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),runtime,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952),state_ref], null),(function (summary,p__28192){\nvar map__28193 \x3d p__28192;\nvar map__28193__$1 \x3d cljs.core.__destructure_map(map__28193);\nvar entry \x3d map__28193__$1;\nvar obj \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28193__$1,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962));\nif((!(shadow.remote.runtime.obj_support.simple_value_QMARK_(obj)))){\nreturn summary;\n} else {\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-get-value\x22,\x22obj-get-value\x22,281897170));\n}\n})),(function (summary,entry){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-str\x22,\x22obj-str\x22,1815115325));\n})),(function (summary,p__28210){\nvar map__28213 \x3d p__28210;\nvar map__28213__$1 \x3d cljs.core.__destructure_map(map__28213);\nvar entry \x3d map__28213__$1;\nvar obj \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28213__$1,new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962));\nif(shadow.remote.runtime.obj_support.exception_QMARK_(obj)){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-ex-str\x22,\x22obj-ex-str\x22,-639656467));\n} else {\nreturn summary;\n}\n})),(function (summary,entry){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-edn\x22,\x22obj-edn\x22,809365133));\n})),(function (summary,entry){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-edn-limit\x22,\x22obj-edn-limit\x22,-1550136004));\n})),(function (summary,p__28237){\nvar map__28242 \x3d p__28237;\nvar map__28242__$1 \x3d cljs.core.__destructure_map(map__28242);\nvar entry \x3d map__28242__$1;\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28242__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\nif(((cljs.core.coll_QMARK_(data)) || (cljs.core.seq_QMARK_(data)))){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-pprint\x22,\x22obj-pprint\x22,-1831226802));\n} else {\nreturn summary;\n}\n})),(function (summary,p__28251){\nvar map__28252 \x3d p__28251;\nvar map__28252__$1 \x3d cljs.core.__destructure_map(map__28252);\nvar entry \x3d map__28252__$1;\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28252__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\nif(((((cljs.core.map_QMARK_(data)) || (((cljs.core.vector_QMARK_(data)) || (((cljs.core.set_QMARK_(data)) || (cljs.core.list_QMARK_(data)))))))) \x26\x26 (cljs.core.seq(data)))){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-nav\x22,\x22obj-nav\x22,1248750622));\n} else {\nreturn summary;\n}\n})),(function (summary,p__28280){\nvar map__28281 \x3d p__28280;\nvar map__28281__$1 \x3d cljs.core.__destructure_map(map__28281);\nvar entry \x3d map__28281__$1;\nvar data \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28281__$1,new cljs.core.Keyword(null,\x22data\x22,\x22data\x22,-232669377));\nif(((((cljs.core.map_QMARK_(data)) || (((cljs.core.vector_QMARK_(data)) || (((cljs.core.set_QMARK_(data)) || (cljs.core.list_QMARK_(data)))))))) \x26\x26 (cljs.core.seq(data)))){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(summary,new cljs.core.Keyword(null,\x22supports\x22,\x22supports\x22,1501242067),cljs.core.conj,new cljs.core.Keyword(null,\x22obj-fragment\x22,\x22obj-fragment\x22,1857463161));\n} else {\nreturn summary;\n}\n}));\nshadow.remote.runtime.api.add_extension(runtime,new cljs.core.Keyword(\x22shadow.remote.runtime.obj-support\x22,\x22ext\x22,\x22shadow.remote.runtime.obj-support/ext\x22,-1896569346),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),cljs.core.PersistentHashMap.fromArrays([new cljs.core.Keyword(null,\x22obj-forget\x22,\x22obj-forget\x22,2003566115),new cljs.core.Keyword(null,\x22obj-describe\x22,\x22obj-describe\x22,-34922904),new cljs.core.Keyword(null,\x22obj-ex-str\x22,\x22obj-ex-str\x22,-639656467),new cljs.core.Keyword(null,\x22obj-request\x22,\x22obj-request\x22,-1709325811),new cljs.core.Keyword(null,\x22obj-edn\x22,\x22obj-edn\x22,809365133),new cljs.core.Keyword(null,\x22obj-pprint\x22,\x22obj-pprint\x22,-1831226802),new cljs.core.Keyword(null,\x22obj-get-value\x22,\x22obj-get-value\x22,281897170),new cljs.core.Keyword(null,\x22obj-forget-all\x22,\x22obj-forget-all\x22,1418682131),new cljs.core.Keyword(null,\x22obj-fragment\x22,\x22obj-fragment\x22,1857463161),new cljs.core.Keyword(null,\x22obj-edn-limit\x22,\x22obj-edn-limit\x22,-1550136004),new cljs.core.Keyword(null,\x22obj-str\x22,\x22obj-str\x22,1815115325),new cljs.core.Keyword(null,\x22obj-nav\x22,\x22obj-nav\x22,1248750622)],[(function (p1__28189_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_forget(svc,p1__28189_SHARP_);\n}),(function (p1__28178_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_describe(svc,p1__28178_SHARP_);\n}),(function (p1__28185_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_ex_str(svc,p1__28185_SHARP_);\n}),(function (p1__28180_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_request(svc,p1__28180_SHARP_);\n}),(function (p1__28181_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_edn(svc,p1__28181_SHARP_);\n}),(function (p1__28186_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_pprint(svc,p1__28186_SHARP_);\n}),(function (p1__28182_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_get_value(svc,p1__28182_SHARP_);\n}),(function (p1__28190_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_forget_all(svc,p1__28190_SHARP_);\n}),(function (p1__28188_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_fragment(svc,p1__28188_SHARP_);\n}),(function (p1__28183_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_edn_limit(svc,p1__28183_SHARP_);\n}),(function (p1__28184_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_str(svc,p1__28184_SHARP_);\n}),(function (p1__28187_SHARP_){\nreturn shadow.remote.runtime.obj_support.obj_nav(svc,p1__28187_SHARP_);\n})]),new cljs.core.Keyword(null,\x22on-idle\x22,\x22on-idle\x22,2044706602),(function (){\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(state_ref,shadow.remote.runtime.obj_support.basic_gc_BANG_);\n})], null));\n\nreturn svc;\n});\nshadow.remote.runtime.obj_support.get_tap_history \x3d (function shadow$remote$runtime$obj_support$get_tap_history(p__28328,num){\nvar map__28331 \x3d p__28328;\nvar map__28331__$1 \x3d cljs.core.__destructure_map(map__28331);\nvar svc \x3d map__28331__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28331__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),cljs.core.take.cljs$core$IFn$_invoke$arity$2(num,cljs.core.reverse(cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22added-at\x22,\x22added-at\x22,-352499434),cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__28316_SHARP_){\nreturn cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22tap\x22,\x22tap\x22,-1086702463),cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(p1__28316_SHARP_,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22obj-info\x22,\x22obj-info\x22,-373842651),new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044)], null)));\n}),cljs.core.vals(new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref)))))))));\n});\nshadow.remote.runtime.obj_support.register \x3d (function shadow$remote$runtime$obj_support$register(p__28351,obj,obj_info){\nvar map__28356 \x3d p__28351;\nvar map__28356__$1 \x3d cljs.core.__destructure_map(map__28356);\nvar svc \x3d map__28356__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28356__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar oid \x3d shadow.remote.runtime.obj_support.next_oid();\nif((!(((cljs.core.vector_QMARK_(obj)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(\x22shadow.remote\x22,\x22wrap\x22,\x22shadow.remote/wrap\x22,996267199),cljs.core.first(obj))) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(obj),(3))))))))){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(state_ref,shadow.remote.runtime.obj_support.register_STAR_,oid,obj,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([obj_info], 0));\n} else {\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(state_ref,shadow.remote.runtime.obj_support.register_STAR_,oid,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(obj,(1)),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([obj_info,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(obj,(2))], 0))], 0));\n}\n\nreturn oid;\n});\nshadow.remote.runtime.obj_support.get_ref \x3d (function shadow$remote$runtime$obj_support$get_ref(p__28374,obj_id){\nvar map__28375 \x3d p__28374;\nvar map__28375__$1 \x3d cljs.core.__destructure_map(map__28375);\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28375__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nreturn cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(state_ref),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22objects\x22,\x22objects\x22,2099713734),obj_id], null));\n});\nshadow.remote.runtime.obj_support.stop \x3d (function shadow$remote$runtime$obj_support$stop(p__28376){\nvar map__28377 \x3d p__28376;\nvar map__28377__$1 \x3d cljs.core.__destructure_map(map__28377);\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28377__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nreturn shadow.remote.runtime.api.del_extension(runtime,new cljs.core.Keyword(\x22shadow.remote.runtime.obj-support\x22,\x22ext\x22,\x22shadow.remote.runtime.obj-support/ext\x22,-1896569346));\n});\n");
SHADOW_ENV.evalLoad("shadow.remote.runtime.tap_support.js", true, "goog.provide(\x27shadow.remote.runtime.tap_support\x27);\nshadow.remote.runtime.tap_support.tap_subscribe \x3d (function shadow$remote$runtime$tap_support$tap_subscribe(p__28415,p__28416){\nvar map__28418 \x3d p__28415;\nvar map__28418__$1 \x3d cljs.core.__destructure_map(map__28418);\nvar svc \x3d map__28418__$1;\nvar subs_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28418__$1,new cljs.core.Keyword(null,\x22subs-ref\x22,\x22subs-ref\x22,-1355989911));\nvar obj_support \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28418__$1,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229));\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28418__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar map__28419 \x3d p__28416;\nvar map__28419__$1 \x3d cljs.core.__destructure_map(map__28419);\nvar msg \x3d map__28419__$1;\nvar from \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28419__$1,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044));\nvar summary \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28419__$1,new cljs.core.Keyword(null,\x22summary\x22,\x22summary\x22,380847952));\nvar history__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28419__$1,new cljs.core.Keyword(null,\x22history\x22,\x22history\x22,-247395220));\nvar num \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__28419__$1,new cljs.core.Keyword(null,\x22num\x22,\x22num\x22,1985240673),(10));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(subs_ref,cljs.core.assoc,from,msg);\n\nif(cljs.core.truth_(history__$1)){\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22tap-subscribed\x22,\x22tap-subscribed\x22,-1882247432),new cljs.core.Keyword(null,\x22history\x22,\x22history\x22,-247395220),cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (oid){\nreturn new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid,new cljs.core.Keyword(null,\x22summary\x22,\x22summary\x22,380847952),shadow.remote.runtime.obj_support.obj_describe_STAR_(obj_support,oid)], null);\n}),shadow.remote.runtime.obj_support.get_tap_history(obj_support,num)))], null));\n} else {\nreturn null;\n}\n});\nshadow.remote.runtime.tap_support.tap_unsubscribe \x3d (function shadow$remote$runtime$tap_support$tap_unsubscribe(p__28430,p__28431){\nvar map__28433 \x3d p__28430;\nvar map__28433__$1 \x3d cljs.core.__destructure_map(map__28433);\nvar subs_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28433__$1,new cljs.core.Keyword(null,\x22subs-ref\x22,\x22subs-ref\x22,-1355989911));\nvar map__28434 \x3d p__28431;\nvar map__28434__$1 \x3d cljs.core.__destructure_map(map__28434);\nvar from \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28434__$1,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(subs_ref,cljs.core.dissoc,from);\n});\nshadow.remote.runtime.tap_support.request_tap_history \x3d (function shadow$remote$runtime$tap_support$request_tap_history(p__28445,p__28446){\nvar map__28447 \x3d p__28445;\nvar map__28447__$1 \x3d cljs.core.__destructure_map(map__28447);\nvar obj_support \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28447__$1,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229));\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28447__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar map__28448 \x3d p__28446;\nvar map__28448__$1 \x3d cljs.core.__destructure_map(map__28448);\nvar msg \x3d map__28448__$1;\nvar num \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__28448__$1,new cljs.core.Keyword(null,\x22num\x22,\x22num\x22,1985240673),(10));\nvar tap_ids \x3d shadow.remote.runtime.obj_support.get_tap_history(obj_support,num);\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22tap-history\x22,\x22tap-history\x22,-282803347),new cljs.core.Keyword(null,\x22oids\x22,\x22oids\x22,-1580877688),tap_ids], null));\n});\nshadow.remote.runtime.tap_support.tool_disconnect \x3d (function shadow$remote$runtime$tap_support$tool_disconnect(p__28452,tid){\nvar map__28453 \x3d p__28452;\nvar map__28453__$1 \x3d cljs.core.__destructure_map(map__28453);\nvar svc \x3d map__28453__$1;\nvar subs_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28453__$1,new cljs.core.Keyword(null,\x22subs-ref\x22,\x22subs-ref\x22,-1355989911));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(subs_ref,cljs.core.dissoc,tid);\n});\nshadow.remote.runtime.tap_support.start \x3d (function shadow$remote$runtime$tap_support$start(runtime,obj_support){\nvar subs_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\nvar tap_fn \x3d (function shadow$remote$runtime$tap_support$start_$_runtime_tap(obj){\nif((!((obj \x3d\x3d null)))){\nvar oid \x3d shadow.remote.runtime.obj_support.register(obj_support,obj,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),new cljs.core.Keyword(null,\x22tap\x22,\x22tap\x22,-1086702463)], null));\nvar seq__28469 \x3d cljs.core.seq(cljs.core.deref(subs_ref));\nvar chunk__28470 \x3d null;\nvar count__28471 \x3d (0);\nvar i__28472 \x3d (0);\nwhile(true){\nif((i__28472 \x3c count__28471)){\nvar vec__28485 \x3d chunk__28470.cljs$core$IIndexed$_nth$arity$2(null, i__28472);\nvar tid \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28485,(0),null);\nvar tap_config \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28485,(1),null);\nshadow.remote.runtime.api.relay_msg(runtime,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22tap\x22,\x22tap\x22,-1086702463),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),tid,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid], null));\n\n\nvar G__28503 \x3d seq__28469;\nvar G__28504 \x3d chunk__28470;\nvar G__28505 \x3d count__28471;\nvar G__28506 \x3d (i__28472 + (1));\nseq__28469 \x3d G__28503;\nchunk__28470 \x3d G__28504;\ncount__28471 \x3d G__28505;\ni__28472 \x3d G__28506;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__28469);\nif(temp__5804__auto__){\nvar seq__28469__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__28469__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__28469__$1);\nvar G__28507 \x3d cljs.core.chunk_rest(seq__28469__$1);\nvar G__28508 \x3d c__5525__auto__;\nvar G__28509 \x3d cljs.core.count(c__5525__auto__);\nvar G__28510 \x3d (0);\nseq__28469 \x3d G__28507;\nchunk__28470 \x3d G__28508;\ncount__28471 \x3d G__28509;\ni__28472 \x3d G__28510;\ncontinue;\n} else {\nvar vec__28489 \x3d cljs.core.first(seq__28469__$1);\nvar tid \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28489,(0),null);\nvar tap_config \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28489,(1),null);\nshadow.remote.runtime.api.relay_msg(runtime,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22tap\x22,\x22tap\x22,-1086702463),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),tid,new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid], null));\n\n\nvar G__28511 \x3d cljs.core.next(seq__28469__$1);\nvar G__28512 \x3d null;\nvar G__28513 \x3d (0);\nvar G__28514 \x3d (0);\nseq__28469 \x3d G__28511;\nchunk__28470 \x3d G__28512;\ncount__28471 \x3d G__28513;\ni__28472 \x3d G__28514;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n} else {\nreturn null;\n}\n});\nvar svc \x3d new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),runtime,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229),obj_support,new cljs.core.Keyword(null,\x22tap-fn\x22,\x22tap-fn\x22,1573556461),tap_fn,new cljs.core.Keyword(null,\x22subs-ref\x22,\x22subs-ref\x22,-1355989911),subs_ref], null);\nshadow.remote.runtime.api.add_extension(runtime,new cljs.core.Keyword(\x22shadow.remote.runtime.tap-support\x22,\x22ext\x22,\x22shadow.remote.runtime.tap-support/ext\x22,1019069674),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22tap-subscribe\x22,\x22tap-subscribe\x22,411179050),(function (p1__28457_SHARP_){\nreturn shadow.remote.runtime.tap_support.tap_subscribe(svc,p1__28457_SHARP_);\n}),new cljs.core.Keyword(null,\x22tap-unsubscribe\x22,\x22tap-unsubscribe\x22,1183890755),(function (p1__28458_SHARP_){\nreturn shadow.remote.runtime.tap_support.tap_unsubscribe(svc,p1__28458_SHARP_);\n}),new cljs.core.Keyword(null,\x22request-tap-history\x22,\x22request-tap-history\x22,-670837812),(function (p1__28459_SHARP_){\nreturn shadow.remote.runtime.tap_support.request_tap_history(svc,p1__28459_SHARP_);\n})], null),new cljs.core.Keyword(null,\x22on-tool-disconnect\x22,\x22on-tool-disconnect\x22,693464366),(function (p1__28460_SHARP_){\nreturn shadow.remote.runtime.tap_support.tool_disconnect(svc,p1__28460_SHARP_);\n})], null));\n\ncljs.core.add_tap(tap_fn);\n\nreturn svc;\n});\nshadow.remote.runtime.tap_support.stop \x3d (function shadow$remote$runtime$tap_support$stop(p__28496){\nvar map__28497 \x3d p__28496;\nvar map__28497__$1 \x3d cljs.core.__destructure_map(map__28497);\nvar svc \x3d map__28497__$1;\nvar tap_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28497__$1,new cljs.core.Keyword(null,\x22tap-fn\x22,\x22tap-fn\x22,1573556461));\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28497__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\ncljs.core.remove_tap(tap_fn);\n\nreturn shadow.remote.runtime.api.del_extension(runtime,new cljs.core.Keyword(\x22shadow.remote.runtime.tap-support\x22,\x22ext\x22,\x22shadow.remote.runtime.tap-support/ext\x22,1019069674));\n});\n");
SHADOW_ENV.evalLoad("shadow.remote.runtime.eval_support.js", true, "goog.provide(\x27shadow.remote.runtime.eval_support\x27);\nshadow.remote.runtime.eval_support.obj_support_inst \x3d null;\nshadow.remote.runtime.eval_support.get_ref \x3d (function shadow$remote$runtime$eval_support$get_ref(oid){\nif(cljs.core.truth_(shadow.remote.runtime.eval_support.obj_support_inst)){\n} else {\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22obj-support not bound, can only call this from eval\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22oid\x22,\x22oid\x22,-768692334),oid], null));\n}\n\nreturn shadow.remote.runtime.obj_support.get_ref(shadow.remote.runtime.eval_support.obj_support_inst,oid);\n});\nshadow.remote.runtime.eval_support.cljs_eval \x3d (function shadow$remote$runtime$eval_support$cljs_eval(p__28423,p__28424){\nvar map__28425 \x3d p__28423;\nvar map__28425__$1 \x3d cljs.core.__destructure_map(map__28425);\nvar svc \x3d map__28425__$1;\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28425__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar obj_support \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28425__$1,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229));\nvar map__28426 \x3d p__28424;\nvar map__28426__$1 \x3d cljs.core.__destructure_map(map__28426);\nvar msg \x3d map__28426__$1;\nvar input \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28426__$1,new cljs.core.Keyword(null,\x22input\x22,\x22input\x22,556931961));\n(shadow.remote.runtime.eval_support.obj_support_inst \x3d obj_support);\n\nreturn shadow.remote.runtime.api.cljs_eval(runtime,input,(function (p__28427){\nvar map__28429 \x3d p__28427;\nvar map__28429__$1 \x3d cljs.core.__destructure_map(map__28429);\nvar info \x3d map__28429__$1;\nvar result \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28429__$1,new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211));\n(shadow.remote.runtime.eval_support.obj_support_inst \x3d null);\n\nvar G__28432 \x3d result;\nvar G__28432__$1 \x3d (((G__28432 instanceof cljs.core.Keyword))?G__28432.fqn:null);\nswitch (G__28432__$1) {\ncase \x22compile-error\x22:\nvar map__28441 \x3d info;\nvar map__28441__$1 \x3d cljs.core.__destructure_map(map__28441);\nvar ex_client_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28441__$1,new cljs.core.Keyword(null,\x22ex-client-id\x22,\x22ex-client-id\x22,-446123984));\nvar ex_oid \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28441__$1,new cljs.core.Keyword(null,\x22ex-oid\x22,\x22ex-oid\x22,-650256737));\nvar report \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28441__$1,new cljs.core.Keyword(null,\x22report\x22,\x22report\x22,1394055010));\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22eval-compile-error\x22,\x22eval-compile-error\x22,-1765075397),new cljs.core.Keyword(null,\x22ex-client-id\x22,\x22ex-client-id\x22,-446123984),ex_client_id,new cljs.core.Keyword(null,\x22ex-oid\x22,\x22ex-oid\x22,-650256737),ex_oid,new cljs.core.Keyword(null,\x22report\x22,\x22report\x22,1394055010),report], null));\n\nbreak;\ncase \x22runtime-error\x22:\nvar map__28444 \x3d info;\nvar map__28444__$1 \x3d cljs.core.__destructure_map(map__28444);\nvar ex \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28444__$1,new cljs.core.Keyword(null,\x22ex\x22,\x22ex\x22,-1413771341));\nvar ex_oid \x3d shadow.remote.runtime.obj_support.register(obj_support,ex,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),input], null));\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22eval-runtime-error\x22,\x22eval-runtime-error\x22,275935402),new cljs.core.Keyword(null,\x22ex-oid\x22,\x22ex-oid\x22,-650256737),ex_oid], null));\n\nbreak;\ncase \x22warnings\x22:\nvar map__28449 \x3d info;\nvar map__28449__$1 \x3d cljs.core.__destructure_map(map__28449);\nvar warnings \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28449__$1,new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651));\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22eval-compile-warnings\x22,\x22eval-compile-warnings\x22,1994859386),new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651),warnings], null));\n\nbreak;\ncase \x22ok\x22:\nvar map__28450 \x3d info;\nvar map__28450__$1 \x3d cljs.core.__destructure_map(map__28450);\nvar results \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28450__$1,new cljs.core.Keyword(null,\x22results\x22,\x22results\x22,-1134170113));\nvar warnings \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28450__$1,new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651));\nvar time_start \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28450__$1,new cljs.core.Keyword(null,\x22time-start\x22,\x22time-start\x22,-590811745));\nvar time_finish \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28450__$1,new cljs.core.Keyword(null,\x22time-finish\x22,\x22time-finish\x22,-1456032653));\nvar val \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((1),cljs.core.count(results)))?cljs.core.first(results):results);\nvar ref_oid \x3d shadow.remote.runtime.obj_support.register(obj_support,val,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),input], null));\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22eval-result-ref\x22,\x22eval-result-ref\x22,263827420),new cljs.core.Keyword(null,\x22ref-oid\x22,\x22ref-oid\x22,-526648644),ref_oid,new cljs.core.Keyword(null,\x22eval-ms\x22,\x22eval-ms\x22,788821074),(time_finish - time_start),new cljs.core.Keyword(null,\x22eval-ns\x22,\x22eval-ns\x22,-915623795),new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760).cljs$core$IFn$_invoke$arity$1(info),new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651),warnings], null));\n\nbreak;\ndefault:\nreturn console.error(\x22Unhandled cljs-eval result\x22,info);\n\n}\n}));\n});\nshadow.remote.runtime.eval_support.js_eval \x3d (function shadow$remote$runtime$eval_support$js_eval(p__28463,p__28464){\nvar map__28465 \x3d p__28463;\nvar map__28465__$1 \x3d cljs.core.__destructure_map(map__28465);\nvar svc \x3d map__28465__$1;\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28465__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar obj_support \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28465__$1,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229));\nvar map__28466 \x3d p__28464;\nvar map__28466__$1 \x3d cljs.core.__destructure_map(map__28466);\nvar msg \x3d map__28466__$1;\nvar code \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28466__$1,new cljs.core.Keyword(null,\x22code\x22,\x22code\x22,1586293142));\ntry{var res \x3d shadow.remote.runtime.api.js_eval(runtime,code);\nvar ref_oid \x3d shadow.remote.runtime.obj_support.register(obj_support,res,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22js-code\x22,\x22js-code\x22,1816578331),code], null));\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22eval-result-ref\x22,\x22eval-result-ref\x22,263827420),new cljs.core.Keyword(null,\x22ref-oid\x22,\x22ref-oid\x22,-526648644),ref_oid], null));\n}catch (e28467){var e \x3d e28467;\nreturn shadow.remote.runtime.shared.reply(runtime,msg,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22eval-error\x22,\x22eval-error\x22,466139568),new cljs.core.Keyword(null,\x22e\x22,\x22e\x22,1381269198),e.message], null));\n}});\nshadow.remote.runtime.eval_support.start \x3d (function shadow$remote$runtime$eval_support$start(runtime,obj_support){\nvar svc \x3d new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),runtime,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229),obj_support], null);\nshadow.remote.runtime.shared.add_extension(runtime,new cljs.core.Keyword(\x22shadow.remote.runtime.eval-support\x22,\x22ext\x22,\x22shadow.remote.runtime.eval-support/ext\x22,1781604625),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22js-eval\x22,\x22js-eval\x22,-137738892),(function (p1__28476_SHARP_){\nreturn shadow.remote.runtime.eval_support.js_eval(svc,p1__28476_SHARP_);\n}),new cljs.core.Keyword(null,\x22cljs-eval\x22,\x22cljs-eval\x22,1860675817),(function (p1__28477_SHARP_){\nreturn shadow.remote.runtime.eval_support.cljs_eval(svc,p1__28477_SHARP_);\n})], null)], null));\n\nreturn svc;\n});\nshadow.remote.runtime.eval_support.stop \x3d (function shadow$remote$runtime$eval_support$stop(p__28481){\nvar map__28483 \x3d p__28481;\nvar map__28483__$1 \x3d cljs.core.__destructure_map(map__28483);\nvar svc \x3d map__28483__$1;\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28483__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nreturn shadow.remote.runtime.api.del_extension(runtime,new cljs.core.Keyword(\x22shadow.remote.runtime.eval-support\x22,\x22ext\x22,\x22shadow.remote.runtime.eval-support/ext\x22,1781604625));\n});\n");
SHADOW_ENV.evalLoad("shadow.cljs.devtools.client.shared.js", true, "goog.provide(\x27shadow.cljs.devtools.client.shared\x27);\ngoog.scope(function(){\n  shadow.cljs.devtools.client.shared.goog$module$goog$object \x3d goog.module.get(\x27goog.object\x27);\n});\n\n/**\n * @interface\n */\nshadow.cljs.devtools.client.shared.IRemote \x3d function(){};\n\nvar shadow$cljs$devtools$client$shared$IRemote$remote_open$dyn_28828 \x3d (function (this$,e){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_open[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(this$,e) : m__5351__auto__.call(null, this$,e));\n} else {\nvar m__5349__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_open[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(this$,e) : m__5349__auto__.call(null, this$,e));\n} else {\nthrow cljs.core.missing_protocol(\x22IRemote.remote-open\x22,this$);\n}\n}\n});\nshadow.cljs.devtools.client.shared.remote_open \x3d (function shadow$cljs$devtools$client$shared$remote_open(this$,e){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$cljs$devtools$client$shared$IRemote$remote_open$arity$2 \x3d\x3d null)))))){\nreturn this$.shadow$cljs$devtools$client$shared$IRemote$remote_open$arity$2(this$,e);\n} else {\nreturn shadow$cljs$devtools$client$shared$IRemote$remote_open$dyn_28828(this$,e);\n}\n});\n\nvar shadow$cljs$devtools$client$shared$IRemote$remote_msg$dyn_28833 \x3d (function (this$,msg){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_msg[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(this$,msg) : m__5351__auto__.call(null, this$,msg));\n} else {\nvar m__5349__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_msg[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(this$,msg) : m__5349__auto__.call(null, this$,msg));\n} else {\nthrow cljs.core.missing_protocol(\x22IRemote.remote-msg\x22,this$);\n}\n}\n});\nshadow.cljs.devtools.client.shared.remote_msg \x3d (function shadow$cljs$devtools$client$shared$remote_msg(this$,msg){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$cljs$devtools$client$shared$IRemote$remote_msg$arity$2 \x3d\x3d null)))))){\nreturn this$.shadow$cljs$devtools$client$shared$IRemote$remote_msg$arity$2(this$,msg);\n} else {\nreturn shadow$cljs$devtools$client$shared$IRemote$remote_msg$dyn_28833(this$,msg);\n}\n});\n\nvar shadow$cljs$devtools$client$shared$IRemote$remote_close$dyn_28837 \x3d (function (this$,e,info){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_close[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(this$,e,info) : m__5351__auto__.call(null, this$,e,info));\n} else {\nvar m__5349__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_close[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(this$,e,info) : m__5349__auto__.call(null, this$,e,info));\n} else {\nthrow cljs.core.missing_protocol(\x22IRemote.remote-close\x22,this$);\n}\n}\n});\nshadow.cljs.devtools.client.shared.remote_close \x3d (function shadow$cljs$devtools$client$shared$remote_close(this$,e,info){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$cljs$devtools$client$shared$IRemote$remote_close$arity$3 \x3d\x3d null)))))){\nreturn this$.shadow$cljs$devtools$client$shared$IRemote$remote_close$arity$3(this$,e,info);\n} else {\nreturn shadow$cljs$devtools$client$shared$IRemote$remote_close$dyn_28837(this$,e,info);\n}\n});\n\nvar shadow$cljs$devtools$client$shared$IRemote$remote_error$dyn_28838 \x3d (function (this$,e){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_error[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(this$,e) : m__5351__auto__.call(null, this$,e));\n} else {\nvar m__5349__auto__ \x3d (shadow.cljs.devtools.client.shared.remote_error[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(this$,e) : m__5349__auto__.call(null, this$,e));\n} else {\nthrow cljs.core.missing_protocol(\x22IRemote.remote-error\x22,this$);\n}\n}\n});\nshadow.cljs.devtools.client.shared.remote_error \x3d (function shadow$cljs$devtools$client$shared$remote_error(this$,e){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$cljs$devtools$client$shared$IRemote$remote_error$arity$2 \x3d\x3d null)))))){\nreturn this$.shadow$cljs$devtools$client$shared$IRemote$remote_error$arity$2(this$,e);\n} else {\nreturn shadow$cljs$devtools$client$shared$IRemote$remote_error$dyn_28838(this$,e);\n}\n});\n\n\n/**\n * @interface\n */\nshadow.cljs.devtools.client.shared.IHostSpecific \x3d function(){};\n\nvar shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_init$dyn_28839 \x3d (function (this$,action,done,error){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.cljs.devtools.client.shared.do_repl_init[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$4(this$,action,done,error) : m__5351__auto__.call(null, this$,action,done,error));\n} else {\nvar m__5349__auto__ \x3d (shadow.cljs.devtools.client.shared.do_repl_init[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$4(this$,action,done,error) : m__5349__auto__.call(null, this$,action,done,error));\n} else {\nthrow cljs.core.missing_protocol(\x22IHostSpecific.do-repl-init\x22,this$);\n}\n}\n});\nshadow.cljs.devtools.client.shared.do_repl_init \x3d (function shadow$cljs$devtools$client$shared$do_repl_init(this$,action,done,error){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_init$arity$4 \x3d\x3d null)))))){\nreturn this$.shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_init$arity$4(this$,action,done,error);\n} else {\nreturn shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_init$dyn_28839(this$,action,done,error);\n}\n});\n\nvar shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_require$dyn_28840 \x3d (function (this$,require_msg,done,error){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.cljs.devtools.client.shared.do_repl_require[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$4(this$,require_msg,done,error) : m__5351__auto__.call(null, this$,require_msg,done,error));\n} else {\nvar m__5349__auto__ \x3d (shadow.cljs.devtools.client.shared.do_repl_require[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$4 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$4(this$,require_msg,done,error) : m__5349__auto__.call(null, this$,require_msg,done,error));\n} else {\nthrow cljs.core.missing_protocol(\x22IHostSpecific.do-repl-require\x22,this$);\n}\n}\n});\nshadow.cljs.devtools.client.shared.do_repl_require \x3d (function shadow$cljs$devtools$client$shared$do_repl_require(this$,require_msg,done,error){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_require$arity$4 \x3d\x3d null)))))){\nreturn this$.shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_require$arity$4(this$,require_msg,done,error);\n} else {\nreturn shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_require$dyn_28840(this$,require_msg,done,error);\n}\n});\n\nvar shadow$cljs$devtools$client$shared$IHostSpecific$do_invoke$dyn_28845 \x3d (function (this$,ns,invoke_msg){\nvar x__5350__auto__ \x3d (((this$ \x3d\x3d null))?null:this$);\nvar m__5351__auto__ \x3d (shadow.cljs.devtools.client.shared.do_invoke[goog.typeOf(x__5350__auto__)]);\nif((!((m__5351__auto__ \x3d\x3d null)))){\nreturn (m__5351__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$3(this$,ns,invoke_msg) : m__5351__auto__.call(null, this$,ns,invoke_msg));\n} else {\nvar m__5349__auto__ \x3d (shadow.cljs.devtools.client.shared.do_invoke[\x22_\x22]);\nif((!((m__5349__auto__ \x3d\x3d null)))){\nreturn (m__5349__auto__.cljs$core$IFn$_invoke$arity$3 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$3(this$,ns,invoke_msg) : m__5349__auto__.call(null, this$,ns,invoke_msg));\n} else {\nthrow cljs.core.missing_protocol(\x22IHostSpecific.do-invoke\x22,this$);\n}\n}\n});\nshadow.cljs.devtools.client.shared.do_invoke \x3d (function shadow$cljs$devtools$client$shared$do_invoke(this$,ns,invoke_msg){\nif((((!((this$ \x3d\x3d null)))) \x26\x26 ((!((this$.shadow$cljs$devtools$client$shared$IHostSpecific$do_invoke$arity$3 \x3d\x3d null)))))){\nreturn this$.shadow$cljs$devtools$client$shared$IHostSpecific$do_invoke$arity$3(this$,ns,invoke_msg);\n} else {\nreturn shadow$cljs$devtools$client$shared$IHostSpecific$do_invoke$dyn_28845(this$,ns,invoke_msg);\n}\n});\n\nshadow.cljs.devtools.client.shared.load_sources \x3d (function shadow$cljs$devtools$client$shared$load_sources(runtime,sources,callback){\nreturn shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$3(runtime,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22cljs-load-sources\x22,\x22cljs-load-sources\x22,-1458295962),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),shadow.cljs.devtools.client.env.worker_client_id,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424),cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22resource-id\x22,\x22resource-id\x22,-1308422582)),sources)], null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22cljs-sources\x22,\x22cljs-sources\x22,31121610),(function (p__28593){\nvar map__28594 \x3d p__28593;\nvar map__28594__$1 \x3d cljs.core.__destructure_map(map__28594);\nvar msg \x3d map__28594__$1;\nvar sources__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28594__$1,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424));\nreturn (callback.cljs$core$IFn$_invoke$arity$1 ? callback.cljs$core$IFn$_invoke$arity$1(sources__$1) : callback.call(null, sources__$1));\n})], null));\n});\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.shared !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.shared.runtime_ref !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.shared.runtime_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(null);\n}\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.shared !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.shared.plugins_ref !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.shared.plugins_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY);\n}\nshadow.cljs.devtools.client.shared.start_all_plugins_BANG_ \x3d (function shadow$cljs$devtools$client$shared$start_all_plugins_BANG_(p__28601){\nvar map__28602 \x3d p__28601;\nvar map__28602__$1 \x3d cljs.core.__destructure_map(map__28602);\nvar runtime \x3d map__28602__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28602__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar started_set \x3d cljs.core.set(cljs.core.keys(new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref))));\nvar plugins \x3d cljs.core.deref(shadow.cljs.devtools.client.shared.plugins_ref);\nvar plugins_set \x3d cljs.core.set(cljs.core.keys(plugins));\nvar pending_set \x3d clojure.set.difference.cljs$core$IFn$_invoke$arity$2(plugins_set,started_set);\nvar pending_set__$1 \x3d pending_set;\nwhile(true){\nif(cljs.core.empty_QMARK_(pending_set__$1)){\nreturn new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22done!\x22,\x22shadow.cljs.devtools.client.shared/done!\x22,-748632664);\n} else {\nvar G__28857 \x3d cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (pending_set__$1,started_set,plugins,plugins_set,pending_set,map__28602,map__28602__$1,runtime,state_ref){\nreturn (function (pending_set__$2,plugin_id){\nvar map__28607 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(plugins,plugin_id);\nvar map__28607__$1 \x3d cljs.core.__destructure_map(map__28607);\nvar plugin \x3d map__28607__$1;\nvar depends_on \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28607__$1,new cljs.core.Keyword(null,\x22depends-on\x22,\x22depends-on\x22,-1448442022));\nvar init_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28607__$1,new cljs.core.Keyword(null,\x22init-fn\x22,\x22init-fn\x22,777257971));\nif(cljs.core.truth_(cljs.core.some(pending_set__$2,depends_on))){\nreturn pending_set__$2;\n} else {\nvar start_arg \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.select_keys(new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(state_ref)),depends_on),new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),runtime);\nvar started \x3d (init_fn.cljs$core$IFn$_invoke$arity$1 ? init_fn.cljs$core$IFn$_invoke$arity$1(start_arg) : init_fn.call(null, start_arg));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc_in,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855),plugin_id], null),started);\n\nreturn cljs.core.disj.cljs$core$IFn$_invoke$arity$2(pending_set__$2,plugin_id);\n}\n});})(pending_set__$1,started_set,plugins,plugins_set,pending_set,map__28602,map__28602__$1,runtime,state_ref))\n,pending_set__$1,pending_set__$1);\npending_set__$1 \x3d G__28857;\ncontinue;\n\n}\nbreak;\n}\n});\nshadow.cljs.devtools.client.shared.add_plugin_BANG_ \x3d (function shadow$cljs$devtools$client$shared$add_plugin_BANG_(plugin_id,depends_on,init_fn,stop_fn){\nif((plugin_id instanceof cljs.core.Keyword)){\n} else {\nthrow (new Error(\x22Assert failed: (keyword? plugin-id)\x22));\n}\n\nif(cljs.core.set_QMARK_(depends_on)){\n} else {\nthrow (new Error(\x22Assert failed: (set? depends-on)\x22));\n}\n\nif(cljs.core.fn_QMARK_(init_fn)){\n} else {\nthrow (new Error(\x22Assert failed: (fn? init-fn)\x22));\n}\n\nif(cljs.core.fn_QMARK_(stop_fn)){\n} else {\nthrow (new Error(\x22Assert failed: (fn? stop-fn)\x22));\n}\n\nvar temp__5808__auto___28866 \x3d cljs.core.deref(shadow.cljs.devtools.client.shared.runtime_ref);\nif((temp__5808__auto___28866 \x3d\x3d null)){\n} else {\nvar runtime_28867 \x3d temp__5808__auto___28866;\nvar temp__5808__auto___28868__$1 \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(runtime_28867,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855),plugin_id], null));\nif((temp__5808__auto___28868__$1 \x3d\x3d null)){\n} else {\nvar started_28869 \x3d temp__5808__auto___28868__$1;\nvar map__28608_28870 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.cljs.devtools.client.shared.plugins_ref),plugin_id);\nvar map__28608_28871__$1 \x3d cljs.core.__destructure_map(map__28608_28870);\nvar old_28872 \x3d map__28608_28871__$1;\nvar stop_fn_28873__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28608_28871__$1,new cljs.core.Keyword(null,\x22stop-fn\x22,\x22stop-fn\x22,-348472246));\n(stop_fn_28873__$1.cljs$core$IFn$_invoke$arity$1 ? stop_fn_28873__$1.cljs$core$IFn$_invoke$arity$1(started_28869) : stop_fn_28873__$1.call(null, started_28869));\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(shadow.cljs.devtools.client.shared.runtime_ref,cljs.core.update,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855),cljs.core.dissoc,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([plugin_id], 0));\n}\n}\n\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(shadow.cljs.devtools.client.shared.plugins_ref,cljs.core.assoc,plugin_id,new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22ext-id\x22,\x22ext-id\x22,-653860474),plugin_id,new cljs.core.Keyword(null,\x22depends-on\x22,\x22depends-on\x22,-1448442022),depends_on,new cljs.core.Keyword(null,\x22init-fn\x22,\x22init-fn\x22,777257971),init_fn,new cljs.core.Keyword(null,\x22stop-fn\x22,\x22stop-fn\x22,-348472246),stop_fn], null));\n\nvar temp__5808__auto__ \x3d cljs.core.deref(shadow.cljs.devtools.client.shared.runtime_ref);\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar runtime \x3d temp__5808__auto__;\nreturn shadow.cljs.devtools.client.shared.start_all_plugins_BANG_(runtime);\n}\n});\nshadow.cljs.devtools.client.shared.transit_read \x3d (function shadow$cljs$devtools$client$shared$transit_read(p__28614,data){\nvar map__28616 \x3d p__28614;\nvar map__28616__$1 \x3d cljs.core.__destructure_map(map__28616);\nvar state \x3d map__28616__$1;\nvar transit_readers \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28616__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22transit-readers\x22,\x22shadow.cljs.devtools.client.shared/transit-readers\x22,-1866893537));\nvar t \x3d cognitect.transit.reader.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22json\x22,\x22json\x22,1279968570),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781),transit_readers], null));\nreturn cognitect.transit.read(t,data);\n});\nshadow.cljs.devtools.client.shared.transit_str \x3d (function shadow$cljs$devtools$client$shared$transit_str(p__28621,obj){\nvar map__28622 \x3d p__28621;\nvar map__28622__$1 \x3d cljs.core.__destructure_map(map__28622);\nvar state \x3d map__28622__$1;\nvar transit_writers \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28622__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22transit-writers\x22,\x22shadow.cljs.devtools.client.shared/transit-writers\x22,-776127897));\nvar w \x3d cognitect.transit.writer.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22json\x22,\x22json\x22,1279968570),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22handlers\x22,\x22handlers\x22,79528781),transit_writers], null));\nreturn cognitect.transit.write(w,obj);\n});\nshadow.cljs.devtools.client.shared.add_transit_writers_BANG_ \x3d (function shadow$cljs$devtools$client$shared$add_transit_writers_BANG_(p__28627,writers){\nvar map__28628 \x3d p__28627;\nvar map__28628__$1 \x3d cljs.core.__destructure_map(map__28628);\nvar runtime \x3d map__28628__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28628__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(state_ref,cljs.core.update,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22transit-writers\x22,\x22shadow.cljs.devtools.client.shared/transit-writers\x22,-776127897),cljs.core.merge,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([writers], 0));\n\nreturn runtime;\n});\nshadow.cljs.devtools.client.shared.continue_BANG_ \x3d (function shadow$cljs$devtools$client$shared$continue_BANG_(state){\nreturn (shadow.cljs.devtools.client.shared.interpret_actions.cljs$core$IFn$_invoke$arity$1 ? shadow.cljs.devtools.client.shared.interpret_actions.cljs$core$IFn$_invoke$arity$1(state) : shadow.cljs.devtools.client.shared.interpret_actions.call(null, state));\n});\nshadow.cljs.devtools.client.shared.abort_BANG_ \x3d (function shadow$cljs$devtools$client$shared$abort_BANG_(p__28632,action,ex){\nvar map__28633 \x3d p__28632;\nvar map__28633__$1 \x3d cljs.core.__destructure_map(map__28633);\nvar state \x3d map__28633__$1;\nvar callback \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28633__$1,new cljs.core.Keyword(null,\x22callback\x22,\x22callback\x22,-705136228));\nvar G__28634 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(state,new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211),new cljs.core.Keyword(null,\x22runtime-error\x22,\x22runtime-error\x22,-2116843646),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22ex\x22,\x22ex\x22,-1413771341),ex,new cljs.core.Keyword(null,\x22ex-action\x22,\x22ex-action\x22,672251553),action], 0)),new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22callback\x22,\x22callback\x22,-705136228)], 0));\nreturn (callback.cljs$core$IFn$_invoke$arity$1 ? callback.cljs$core$IFn$_invoke$arity$1(G__28634) : callback.call(null, G__28634));\n});\nshadow.cljs.devtools.client.shared.handle_invoke \x3d (function shadow$cljs$devtools$client$shared$handle_invoke(state,runtime,action){\nvar res \x3d shadow.cljs.devtools.client.shared.do_invoke(runtime,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760).cljs$core$IFn$_invoke$arity$1(state),action);\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22internal\x22,\x22internal\x22,-854870097).cljs$core$IFn$_invoke$arity$1(action))){\nreturn state;\n} else {\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(state,new cljs.core.Keyword(null,\x22results\x22,\x22results\x22,-1134170113),cljs.core.conj,res);\n}\n});\nshadow.cljs.devtools.client.shared.handle_repl_invoke \x3d (function shadow$cljs$devtools$client$shared$handle_repl_invoke(state,runtime,action){\nvar ret \x3d shadow.cljs.devtools.client.shared.do_invoke(runtime,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760).cljs$core$IFn$_invoke$arity$1(state),action);\n(cljs.core._STAR_3 \x3d cljs.core._STAR_2);\n\n(cljs.core._STAR_2 \x3d cljs.core._STAR_1);\n\n(cljs.core._STAR_1 \x3d ret);\n\nif(cljs.core.truth_(new cljs.core.Keyword(null,\x22internal\x22,\x22internal\x22,-854870097).cljs$core$IFn$_invoke$arity$1(action))){\nreturn state;\n} else {\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(state,new cljs.core.Keyword(null,\x22results\x22,\x22results\x22,-1134170113),cljs.core.conj,ret);\n}\n});\nshadow.cljs.devtools.client.shared.interpret_action \x3d (function shadow$cljs$devtools$client$shared$interpret_action(p__28648,p__28649){\nvar map__28650 \x3d p__28648;\nvar map__28650__$1 \x3d cljs.core.__destructure_map(map__28650);\nvar state \x3d map__28650__$1;\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28650__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar obj_support \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28650__$1,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229));\nvar map__28651 \x3d p__28649;\nvar map__28651__$1 \x3d cljs.core.__destructure_map(map__28651);\nvar action \x3d map__28651__$1;\nvar type \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28651__$1,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348));\nvar G__28652 \x3d type;\nvar G__28652__$1 \x3d (((G__28652 instanceof cljs.core.Keyword))?G__28652.fqn:null);\nswitch (G__28652__$1) {\ncase \x22repl/init\x22:\nreturn shadow.cljs.devtools.client.shared.do_repl_init(runtime,action,(function (){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952).cljs$core$IFn$_invoke$arity$1(runtime),cljs.core.assoc,new cljs.core.Keyword(null,\x22init-complete\x22,\x22init-complete\x22,-157163484),true);\n\nreturn shadow.cljs.devtools.client.shared.continue_BANG_(state);\n}),(function (ex){\nreturn shadow.cljs.devtools.client.shared.abort_BANG_(state,action,ex);\n}));\n\nbreak;\ncase \x22repl/set-ns\x22:\nvar map__28653 \x3d action;\nvar map__28653__$1 \x3d cljs.core.__destructure_map(map__28653);\nvar ns \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28653__$1,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760));\nvar internal \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28653__$1,new cljs.core.Keyword(null,\x22internal\x22,\x22internal\x22,-854870097));\nreturn shadow.cljs.devtools.client.shared.continue_BANG_((function (){var G__28654 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(state,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),ns);\nif(cljs.core.not(internal)){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(G__28654,new cljs.core.Keyword(null,\x22results\x22,\x22results\x22,-1134170113),cljs.core.conj,null);\n} else {\nreturn G__28654;\n}\n})());\n\nbreak;\ncase \x22repl/require\x22:\nvar map__28655 \x3d action;\nvar map__28655__$1 \x3d cljs.core.__destructure_map(map__28655);\nvar internal \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28655__$1,new cljs.core.Keyword(null,\x22internal\x22,\x22internal\x22,-854870097));\nreturn shadow.cljs.devtools.client.shared.do_repl_require(runtime,action,(function (sources){\nreturn shadow.cljs.devtools.client.shared.continue_BANG_((function (){var G__28656 \x3d cljs.core.update.cljs$core$IFn$_invoke$arity$4(state,new cljs.core.Keyword(null,\x22loaded-sources\x22,\x22loaded-sources\x22,-300252436),cljs.core.into,sources);\nif(cljs.core.not(internal)){\nreturn cljs.core.update.cljs$core$IFn$_invoke$arity$4(G__28656,new cljs.core.Keyword(null,\x22results\x22,\x22results\x22,-1134170113),cljs.core.conj,null);\n} else {\nreturn G__28656;\n}\n})());\n}),(function (ex){\nreturn shadow.cljs.devtools.client.shared.abort_BANG_(state,action,ex);\n}));\n\nbreak;\ncase \x22repl/invoke\x22:\nvar repl \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(state,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22input\x22,\x22input\x22,556931961),new cljs.core.Keyword(null,\x22repl\x22,\x22repl\x22,-35398667)], null));\ntry{var temp__5808__auto___28891 \x3d cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(state,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22input\x22,\x22input\x22,556931961),new cljs.core.Keyword(null,\x22obj-refs\x22,\x22obj-refs\x22,-2086642078)], null));\nif((temp__5808__auto___28891 \x3d\x3d null)){\n} else {\nvar obj_refs_28892 \x3d temp__5808__auto___28891;\nvar obj_support_28893__$1 \x3d new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229).cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952).cljs$core$IFn$_invoke$arity$1(runtime))));\nvar vec__28660_28894 \x3d obj_refs_28892;\nvar a_28895 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28660_28894,(0),null);\nvar b_28896 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28660_28894,(1),null);\nvar c_28897 \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28660_28894,(2),null);\nif(cljs.core.truth_(a_28895)){\n(cljs.core._STAR_1 \x3d new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962).cljs$core$IFn$_invoke$arity$1(shadow.remote.runtime.obj_support.get_ref(obj_support_28893__$1,a_28895)));\n} else {\n}\n\nif(cljs.core.truth_(b_28896)){\n(cljs.core._STAR_2 \x3d new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962).cljs$core$IFn$_invoke$arity$1(shadow.remote.runtime.obj_support.get_ref(obj_support_28893__$1,b_28896)));\n} else {\n}\n\nif(cljs.core.truth_(c_28897)){\n(cljs.core._STAR_3 \x3d new cljs.core.Keyword(null,\x22obj\x22,\x22obj\x22,981763962).cljs$core$IFn$_invoke$arity$1(shadow.remote.runtime.obj_support.get_ref(obj_support_28893__$1,c_28897)));\n} else {\n}\n}\n\nvar invoke_fn \x3d (cljs.core.truth_((function (){var and__5000__auto__ \x3d repl;\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.not(new cljs.core.Keyword(null,\x22internal\x22,\x22internal\x22,-854870097).cljs$core$IFn$_invoke$arity$1(action));\n} else {\nreturn and__5000__auto__;\n}\n})())?shadow.cljs.devtools.client.shared.handle_repl_invoke:shadow.cljs.devtools.client.shared.handle_invoke);\nreturn shadow.cljs.devtools.client.shared.continue_BANG_((invoke_fn.cljs$core$IFn$_invoke$arity$3 ? invoke_fn.cljs$core$IFn$_invoke$arity$3(state,runtime,action) : invoke_fn.call(null, state,runtime,action)));\n}catch (e28658){var ex \x3d e28658;\nif(cljs.core.truth_(repl)){\n(cljs.core._STAR_e \x3d ex);\n} else {\n}\n\nconsole.error(\x22REPL Invoke Exception\x22,ex,action);\n\nreturn shadow.cljs.devtools.client.shared.abort_BANG_(state,action,ex);\n}\nbreak;\ndefault:\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22unhandled repl action\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22state\x22,\x22state\x22,-1988618099),state,new cljs.core.Keyword(null,\x22action\x22,\x22action\x22,-811238024),action], null));\n\n}\n});\nshadow.cljs.devtools.client.shared.interpret_actions \x3d (function shadow$cljs$devtools$client$shared$interpret_actions(p__28666){\nvar map__28667 \x3d p__28666;\nvar map__28667__$1 \x3d cljs.core.__destructure_map(map__28667);\nvar state \x3d map__28667__$1;\nvar queue \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28667__$1,new cljs.core.Keyword(null,\x22queue\x22,\x22queue\x22,1455835879));\nvar warnings \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28667__$1,new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651));\nif(cljs.core.empty_QMARK_(queue)){\nvar map__28668 \x3d state;\nvar map__28668__$1 \x3d cljs.core.__destructure_map(map__28668);\nvar callback \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28668__$1,new cljs.core.Keyword(null,\x22callback\x22,\x22callback\x22,-705136228));\nvar G__28669 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(state,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22callback\x22,\x22callback\x22,-705136228),new cljs.core.Keyword(null,\x22queue\x22,\x22queue\x22,1455835879)], 0)),new cljs.core.Keyword(null,\x22time-finish\x22,\x22time-finish\x22,-1456032653),Date.now());\nreturn (callback.cljs$core$IFn$_invoke$arity$1 ? callback.cljs$core$IFn$_invoke$arity$1(G__28669) : callback.call(null, G__28669));\n} else {\nif(((cljs.core.seq(warnings)) \x26\x26 (shadow.cljs.devtools.client.env.ignore_warnings \x3d\x3d\x3d false))){\nvar map__28674 \x3d state;\nvar map__28674__$1 \x3d cljs.core.__destructure_map(map__28674);\nvar callback \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28674__$1,new cljs.core.Keyword(null,\x22callback\x22,\x22callback\x22,-705136228));\nvar G__28679 \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(state,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22callback\x22,\x22callback\x22,-705136228),new cljs.core.Keyword(null,\x22queue\x22,\x22queue\x22,1455835879)], 0)),new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211),new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651),warnings,new cljs.core.Keyword(null,\x22time-finish\x22,\x22time-finish\x22,-1456032653),Date.now()], 0));\nreturn (callback.cljs$core$IFn$_invoke$arity$1 ? callback.cljs$core$IFn$_invoke$arity$1(G__28679) : callback.call(null, G__28679));\n} else {\nvar action \x3d cljs.core.first(queue);\nvar state__$1 \x3d cljs.core.update.cljs$core$IFn$_invoke$arity$3(state,new cljs.core.Keyword(null,\x22queue\x22,\x22queue\x22,1455835879),cljs.core.rest);\nreturn shadow.cljs.devtools.client.shared.interpret_action(state__$1,action);\n\n}\n}\n});\nshadow.cljs.devtools.client.shared.setup_actions \x3d (function shadow$cljs$devtools$client$shared$setup_actions(runtime,input,p__28685,callback){\nvar map__28686 \x3d p__28685;\nvar map__28686__$1 \x3d cljs.core.__destructure_map(map__28686);\nvar msg \x3d map__28686__$1;\nvar actions \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28686__$1,new cljs.core.Keyword(null,\x22actions\x22,\x22actions\x22,-812656882));\nreturn cljs.core.PersistentHashMap.fromArrays([new cljs.core.Keyword(null,\x22queue\x22,\x22queue\x22,1455835879),new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),new cljs.core.Keyword(null,\x22loaded-sources\x22,\x22loaded-sources\x22,-300252436),new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651),new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211),new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),new cljs.core.Keyword(null,\x22input\x22,\x22input\x22,556931961),new cljs.core.Keyword(null,\x22callback\x22,\x22callback\x22,-705136228),new cljs.core.Keyword(null,\x22time-start\x22,\x22time-start\x22,-590811745),new cljs.core.Keyword(null,\x22results\x22,\x22results\x22,-1134170113)],[actions,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760).cljs$core$IFn$_invoke$arity$1(input),msg,cljs.core.PersistentVector.EMPTY,cljs.core.vec(cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([actions], 0))),new cljs.core.Keyword(null,\x22ok\x22,\x22ok\x22,967785236),runtime,input,callback,Date.now(),cljs.core.PersistentVector.EMPTY]);\n});\n\n/**\n* @constructor\n * @implements {cljs.core.IRecord}\n * @implements {shadow.cljs.devtools.client.shared.IRemote}\n * @implements {shadow.remote.runtime.api.IRuntime}\n * @implements {cljs.core.IKVReduce}\n * @implements {cljs.core.IEquiv}\n * @implements {cljs.core.IHash}\n * @implements {cljs.core.ICollection}\n * @implements {cljs.core.ICounted}\n * @implements {cljs.core.ISeqable}\n * @implements {cljs.core.IMeta}\n * @implements {cljs.core.ICloneable}\n * @implements {cljs.core.IPrintWithWriter}\n * @implements {cljs.core.IIterable}\n * @implements {cljs.core.IWithMeta}\n * @implements {cljs.core.IAssociative}\n * @implements {cljs.core.IMap}\n * @implements {cljs.core.ILookup}\n * @implements {shadow.remote.runtime.api.IEvalCLJS}\n*/\nshadow.cljs.devtools.client.shared.Runtime \x3d (function (state_ref,__meta,__extmap,__hash){\nthis.state_ref \x3d state_ref;\nthis.__meta \x3d __meta;\nthis.__extmap \x3d __extmap;\nthis.__hash \x3d __hash;\nthis.cljs$lang$protocol_mask$partition0$ \x3d 2230716170;\nthis.cljs$lang$protocol_mask$partition1$ \x3d 139264;\n});\n(shadow.cljs.devtools.client.shared.Runtime.prototype.attempt_connect_BANG_ \x3d (function (){\nvar self__ \x3d this;\nvar this$ \x3d this;\nvar map__28692 \x3d cljs.core.deref(self__.state_ref);\nvar map__28692__$1 \x3d cljs.core.__destructure_map(map__28692);\nvar state \x3d map__28692__$1;\nvar ws_connecting \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28692__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connecting\x22,\x22shadow.cljs.devtools.client.shared/ws-connecting\x22,-847036450));\nvar ws_connect_timeout \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28692__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connect-timeout\x22,\x22shadow.cljs.devtools.client.shared/ws-connect-timeout\x22,1477702043));\nvar shutdown \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28692__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22shutdown\x22,\x22shadow.cljs.devtools.client.shared/shutdown\x22,1947481008));\nvar stale \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28692__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22stale\x22,\x22shadow.cljs.devtools.client.shared/stale\x22,-1017562082));\nvar ws_state \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28692__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-state\x22,\x22shadow.cljs.devtools.client.shared/ws-state\x22,1653373656));\nvar ws_stop_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28692__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-stop-fn\x22,\x22shadow.cljs.devtools.client.shared/ws-stop-fn\x22,88454255));\nvar ws_start_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28692__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-start-fn\x22,\x22shadow.cljs.devtools.client.shared/ws-start-fn\x22,-49893682));\nif(((cljs.core.not(shutdown)) \x26\x26 (((cljs.core.not(stale)) \x26\x26 (cljs.core.not(ws_connecting)))))){\nif(cljs.core.truth_(ws_connect_timeout)){\nclearTimeout(ws_connect_timeout);\n} else {\n}\n\nif((!((ws_state \x3d\x3d null)))){\n(ws_stop_fn.cljs$core$IFn$_invoke$arity$1 ? ws_stop_fn.cljs$core$IFn$_invoke$arity$1(ws_state) : ws_stop_fn.call(null, ws_state));\n} else {\n}\n\nvar ws_state__$1 \x3d (ws_start_fn.cljs$core$IFn$_invoke$arity$1 ? ws_start_fn.cljs$core$IFn$_invoke$arity$1(this$) : ws_start_fn.call(null, this$));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(self__.state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connecting\x22,\x22shadow.cljs.devtools.client.shared/ws-connecting\x22,-847036450),true,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connected\x22,\x22shadow.cljs.devtools.client.shared/ws-connected\x22,-1476385853),false,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-state\x22,\x22shadow.cljs.devtools.client.shared/ws-state\x22,1653373656),ws_state__$1], 0));\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.schedule_connect_BANG_ \x3d (function (after){\nvar self__ \x3d this;\nvar this$ \x3d this;\nvar map__28697 \x3d cljs.core.deref(self__.state_ref);\nvar map__28697__$1 \x3d cljs.core.__destructure_map(map__28697);\nvar ws_connect_timeout \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28697__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connect-timeout\x22,\x22shadow.cljs.devtools.client.shared/ws-connect-timeout\x22,1477702043));\nvar stale \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28697__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22stale\x22,\x22shadow.cljs.devtools.client.shared/stale\x22,-1017562082));\nvar shutdown \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28697__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22shutdown\x22,\x22shadow.cljs.devtools.client.shared/shutdown\x22,1947481008));\nif(cljs.core.truth_(ws_connect_timeout)){\nclearTimeout(ws_connect_timeout);\n} else {\n}\n\nif(((cljs.core.not(stale)) \x26\x26 (cljs.core.not(shutdown)))){\nshadow.remote.runtime.shared.trigger_BANG_(this$,new cljs.core.Keyword(null,\x22on-reconnect\x22,\x22on-reconnect\x22,1239988702));\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connect-timeout\x22,\x22shadow.cljs.devtools.client.shared/ws-connect-timeout\x22,1477702043),setTimeout((function (){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(self__.state_ref,cljs.core.dissoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connect-timeout\x22,\x22shadow.cljs.devtools.client.shared/ws-connect-timeout\x22,1477702043));\n\nreturn this$.attempt_connect_BANG_();\n}),after));\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$ILookup$_lookup$arity$2 \x3d (function (this__5300__auto__,k__5301__auto__){\nvar self__ \x3d this;\nvar this__5300__auto____$1 \x3d this;\nreturn this__5300__auto____$1.cljs$core$ILookup$_lookup$arity$3(null, k__5301__auto__,null);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$ILookup$_lookup$arity$3 \x3d (function (this__5302__auto__,k28688,else__5303__auto__){\nvar self__ \x3d this;\nvar this__5302__auto____$1 \x3d this;\nvar G__28700 \x3d k28688;\nvar G__28700__$1 \x3d (((G__28700 instanceof cljs.core.Keyword))?G__28700.fqn:null);\nswitch (G__28700__$1) {\ncase \x22state-ref\x22:\nreturn self__.state_ref;\n\nbreak;\ndefault:\nreturn cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k28688,else__5303__auto__);\n\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 \x3d (function (this__5320__auto__,f__5321__auto__,init__5322__auto__){\nvar self__ \x3d this;\nvar this__5320__auto____$1 \x3d this;\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret__5323__auto__,p__28706){\nvar vec__28707 \x3d p__28706;\nvar k__5324__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28707,(0),null);\nvar v__5325__auto__ \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__28707,(1),null);\nreturn (f__5321__auto__.cljs$core$IFn$_invoke$arity$3 ? f__5321__auto__.cljs$core$IFn$_invoke$arity$3(ret__5323__auto__,k__5324__auto__,v__5325__auto__) : f__5321__auto__.call(null, ret__5323__auto__,k__5324__auto__,v__5325__auto__));\n}),init__5322__auto__,this__5320__auto____$1);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 \x3d (function (this__5315__auto__,writer__5316__auto__,opts__5317__auto__){\nvar self__ \x3d this;\nvar this__5315__auto____$1 \x3d this;\nvar pr_pair__5318__auto__ \x3d (function (keyval__5319__auto__){\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,cljs.core.pr_writer,\x22\x22,\x22 \x22,\x22\x22,opts__5317__auto__,keyval__5319__auto__);\n});\nreturn cljs.core.pr_sequential_writer(writer__5316__auto__,pr_pair__5318__auto__,\x22#shadow.cljs.devtools.client.shared.Runtime{\x22,\x22, \x22,\x22}\x22,opts__5317__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952),self__.state_ref],null))], null),self__.__extmap));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IIterable$_iterator$arity$1 \x3d (function (G__28687){\nvar self__ \x3d this;\nvar G__28687__$1 \x3d this;\nreturn (new cljs.core.RecordIter((0),G__28687__$1,1,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952)], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter())));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IMeta$_meta$arity$1 \x3d (function (this__5298__auto__){\nvar self__ \x3d this;\nvar this__5298__auto____$1 \x3d this;\nreturn self__.__meta;\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$ICloneable$_clone$arity$1 \x3d (function (this__5295__auto__){\nvar self__ \x3d this;\nvar this__5295__auto____$1 \x3d this;\nreturn (new shadow.cljs.devtools.client.shared.Runtime(self__.state_ref,self__.__meta,self__.__extmap,self__.__hash));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$ICounted$_count$arity$1 \x3d (function (this__5304__auto__){\nvar self__ \x3d this;\nvar this__5304__auto____$1 \x3d this;\nreturn (1 + cljs.core.count(self__.__extmap));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IHash$_hash$arity$1 \x3d (function (this__5296__auto__){\nvar self__ \x3d this;\nvar this__5296__auto____$1 \x3d this;\nvar h__5111__auto__ \x3d self__.__hash;\nif((!((h__5111__auto__ \x3d\x3d null)))){\nreturn h__5111__auto__;\n} else {\nvar h__5111__auto____$1 \x3d (function (coll__5297__auto__){\nreturn (229736719 ^ cljs.core.hash_unordered_coll(coll__5297__auto__));\n})(this__5296__auto____$1);\n(self__.__hash \x3d h__5111__auto____$1);\n\nreturn h__5111__auto____$1;\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IEquiv$_equiv$arity$2 \x3d (function (this28689,other28690){\nvar self__ \x3d this;\nvar this28689__$1 \x3d this;\nreturn (((!((other28690 \x3d\x3d null)))) \x26\x26 ((((this28689__$1.constructor \x3d\x3d\x3d other28690.constructor)) \x26\x26 (((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28689__$1.state_ref,other28690.state_ref)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this28689__$1.__extmap,other28690.__extmap)))))));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IEvalCLJS$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IEvalCLJS$_cljs_eval$arity$3 \x3d (function (this$,input,callback){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$3(this$__$1,new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22cljs-compile\x22,\x22cljs-compile\x22,-1735075279),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),shadow.cljs.devtools.client.env.worker_client_id,new cljs.core.Keyword(null,\x22input\x22,\x22input\x22,556931961),input,new cljs.core.Keyword(null,\x22include-init\x22,\x22include-init\x22,1061115199),cljs.core.not(new cljs.core.Keyword(null,\x22init-complete\x22,\x22init-complete\x22,-157163484).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(self__.state_ref)))], null),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22cljs-compile-result\x22,\x22cljs-compile-result\x22,-1137644713),(function (msg){\nreturn shadow.cljs.devtools.client.shared.interpret_actions(shadow.cljs.devtools.client.shared.setup_actions(this$__$1,input,msg,callback));\n}),new cljs.core.Keyword(null,\x22cljs-compile-error\x22,\x22cljs-compile-error\x22,-371665768),(function (p__28735){\nvar map__28736 \x3d p__28735;\nvar map__28736__$1 \x3d cljs.core.__destructure_map(map__28736);\nvar ex_oid \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28736__$1,new cljs.core.Keyword(null,\x22ex-oid\x22,\x22ex-oid\x22,-650256737));\nvar ex_client_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28736__$1,new cljs.core.Keyword(null,\x22ex-client-id\x22,\x22ex-client-id\x22,-446123984));\nvar report \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28736__$1,new cljs.core.Keyword(null,\x22report\x22,\x22report\x22,1394055010));\nvar G__28737 \x3d new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211),new cljs.core.Keyword(null,\x22compile-error\x22,\x22compile-error\x22,-1313154526),new cljs.core.Keyword(null,\x22ex-oid\x22,\x22ex-oid\x22,-650256737),ex_oid,new cljs.core.Keyword(null,\x22ex-client-id\x22,\x22ex-client-id\x22,-446123984),ex_client_id,new cljs.core.Keyword(null,\x22report\x22,\x22report\x22,1394055010),report], null);\nreturn (callback.cljs$core$IFn$_invoke$arity$1 ? callback.cljs$core$IFn$_invoke$arity$1(G__28737) : callback.call(null, G__28737));\n}),new cljs.core.Keyword(null,\x22client-not-found\x22,\x22client-not-found\x22,-1754042614),(function (msg){\nvar G__28738 \x3d new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211),new cljs.core.Keyword(null,\x22worker-not-found\x22,\x22worker-not-found\x22,-1848657608)], null);\nreturn (callback.cljs$core$IFn$_invoke$arity$1 ? callback.cljs$core$IFn$_invoke$arity$1(G__28738) : callback.call(null, G__28738));\n})], null));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IRemote$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IRemote$remote_open$arity$2 \x3d (function (this$,e){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(self__.state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-errors\x22,\x22shadow.cljs.devtools.client.shared/ws-errors\x22,105464879),(0),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connecting\x22,\x22shadow.cljs.devtools.client.shared/ws-connecting\x22,-847036450),false,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connected\x22,\x22shadow.cljs.devtools.client.shared/ws-connected\x22,-1476385853),true,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-last-msg\x22,\x22shadow.cljs.devtools.client.shared/ws-last-msg\x22,-1438906782),shadow.remote.runtime.shared.now()], 0));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IRemote$remote_msg$arity$2 \x3d (function (this$,text){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar msg \x3d shadow.cljs.devtools.client.shared.transit_read(cljs.core.deref(self__.state_ref),text);\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-last-msg\x22,\x22shadow.cljs.devtools.client.shared/ws-last-msg\x22,-1438906782),shadow.remote.runtime.shared.now());\n\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22access-denied\x22,\x22access-denied\x22,959449406),new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955).cljs$core$IFn$_invoke$arity$1(msg))){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22stale\x22,\x22shadow.cljs.devtools.client.shared/stale\x22,-1017562082),true);\n} else {\n}\n\nreturn shadow.remote.runtime.shared.process(this$__$1,msg);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IRemote$remote_close$arity$3 \x3d (function (this$,e,info){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.state_ref,cljs.core.dissoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connected\x22,\x22shadow.cljs.devtools.client.shared/ws-connected\x22,-1476385853),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connecting\x22,\x22shadow.cljs.devtools.client.shared/ws-connecting\x22,-847036450));\n\nif(((3) \x3e\x3d new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-errors\x22,\x22shadow.cljs.devtools.client.shared/ws-errors\x22,105464879).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(self__.state_ref)))){\nreturn this$__$1.schedule_connect_BANG_((5000));\n} else {\nreturn console.warn(\x22shadow-cljs: giving up trying to connect to \x22,info);\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IRemote$remote_error$arity$2 \x3d (function (this$,e){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.state_ref,cljs.core.update,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-errors\x22,\x22shadow.cljs.devtools.client.shared/ws-errors\x22,105464879),cljs.core.inc);\n\nshadow.remote.runtime.shared.trigger_BANG_(this$__$1,new cljs.core.Keyword(null,\x22on-disconnect\x22,\x22on-disconnect\x22,-809021814));\n\nreturn console.error(\x22shadow-cljs - remote-error\x22,e);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IRuntime$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IRuntime$relay_msg$arity$2 \x3d (function (this$,msg){\nvar self__ \x3d this;\nvar this$__$1 \x3d this;\nvar map__28740 \x3d cljs.core.deref(self__.state_ref);\nvar map__28740__$1 \x3d cljs.core.__destructure_map(map__28740);\nvar state \x3d map__28740__$1;\nvar ws_state \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28740__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-state\x22,\x22shadow.cljs.devtools.client.shared/ws-state\x22,1653373656));\nvar ws_connected \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28740__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connected\x22,\x22shadow.cljs.devtools.client.shared/ws-connected\x22,-1476385853));\nvar ws_send_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28740__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-send-fn\x22,\x22shadow.cljs.devtools.client.shared/ws-send-fn\x22,-1986889866));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-last-msg\x22,\x22shadow.cljs.devtools.client.shared/ws-last-msg\x22,-1438906782),shadow.remote.runtime.shared.now());\n\nif(cljs.core.not(ws_connected)){\nreturn console.warn(\x22shadow-cljs - dropped ws message, not connected\x22,msg,state);\n} else {\nvar s \x3d (function (){try{return shadow.cljs.devtools.client.shared.transit_str(state,msg);\n}catch (e28741){var e \x3d e28741;\nthrow cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22failed to encode relay msg\x22,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444),msg], null));\n}})();\nreturn (ws_send_fn.cljs$core$IFn$_invoke$arity$2 ? ws_send_fn.cljs$core$IFn$_invoke$arity$2(ws_state,s) : ws_send_fn.call(null, ws_state,s));\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IRuntime$add_extension$arity$3 \x3d (function (runtime,key,spec){\nvar self__ \x3d this;\nvar runtime__$1 \x3d this;\nreturn shadow.remote.runtime.shared.add_extension(runtime__$1,key,spec);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IRuntime$del_extension$arity$2 \x3d (function (runtime,key){\nvar self__ \x3d this;\nvar runtime__$1 \x3d this;\nreturn shadow.remote.runtime.shared.del_extension(runtime__$1,key);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IMap$_dissoc$arity$2 \x3d (function (this__5310__auto__,k__5311__auto__){\nvar self__ \x3d this;\nvar this__5310__auto____$1 \x3d this;\nif(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952),null], null), null),k__5311__auto__)){\nreturn cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__5310__auto____$1),self__.__meta),k__5311__auto__);\n} else {\nreturn (new shadow.cljs.devtools.client.shared.Runtime(self__.state_ref,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__5311__auto__)),null));\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 \x3d (function (this__5307__auto__,k28688){\nvar self__ \x3d this;\nvar this__5307__auto____$1 \x3d this;\nvar G__28743 \x3d k28688;\nvar G__28743__$1 \x3d (((G__28743 instanceof cljs.core.Keyword))?G__28743.fqn:null);\nswitch (G__28743__$1) {\ncase \x22state-ref\x22:\nreturn true;\n\nbreak;\ndefault:\nreturn cljs.core.contains_QMARK_(self__.__extmap,k28688);\n\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IAssociative$_assoc$arity$3 \x3d (function (this__5308__auto__,k__5309__auto__,G__28687){\nvar self__ \x3d this;\nvar this__5308__auto____$1 \x3d this;\nvar pred__28747 \x3d cljs.core.keyword_identical_QMARK_;\nvar expr__28748 \x3d k__5309__auto__;\nif(cljs.core.truth_((pred__28747.cljs$core$IFn$_invoke$arity$2 ? pred__28747.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952),expr__28748) : pred__28747.call(null, new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952),expr__28748)))){\nreturn (new shadow.cljs.devtools.client.shared.Runtime(G__28687,self__.__meta,self__.__extmap,null));\n} else {\nreturn (new shadow.cljs.devtools.client.shared.Runtime(self__.state_ref,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__5309__auto__,G__28687),null));\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$ISeqable$_seq$arity$1 \x3d (function (this__5313__auto__){\nvar self__ \x3d this;\nvar this__5313__auto____$1 \x3d this;\nreturn cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952),self__.state_ref,null))], null),self__.__extmap));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$IWithMeta$_with_meta$arity$2 \x3d (function (this__5299__auto__,G__28687){\nvar self__ \x3d this;\nvar this__5299__auto____$1 \x3d this;\nreturn (new shadow.cljs.devtools.client.shared.Runtime(self__.state_ref,G__28687,self__.__extmap,self__.__hash));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.cljs$core$ICollection$_conj$arity$2 \x3d (function (this__5305__auto__,entry__5306__auto__){\nvar self__ \x3d this;\nvar this__5305__auto____$1 \x3d this;\nif(cljs.core.vector_QMARK_(entry__5306__auto__)){\nreturn this__5305__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null, cljs.core._nth(entry__5306__auto__,(0)),cljs.core._nth(entry__5306__auto__,(1)));\n} else {\nreturn cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__5305__auto____$1,entry__5306__auto__);\n}\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.getBasis \x3d (function (){\nreturn new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Symbol(null,\x22state-ref\x22,\x22state-ref\x22,-526560817,null)], null);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.cljs$lang$type \x3d true);\n\n(shadow.cljs.devtools.client.shared.Runtime.cljs$lang$ctorPrSeq \x3d (function (this__5346__auto__){\nreturn (new cljs.core.List(null,\x22shadow.cljs.devtools.client.shared/Runtime\x22,null,(1),null));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.cljs$lang$ctorPrWriter \x3d (function (this__5346__auto__,writer__5347__auto__){\nreturn cljs.core._write(writer__5347__auto__,\x22shadow.cljs.devtools.client.shared/Runtime\x22);\n}));\n\n/**\n * Positional factory function for shadow.cljs.devtools.client.shared/Runtime.\n */\nshadow.cljs.devtools.client.shared.__GT_Runtime \x3d (function shadow$cljs$devtools$client$shared$__GT_Runtime(state_ref){\nreturn (new shadow.cljs.devtools.client.shared.Runtime(state_ref,null,null,null));\n});\n\n/**\n * Factory function for shadow.cljs.devtools.client.shared/Runtime, taking a map of keywords to field values.\n */\nshadow.cljs.devtools.client.shared.map__GT_Runtime \x3d (function shadow$cljs$devtools$client$shared$map__GT_Runtime(G__28691){\nvar extmap__5342__auto__ \x3d (function (){var G__28751 \x3d cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(G__28691,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nif(cljs.core.record_QMARK_(G__28691)){\nreturn cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__28751);\n} else {\nreturn G__28751;\n}\n})();\nreturn (new shadow.cljs.devtools.client.shared.Runtime(new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952).cljs$core$IFn$_invoke$arity$1(G__28691),null,cljs.core.not_empty(extmap__5342__auto__),null));\n});\n\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.shared !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.shared.print_subs !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.shared.print_subs \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentHashSet.EMPTY);\n}\nshadow.cljs.devtools.client.shared.stop_runtime_BANG_ \x3d (function shadow$cljs$devtools$client$shared$stop_runtime_BANG_(p__28754){\nvar map__28755 \x3d p__28754;\nvar map__28755__$1 \x3d cljs.core.__destructure_map(map__28755);\nvar runtime \x3d map__28755__$1;\nvar state_ref \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28755__$1,new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952));\nvar map__28756 \x3d cljs.core.deref(state_ref);\nvar map__28756__$1 \x3d cljs.core.__destructure_map(map__28756);\nvar ws_state \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28756__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-state\x22,\x22shadow.cljs.devtools.client.shared/ws-state\x22,1653373656));\nvar ws_stop_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28756__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-stop-fn\x22,\x22shadow.cljs.devtools.client.shared/ws-stop-fn\x22,88454255));\nvar interval \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28756__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22interval\x22,\x22shadow.cljs.devtools.client.shared/interval\x22,-2112273585));\nvar plugins \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28756__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855));\nclearInterval(interval);\n\nif((!((ws_state \x3d\x3d null)))){\n(ws_stop_fn.cljs$core$IFn$_invoke$arity$1 ? ws_stop_fn.cljs$core$IFn$_invoke$arity$1(ws_state) : ws_stop_fn.call(null, ws_state));\n} else {\n}\n\ncljs.core.reduce_kv((function (_,plugin_id,started){\nvar map__28757 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(shadow.cljs.devtools.client.shared.plugins_ref),plugin_id);\nvar map__28757__$1 \x3d cljs.core.__destructure_map(map__28757);\nvar stop_fn \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28757__$1,new cljs.core.Keyword(null,\x22stop-fn\x22,\x22stop-fn\x22,-348472246));\nreturn (stop_fn.cljs$core$IFn$_invoke$arity$1 ? stop_fn.cljs$core$IFn$_invoke$arity$1(started) : stop_fn.call(null, started));\n}),null,plugins);\n\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22shutdown\x22,\x22shadow.cljs.devtools.client.shared/shutdown\x22,1947481008),true);\n});\nshadow.cljs.devtools.client.shared.init_runtime_BANG_ \x3d (function shadow$cljs$devtools$client$shared$init_runtime_BANG_(client_info,ws_start_fn,ws_send_fn,ws_stop_fn){\nvar temp__5808__auto___29003 \x3d cljs.core.deref(shadow.cljs.devtools.client.shared.runtime_ref);\nif((temp__5808__auto___29003 \x3d\x3d null)){\n} else {\nvar runtime_29004 \x3d temp__5808__auto___29003;\nshadow.cljs.devtools.client.shared.stop_runtime_BANG_(runtime_29004);\n\ncljs.core.reset_BANG_(shadow.cljs.devtools.client.shared.runtime_ref,null);\n}\n\nshadow.cljs.devtools.client.shared.add_plugin_BANG_(new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229),cljs.core.PersistentHashSet.EMPTY,(function (p1__28758_SHARP_){\nreturn shadow.remote.runtime.obj_support.start(new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996).cljs$core$IFn$_invoke$arity$1(p1__28758_SHARP_));\n}),shadow.remote.runtime.obj_support.stop);\n\nshadow.cljs.devtools.client.shared.add_plugin_BANG_(new cljs.core.Keyword(null,\x22tap-support\x22,\x22tap-support\x22,80346439),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229),null], null), null),(function (p__28769){\nvar map__28771 \x3d p__28769;\nvar map__28771__$1 \x3d cljs.core.__destructure_map(map__28771);\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28771__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar obj_support \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28771__$1,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229));\nreturn shadow.remote.runtime.tap_support.start(runtime,obj_support);\n}),shadow.remote.runtime.tap_support.stop);\n\nshadow.cljs.devtools.client.shared.add_plugin_BANG_(new cljs.core.Keyword(null,\x22eval-support\x22,\x22eval-support\x22,-1581799533),new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229),null], null), null),(function (p__28772){\nvar map__28773 \x3d p__28772;\nvar map__28773__$1 \x3d cljs.core.__destructure_map(map__28773);\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28773__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar obj_support \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28773__$1,new cljs.core.Keyword(null,\x22obj-support\x22,\x22obj-support\x22,1522559229));\nreturn shadow.remote.runtime.eval_support.start(runtime,obj_support);\n}),shadow.remote.runtime.eval_support.stop);\n\nvar state_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(shadow.remote.runtime.shared.init_state(cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(client_info,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22lang\x22,\x22lang\x22,-1819677104),new cljs.core.Keyword(null,\x22cljs\x22,\x22cljs\x22,1492417629),new cljs.core.Keyword(null,\x22build-id\x22,\x22build-id\x22,1642831089),cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.env.build_id),new cljs.core.Keyword(null,\x22worker-id\x22,\x22worker-id\x22,644510040),shadow.cljs.devtools.client.env.worker_client_id,new cljs.core.Keyword(null,\x22proc-id\x22,\x22proc-id\x22,-1856109278),shadow.cljs.devtools.client.env.proc_id], 0))),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22shutdown\x22,\x22shadow.cljs.devtools.client.shared/shutdown\x22,1947481008),false,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22stale\x22,\x22shadow.cljs.devtools.client.shared/stale\x22,-1017562082),false,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22plugins\x22,\x22shadow.cljs.devtools.client.shared/plugins\x22,1565262855),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-errors\x22,\x22shadow.cljs.devtools.client.shared/ws-errors\x22,105464879),(0),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22transit-writers\x22,\x22shadow.cljs.devtools.client.shared/transit-writers\x22,-776127897),cljs.core.PersistentArrayMap.EMPTY,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22transit-readers\x22,\x22shadow.cljs.devtools.client.shared/transit-readers\x22,-1866893537),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22default\x22,\x22default\x22,-1987822328),cljs.core.tagged_literal], null),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-start-fn\x22,\x22shadow.cljs.devtools.client.shared/ws-start-fn\x22,-49893682),ws_start_fn,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-send-fn\x22,\x22shadow.cljs.devtools.client.shared/ws-send-fn\x22,-1986889866),ws_send_fn,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-stop-fn\x22,\x22shadow.cljs.devtools.client.shared/ws-stop-fn\x22,88454255),ws_stop_fn], 0)));\nvar runtime \x3d (function (){var G__28774 \x3d shadow.cljs.devtools.client.shared.__GT_Runtime(state_ref);\nshadow.remote.runtime.shared.add_defaults(G__28774);\n\nreturn G__28774;\n})();\nvar idle_fn \x3d (function (){\nvar map__28775 \x3d cljs.core.deref(state_ref);\nvar map__28775__$1 \x3d cljs.core.__destructure_map(map__28775);\nvar state \x3d map__28775__$1;\nvar shutdown \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28775__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22shutdown\x22,\x22shadow.cljs.devtools.client.shared/shutdown\x22,1947481008));\nvar ws_connected \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28775__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connected\x22,\x22shadow.cljs.devtools.client.shared/ws-connected\x22,-1476385853));\nvar ws_last_msg \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28775__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-last-msg\x22,\x22shadow.cljs.devtools.client.shared/ws-last-msg\x22,-1438906782));\nvar ws_connect_timeout \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28775__$1,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connect-timeout\x22,\x22shadow.cljs.devtools.client.shared/ws-connect-timeout\x22,1477702043));\nif(cljs.core.truth_((function (){var and__5000__auto__ \x3d cljs.core.not(ws_connect_timeout);\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d cljs.core.not(shutdown);\nif(and__5000__auto____$1){\nvar and__5000__auto____$2 \x3d ws_connected;\nif(cljs.core.truth_(and__5000__auto____$2)){\nreturn (shadow.remote.runtime.shared.now() \x3e (ws_last_msg + (20000)));\n} else {\nreturn and__5000__auto____$2;\n}\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n})())){\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(state_ref,cljs.core.dissoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22ws-connected\x22,\x22shadow.cljs.devtools.client.shared/ws-connected\x22,-1476385853));\n\nruntime.schedule_connect_BANG_((2000));\n} else {\n}\n\nreturn shadow.remote.runtime.shared.run_on_idle(state_ref);\n});\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(state_ref,cljs.core.assoc,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22interval\x22,\x22shadow.cljs.devtools.client.shared/interval\x22,-2112273585),setInterval(idle_fn,(1000)));\n\ncljs.core.reset_BANG_(shadow.cljs.devtools.client.shared.runtime_ref,runtime);\n\n(goog.global.cljs_eval \x3d (function (input,opts){\nvar input__$1 \x3d ((cljs.core.map_QMARK_(input))?input:((((typeof input \x3d\x3d\x3d \x27string\x27) \x26\x26 (cljs.core.not(opts))))?new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22code\x22,\x22code\x22,1586293142),input,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),new cljs.core.Symbol(null,\x22cljs.user\x22,\x22cljs.user\x22,877795071,null)], null):((((typeof input \x3d\x3d\x3d \x27string\x27) \x26\x26 (cljs.core.object_QMARK_(opts))))?new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22code\x22,\x22code\x22,1586293142),input,new cljs.core.Keyword(null,\x22ns\x22,\x22ns\x22,441598760),cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.shared.goog$module$goog$object.get(opts,\x22ns\x22))], null):(function(){throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(\x22invalid arguments, call cljs_eval(string, opts-obj) or cljs_eval(map)\x22,new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22input\x22,\x22input\x22,556931961),input,new cljs.core.Keyword(null,\x22opts\x22,\x22opts\x22,155075701),opts], null))})()\n)));\nreturn (new Promise((function (resolve,reject){\nreturn shadow.remote.runtime.api.cljs_eval(runtime,input__$1,(function (p__28778){\nvar map__28779 \x3d p__28778;\nvar map__28779__$1 \x3d cljs.core.__destructure_map(map__28779);\nvar info \x3d map__28779__$1;\nvar result \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28779__$1,new cljs.core.Keyword(null,\x22result\x22,\x22result\x22,1415092211));\nvar results \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28779__$1,new cljs.core.Keyword(null,\x22results\x22,\x22results\x22,-1134170113));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22ok\x22,\x22ok\x22,967785236),result)){\nvar G__28781 \x3d cljs.core.last(results);\nreturn (resolve.cljs$core$IFn$_invoke$arity$1 ? resolve.cljs$core$IFn$_invoke$arity$1(G__28781) : resolve.call(null, G__28781));\n} else {\nreturn (reject.cljs$core$IFn$_invoke$arity$1 ? reject.cljs$core$IFn$_invoke$arity$1(info) : reject.call(null, info));\n}\n}));\n})));\n}));\n\nruntime.shadow$remote$runtime$api$IRuntime$add_extension$arity$3(null, new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22print-support\x22,\x22shadow.cljs.devtools.client.shared/print-support\x22,-1090548637),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22runtime-print-sub\x22,\x22runtime-print-sub\x22,1832904759),(function (p__28783){\nvar map__28784 \x3d p__28783;\nvar map__28784__$1 \x3d cljs.core.__destructure_map(map__28784);\nvar msg \x3d map__28784__$1;\nvar from \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28784__$1,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044));\ncljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(shadow.cljs.devtools.client.shared.print_subs,cljs.core.conj,from);\n\nreturn shadow.remote.runtime.shared.relay_msg(runtime,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22request-notify\x22,\x22request-notify\x22,351029173),new cljs.core.Keyword(null,\x22notify-op\x22,\x22notify-op\x22,1568109361),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22runtime-print-disconnect\x22,\x22shadow.cljs.devtools.client.shared/runtime-print-disconnect\x22,2030167412),new cljs.core.Keyword(null,\x22query\x22,\x22query\x22,-1288509510),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22eq\x22,\x22eq\x22,-618539067),new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140),from], null)], null));\n}),new cljs.core.Keyword(null,\x22runtime-print-unsub\x22,\x22runtime-print-unsub\x22,2055442536),(function (p__28785){\nvar map__28786 \x3d p__28785;\nvar map__28786__$1 \x3d cljs.core.__destructure_map(map__28786);\nvar msg \x3d map__28786__$1;\nvar from \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28786__$1,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(shadow.cljs.devtools.client.shared.print_subs,cljs.core.disj,from);\n}),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22runtime-print-disconnect\x22,\x22shadow.cljs.devtools.client.shared/runtime-print-disconnect\x22,2030167412),(function (p__28787){\nvar map__28788 \x3d p__28787;\nvar map__28788__$1 \x3d cljs.core.__destructure_map(map__28788);\nvar event_op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28788__$1,new cljs.core.Keyword(null,\x22event-op\x22,\x22event-op\x22,200358057));\nvar client_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28788__$1,new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140));\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22client-disconnect\x22,\x22client-disconnect\x22,640227957),event_op)){\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(shadow.cljs.devtools.client.shared.print_subs,cljs.core.disj,client_id);\n} else {\nreturn null;\n}\n})], null),new cljs.core.Keyword(null,\x22on-client-not-found\x22,\x22on-client-not-found\x22,-642452849),(function (p__28789){\nvar map__28790 \x3d p__28789;\nvar map__28790__$1 \x3d cljs.core.__destructure_map(map__28790);\nvar client_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28790__$1,new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140));\nreturn cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(shadow.cljs.devtools.client.shared.print_subs,cljs.core.disj,client_id);\n})], null));\n\nshadow.cljs.devtools.client.env.reset_print_fns_BANG_();\n\nshadow.cljs.devtools.client.env.set_print_fns_BANG_((function (stream,text){\nvar subs \x3d cljs.core.deref(shadow.cljs.devtools.client.shared.print_subs);\nif(cljs.core.seq(subs)){\nreturn shadow.remote.runtime.shared.relay_msg(runtime,new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22runtime-print\x22,\x22runtime-print\x22,-1950604603),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),subs,new cljs.core.Keyword(null,\x22stream\x22,\x22stream\x22,1534941648),stream,new cljs.core.Keyword(null,\x22text\x22,\x22text\x22,-1790561697),text], null));\n} else {\nreturn null;\n}\n}));\n\nruntime.shadow$remote$runtime$api$IRuntime$add_extension$arity$3(null, new cljs.core.Keyword(\x22shadow.cljs.devtools.client.shared\x22,\x22shared\x22,\x22shadow.cljs.devtools.client.shared/shared\x22,85374117),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22on-welcome\x22,\x22on-welcome\x22,1895317125),(function (){\nreturn shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$3(runtime,new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22request-clients\x22,\x22request-clients\x22,13229886),new cljs.core.Keyword(null,\x22notify\x22,\x22notify\x22,-1256867814),true,new cljs.core.Keyword(null,\x22notify-op\x22,\x22notify-op\x22,1568109361),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.env\x22,\x22worker-notify\x22,\x22shadow.cljs.devtools.client.env/worker-notify\x22,-1456820670),new cljs.core.Keyword(null,\x22query\x22,\x22query\x22,-1288509510),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22eq\x22,\x22eq\x22,-618539067),new cljs.core.Keyword(\x22shadow.cljs\x22,\x22worker-for\x22,\x22shadow.cljs/worker-for\x22,-574470432),cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.env.build_id)], null)], null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22clients\x22,\x22clients\x22,1436018090),(function (p__28799){\nvar map__28800 \x3d p__28799;\nvar map__28800__$1 \x3d cljs.core.__destructure_map(map__28800);\nvar msg \x3d map__28800__$1;\nvar clients \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28800__$1,new cljs.core.Keyword(null,\x22clients\x22,\x22clients\x22,1436018090));\nif(cljs.core.not(cljs.core.seq(clients))){\nreturn console.error([\x22shadow-cljs watch for build :\x22,shadow.cljs.devtools.client.env.build_id,\x22 not running!\x22].join(\x27\x27));\n} else {\nvar worker \x3d cljs.core.first(clients);\nvar map__28805 \x3d worker;\nvar map__28805__$1 \x3d cljs.core.__destructure_map(map__28805);\nvar client_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__28805__$1,new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140));\nif(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(client_id,shadow.cljs.devtools.client.env.worker_client_id)){\nconsole.warn(\x22shadow-cljs worker id outdated! This can mean that the JS loaded is outdated! Ensure that the shadow-cljs output is not cached. If other tools process this output make sure they update correctly. The code may continue to run fine, but if unexplained things happen make sure to fix this first.\x22);\n\nreturn (shadow.cljs.devtools.client.env.worker_client_id \x3d client_id);\n} else {\nreturn null;\n}\n}\n})], null));\n})], null));\n\nshadow.cljs.devtools.client.shared.start_all_plugins_BANG_(runtime);\n\nreturn runtime.attempt_connect_BANG_();\n});\n");
SHADOW_ENV.evalLoad("shadow.cljs.devtools.client.hud.js", true, "goog.provide(\x27shadow.cljs.devtools.client.hud\x27);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.hud.show_progress \x3d goog.define(\x22shadow.cljs.devtools.client.hud.show_progress\x22,true);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.hud.show_warnings \x3d goog.define(\x22shadow.cljs.devtools.client.hud.show_warnings\x22,true);\n/**\n * @define {boolean}\n */\nshadow.cljs.devtools.client.hud.show_errors \x3d goog.define(\x22shadow.cljs.devtools.client.hud.show_errors\x22,true);\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.hud !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.hud.dom_available_QMARK_ !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.hud.dom_available_QMARK_ \x3d (!((goog.global.document \x3d\x3d null)));\n}\nshadow.cljs.devtools.client.hud.open_file \x3d (function shadow$cljs$devtools$client$hud$open_file(file,line,column){\nconsole.log(\x22opening file\x22,file,line,column);\n\nreturn fetch([shadow.cljs.devtools.client.env.get_url_base(),\x22/api/open-file\x22].join(\x27\x27),({\x22method\x22: \x22POST\x22, \x22cache\x22: \x22no-cache\x22, \x22mode\x22: \x22cors\x22, \x22body\x22: shadow.cljs.devtools.client.shared.transit_str(cljs.core.PersistentArrayMap.EMPTY,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22file\x22,\x22file\x22,-1269645878),file,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235),line,new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095),column], null))})).then((function (p1__28917_SHARP_){\nreturn p1__28917_SHARP_.text();\n})).then((function (result_text){\nvar data \x3d shadow.cljs.devtools.client.shared.transit_read(cljs.core.PersistentArrayMap.EMPTY,result_text);\nreturn console.log(\x22open file result\x22,data);\n}));\n});\nshadow.cljs.devtools.client.hud.dom_insert \x3d (function shadow$cljs$devtools$client$hud$dom_insert(var_args){\nvar G__28931 \x3d arguments.length;\nswitch (G__28931) {\ncase 1:\nreturn shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$1 \x3d (function (node){\nreturn shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$2(document.body,node);\n}));\n\n(shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$2 \x3d (function (where,node){\nvar el \x3d shadow.dom.dom_node(node);\nvar id \x3d el.id;\nif(cljs.core.seq(id)){\n} else {\nthrow (new Error(\x22Assert failed: (seq id)\x22));\n}\n\nvar temp__5808__auto___29083 \x3d shadow.dom.by_id.cljs$core$IFn$_invoke$arity$1(id);\nif((temp__5808__auto___29083 \x3d\x3d null)){\n} else {\nvar x_29084 \x3d temp__5808__auto___29083;\nshadow.dom.remove(x_29084);\n}\n\nreturn shadow.dom.append.cljs$core$IFn$_invoke$arity$2(where,el);\n}));\n\n(shadow.cljs.devtools.client.hud.dom_insert.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.cljs.devtools.client.hud.hud_id \x3d \x22shadow-hud-container\x22;\nshadow.cljs.devtools.client.hud.load_id \x3d \x22shadow-hud-loading-container\x22;\nshadow.cljs.devtools.client.hud.logo_svg \x3d (new cljs.core.Delay((function (){\nvar s_path \x3d \x22M247.183941,141.416413 C247.183941,74.7839971 148.383423,78.9723529 148.383423,141.416413 C148.383423,203.860473 265.090698,171.864644 265.090698,248.900057 C265.090698,325.93547 135,325.851749 135,251.708304\x22;\nreturn shadow.dom.svg.cljs$core$IFn$_invoke$arity$variadic(new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),\x22shadow-cljs-logo\x22,new cljs.core.Keyword(null,\x22version\x22,\x22version\x22,425292698),\x221.1\x22,new cljs.core.Keyword(null,\x22viewBox\x22,\x22viewBox\x22,-469489477),\x220 0 400 400\x22,new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22display\x22,\x22display\x22,242065432),\x22block\x22], null),new cljs.core.Keyword(null,\x22height\x22,\x22height\x22,1025178622),\x2260px\x22,new cljs.core.Keyword(null,\x22width\x22,\x22width\x22,-384071477),\x2260px\x22], null),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22title\x22,\x22title\x22,636505583),\x22shadow-cljs\x22], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22defs\x22,\x22defs\x22,1398449717),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22mask#shadow-cljs-logo-mask\x22,\x22mask#shadow-cljs-logo-mask\x22,1690487509),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),\x22#fff\x22], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22circle\x22,\x22circle\x22,1903212362),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22r\x22,\x22r\x22,-471384190),\x22200\x22,new cljs.core.Keyword(null,\x22cy\x22,\x22cy\x22,755331060),\x22200\x22,new cljs.core.Keyword(null,\x22cx\x22,\x22cx\x22,1272694324),\x22200\x22], null)], null)], null)], null),new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22g\x22,\x22g\x22,1738089905),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22fill-rule\x22,\x22fill-rule\x22,-1824841598),\x22evenodd\x22,new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),\x22none\x22,new cljs.core.Keyword(null,\x22stroke-width\x22,\x22stroke-width\x22,716836435),\x220\x22,new cljs.core.Keyword(null,\x22stroke\x22,\x22stroke\x22,1741823555),\x22none\x22,new cljs.core.Keyword(null,\x22mask\x22,\x22mask\x22,-585748447),\x22url(#shadow-cljs-logo-mask)\x22], null),new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22g.circles\x22,\x22g.circles\x22,374463200),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22circle.blue\x22,\x22circle.blue\x22,1902916291),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22r\x22,\x22r\x22,-471384190),\x22200\x22,new cljs.core.Keyword(null,\x22cy\x22,\x22cy\x22,755331060),\x22200\x22,new cljs.core.Keyword(null,\x22cx\x22,\x22cx\x22,1272694324),\x22200\x22,new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),\x22#4F80DF\x22], null)], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22circle.light-blue\x22,\x22circle.light-blue\x22,438137342),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22r\x22,\x22r\x22,-471384190),\x2271.5\x22,new cljs.core.Keyword(null,\x22cy\x22,\x22cy\x22,755331060),\x22200\x22,new cljs.core.Keyword(null,\x22cx\x22,\x22cx\x22,1272694324),\x22370\x22,new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),\x22#89B4FF\x22], null)], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22circle.dark-green\x22,\x22circle.dark-green\x22,608465767),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22r\x22,\x22r\x22,-471384190),\x22180\x22,new cljs.core.Keyword(null,\x22cy\x22,\x22cy\x22,755331060),\x22360\x22,new cljs.core.Keyword(null,\x22cx\x22,\x22cx\x22,1272694324),\x2260\x22,new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),\x22#40B400\x22], null)], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22circle.light-green\x22,\x22circle.light-green\x22,-1663041285),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22r\x22,\x22r\x22,-471384190),\x22129\x22,new cljs.core.Keyword(null,\x22cy\x22,\x22cy\x22,755331060),\x22320\x22,new cljs.core.Keyword(null,\x22cx\x22,\x22cx\x22,1272694324),\x22280\x22,new cljs.core.Keyword(null,\x22fill\x22,\x22fill\x22,883462889),\x22#76E013\x22], null)], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22animateTransform\x22,\x22animateTransform\x22,759329815),new cljs.core.PersistentArrayMap(null, 7, [new cljs.core.Keyword(null,\x22attributeType\x22,\x22attributeType\x22,1055561918),\x22xml\x22,new cljs.core.Keyword(null,\x22attributeName\x22,\x22attributeName\x22,-400177890),\x22transform\x22,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),\x22rotate\x22,new cljs.core.Keyword(null,\x22from\x22,\x22from\x22,1815293044),\x220 200 200\x22,new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),\x22360 200 200\x22,new cljs.core.Keyword(null,\x22dur\x22,\x22dur\x22,1464522452),\x223s\x22,new cljs.core.Keyword(null,\x22repeatCount\x22,\x22repeatCount\x22,1447663848),\x22indefinite\x22], null)], null)], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22g\x22,\x22g\x22,1738089905),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22transform\x22,\x22transform\x22,1381301764),\x22translate(10,10)\x22], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22stroke-linecap\x22,\x22stroke-linecap\x22,-1201103248),\x22square\x22,new cljs.core.Keyword(null,\x22stroke-width\x22,\x22stroke-width\x22,716836435),\x2216\x22,new cljs.core.Keyword(null,\x22stroke\x22,\x22stroke\x22,1741823555),\x22#aaa\x22,new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424),s_path], null)], null)], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22path\x22,\x22path\x22,-188191168),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22stroke-linecap\x22,\x22stroke-linecap\x22,-1201103248),\x22square\x22,new cljs.core.Keyword(null,\x22stroke-width\x22,\x22stroke-width\x22,716836435),\x2216\x22,new cljs.core.Keyword(null,\x22stroke\x22,\x22stroke\x22,1741823555),\x22#FFFFFF\x22,new cljs.core.Keyword(null,\x22d\x22,\x22d\x22,1972142424),s_path], null)], null)], null)], 0));\n}),null));\nshadow.cljs.devtools.client.hud.load_start \x3d (function shadow$cljs$devtools$client$hud$load_start(){\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nif(shadow.cljs.devtools.client.hud.show_progress){\nreturn shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),shadow.cljs.devtools.client.hud.load_id,new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22position\x22,\x22position\x22,-2011731912),\x22fixed\x22,new cljs.core.Keyword(null,\x22pointer-events\x22,\x22pointer-events\x22,-1053858853),\x22none\x22,new cljs.core.Keyword(null,\x22left\x22,\x22left\x22,-399115937),\x220px\x22,new cljs.core.Keyword(null,\x22bottom\x22,\x22bottom\x22,-1550509018),\x2220px\x22,new cljs.core.Keyword(null,\x22z-index\x22,\x22z-index\x22,1892827090),\x2210000\x22], null)], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22background\x22,\x22background\x22,-863952629),\x22#eee\x22,new cljs.core.Keyword(null,\x22border-top-right-radius\x22,\x22border-top-right-radius\x22,1678770792),\x2240px\x22,new cljs.core.Keyword(null,\x22border-bottom-right-radius\x22,\x22border-bottom-right-radius\x22,414899772),\x2240px\x22,new cljs.core.Keyword(null,\x22box-shadow\x22,\x22box-shadow\x22,1600206755),\x222px 2px 10px #aaa\x22,new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),\x2210px\x22], null)], null),cljs.core.deref(shadow.cljs.devtools.client.hud.logo_svg)], null)], null));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.load_end_success \x3d (function shadow$cljs$devtools$client$hud$load_end_success(){\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nif(shadow.cljs.devtools.client.hud.show_progress){\nvar temp__5808__auto__ \x3d shadow.dom.by_id.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.hud.load_id);\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar container_el \x3d temp__5808__auto__;\nvar el \x3d container_el.firstChild;\nshadow.animate.start((500),cljs.core.PersistentArrayMap.createAsIfByAssoc([el,shadow.animate.transition.cljs$core$IFn$_invoke$arity$4(new cljs.core.Keyword(null,\x22background\x22,\x22background\x22,-863952629),\x22#eee\x22,\x22#40B400\x22,\x22ease-out\x22)]));\n\nvar c__22634__auto__ \x3d cljs.core.async.chan.cljs$core$IFn$_invoke$arity$1((1));\ncljs.core.async.impl.dispatch.run((function (){\nvar f__22635__auto__ \x3d (function (){var switch__21554__auto__ \x3d (function (state_28979){\nvar state_val_28980 \x3d (state_28979[(1)]);\nif((state_val_28980 \x3d\x3d\x3d (1))){\nvar inst_28960 \x3d cljs.core.async.timeout((250));\nvar state_28979__$1 \x3d state_28979;\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_28979__$1,(2),inst_28960);\n} else {\nif((state_val_28980 \x3d\x3d\x3d (2))){\nvar inst_28962 \x3d (state_28979[(2)]);\nvar inst_28965 \x3d [el];\nvar inst_28967 \x3d shadow.animate.transition.cljs$core$IFn$_invoke$arity$4(new cljs.core.Keyword(null,\x22opacity\x22,\x22opacity\x22,397153780),\x221\x22,\x220\x22,\x22ease-in\x22);\nvar inst_28968 \x3d [inst_28967];\nvar inst_28969 \x3d cljs.core.PersistentHashMap.fromArrays(inst_28965,inst_28968);\nvar inst_28970 \x3d shadow.animate.start((250),inst_28969);\nvar state_28979__$1 \x3d (function (){var statearr_28990 \x3d state_28979;\n(statearr_28990[(7)] \x3d inst_28962);\n\nreturn statearr_28990;\n})();\nreturn cljs.core.async.impl.ioc_helpers.take_BANG_(state_28979__$1,(3),inst_28970);\n} else {\nif((state_val_28980 \x3d\x3d\x3d (3))){\nvar inst_28972 \x3d (state_28979[(2)]);\nvar inst_28973 \x3d shadow.dom.remove(container_el);\nvar state_28979__$1 \x3d (function (){var statearr_28995 \x3d state_28979;\n(statearr_28995[(8)] \x3d inst_28972);\n\nreturn statearr_28995;\n})();\nreturn cljs.core.async.impl.ioc_helpers.return_chan(state_28979__$1,inst_28973);\n} else {\nreturn null;\n}\n}\n}\n});\nreturn (function() {\nvar shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto__ \x3d null;\nvar shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto____0 \x3d (function (){\nvar statearr_29002 \x3d [null,null,null,null,null,null,null,null,null];\n(statearr_29002[(0)] \x3d shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto__);\n\n(statearr_29002[(1)] \x3d (1));\n\nreturn statearr_29002;\n});\nvar shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto____1 \x3d (function (state_28979){\nwhile(true){\nvar ret_value__21556__auto__ \x3d (function (){try{while(true){\nvar result__21557__auto__ \x3d switch__21554__auto__(state_28979);\nif(cljs.core.keyword_identical_QMARK_(result__21557__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\ncontinue;\n} else {\nreturn result__21557__auto__;\n}\nbreak;\n}\n}catch (e29005){var ex__21558__auto__ \x3d e29005;\nvar statearr_29008_29085 \x3d state_28979;\n(statearr_29008_29085[(2)] \x3d ex__21558__auto__);\n\n\nif(cljs.core.seq((state_28979[(4)]))){\nvar statearr_29009_29086 \x3d state_28979;\n(statearr_29009_29086[(1)] \x3d cljs.core.first((state_28979[(4)])));\n\n} else {\nthrow ex__21558__auto__;\n}\n\nreturn new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268);\n}})();\nif(cljs.core.keyword_identical_QMARK_(ret_value__21556__auto__,new cljs.core.Keyword(null,\x22recur\x22,\x22recur\x22,-437573268))){\nvar G__29087 \x3d state_28979;\nstate_28979 \x3d G__29087;\ncontinue;\n} else {\nreturn ret_value__21556__auto__;\n}\nbreak;\n}\n});\nshadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto__ \x3d function(state_28979){\nswitch(arguments.length){\ncase 0:\nreturn shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto____0.call(this);\ncase 1:\nreturn shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto____1.call(this,state_28979);\n}\nthrow(new Error(\x27Invalid arity: \x27 + arguments.length));\n};\nshadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$0 \x3d shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto____0;\nshadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto__.cljs$core$IFn$_invoke$arity$1 \x3d shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto____1;\nreturn shadow$cljs$devtools$client$hud$load_end_success_$_state_machine__21555__auto__;\n})()\n})();\nvar state__22636__auto__ \x3d (function (){var statearr_29015 \x3d f__22635__auto__();\n(statearr_29015[(6)] \x3d c__22634__auto__);\n\nreturn statearr_29015;\n})();\nreturn cljs.core.async.impl.ioc_helpers.run_state_machine_wrapped(state__22636__auto__);\n}));\n\nreturn c__22634__auto__;\n}\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.load_end \x3d (function shadow$cljs$devtools$client$hud$load_end(){\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nvar temp__5808__auto__ \x3d shadow.dom.by_id.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.hud.load_id);\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar el \x3d temp__5808__auto__;\nreturn shadow.dom.remove(el);\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.hud_hide \x3d (function shadow$cljs$devtools$client$hud$hud_hide(){\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nvar temp__5808__auto__ \x3d shadow.dom.by_id.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.hud.hud_id);\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar d \x3d temp__5808__auto__;\nreturn shadow.dom.remove(d);\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.source_line_styles \x3d new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),\x220\x22,new cljs.core.Keyword(null,\x22margin\x22,\x22margin\x22,-995903681),\x220\x22], null);\nshadow.cljs.devtools.client.hud.source_highlight_styles \x3d cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(shadow.cljs.devtools.client.hud.source_line_styles,new cljs.core.Keyword(null,\x22font-weight\x22,\x22font-weight\x22,2085804583),\x22bold\x22);\nshadow.cljs.devtools.client.hud.source_line_html \x3d (function shadow$cljs$devtools$client$hud$source_line_html(start_idx,lines,styles){\nvar iter__5480__auto__ \x3d (function shadow$cljs$devtools$client$hud$source_line_html_$_iter__29035(s__29036){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__29036__$1 \x3d s__29036;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__29036__$1);\nif(temp__5804__auto__){\nvar s__29036__$2 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(s__29036__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__29036__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__29038 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__29037 \x3d (0);\nwhile(true){\nif((i__29037 \x3c size__5479__auto__)){\nvar vec__29042 \x3d cljs.core._nth(c__5478__auto__,i__29037);\nvar idx \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__29042,(0),null);\nvar text \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__29042,(1),null);\ncljs.core.chunk_append(b__29038,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22pre\x22,\x22pre\x22,2118456869),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),styles], null),goog.string.format(\x22%4d | %s\x22,(((1) + idx) + start_idx),text)], null));\n\nvar G__29088 \x3d (i__29037 + (1));\ni__29037 \x3d G__29088;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__29038),shadow$cljs$devtools$client$hud$source_line_html_$_iter__29035(cljs.core.chunk_rest(s__29036__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__29038),null);\n}\n} else {\nvar vec__29045 \x3d cljs.core.first(s__29036__$2);\nvar idx \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__29045,(0),null);\nvar text \x3d cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__29045,(1),null);\nreturn cljs.core.cons(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22pre\x22,\x22pre\x22,2118456869),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),styles], null),goog.string.format(\x22%4d | %s\x22,(((1) + idx) + start_idx),text)], null),shadow$cljs$devtools$client$hud$source_line_html_$_iter__29035(cljs.core.rest(s__29036__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2(cljs.core.vector,lines));\n});\nshadow.cljs.devtools.client.hud.sep_length \x3d (80);\nshadow.cljs.devtools.client.hud.sep_line \x3d (function shadow$cljs$devtools$client$hud$sep_line(var_args){\nvar G__29049 \x3d arguments.length;\nswitch (G__29049) {\ncase 0:\nreturn shadow.cljs.devtools.client.hud.sep_line.cljs$core$IFn$_invoke$arity$0();\n\nbreak;\ncase 2:\nreturn shadow.cljs.devtools.client.hud.sep_line.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.cljs.devtools.client.hud.sep_line.cljs$core$IFn$_invoke$arity$0 \x3d (function (){\nreturn shadow.cljs.devtools.client.hud.sep_line.cljs$core$IFn$_invoke$arity$2(\x22\x22,(0));\n}));\n\n(shadow.cljs.devtools.client.hud.sep_line.cljs$core$IFn$_invoke$arity$2 \x3d (function (label,offset){\nvar sep_len \x3d Math.max(shadow.cljs.devtools.client.hud.sep_length,offset);\nvar len \x3d cljs.core.count(label);\nvar sep \x3d (function (c){\nreturn clojure.string.join.cljs$core$IFn$_invoke$arity$2(\x22\x22,cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(c,\x22-\x22));\n});\nreturn [sep(offset),cljs.core.str.cljs$core$IFn$_invoke$arity$1(label),sep((sep_len - (offset + len)))].join(\x27\x27);\n}));\n\n(shadow.cljs.devtools.client.hud.sep_line.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.cljs.devtools.client.hud.file_link \x3d (function shadow$cljs$devtools$client$hud$file_link(p__29051){\nvar map__29052 \x3d p__29051;\nvar map__29052__$1 \x3d cljs.core.__destructure_map(map__29052);\nvar warning \x3d map__29052__$1;\nvar resource_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29052__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nvar file \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29052__$1,new cljs.core.Keyword(null,\x22file\x22,\x22file\x22,-1269645878));\nvar line \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29052__$1,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235));\nvar column \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29052__$1,new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095));\nif(cljs.core.not(file)){\nreturn new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),resource_name], null);\n} else {\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22text-decoration\x22,\x22text-decoration\x22,1836813207),\x22underline\x22,new cljs.core.Keyword(null,\x22color\x22,\x22color\x22,1011675173),\x22blue\x22,new cljs.core.Keyword(null,\x22cursor\x22,\x22cursor\x22,1011937484),\x22pointer\x22], null),new cljs.core.Keyword(null,\x22on\x22,\x22on\x22,173873944),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22click\x22,\x22click\x22,1912301393),(function (e){\nshadow.dom.ev_stop.cljs$core$IFn$_invoke$arity$1(e);\n\nreturn shadow.cljs.devtools.client.hud.open_file(file,line,column);\n})], null)], null),resource_name], null);\n}\n});\nshadow.cljs.devtools.client.hud.html_for_warning \x3d (function shadow$cljs$devtools$client$hud$html_for_warning(p__29058){\nvar map__29059 \x3d p__29058;\nvar map__29059__$1 \x3d cljs.core.__destructure_map(map__29059);\nvar warning \x3d map__29059__$1;\nvar resource_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29059__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nvar msg \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29059__$1,new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444));\nvar file \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29059__$1,new cljs.core.Keyword(null,\x22file\x22,\x22file\x22,-1269645878));\nvar line \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29059__$1,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235));\nvar column \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29059__$1,new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095));\nvar source_excerpt \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29059__$1,new cljs.core.Keyword(null,\x22source-excerpt\x22,\x22source-excerpt\x22,5665576));\nreturn new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22border\x22,\x22border\x22,1444987323),\x222px solid #ccc\x22,new cljs.core.Keyword(null,\x22margin-bottom\x22,\x22margin-bottom\x22,388334941),\x2210px\x22], null)], null),new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22line-height\x22,\x22line-height\x22,1870784992),\x2216px\x22,new cljs.core.Keyword(null,\x22background-color\x22,\x22background-color\x22,570434026),\x22#fadb64\x22,new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),\x2210px\x22,new cljs.core.Keyword(null,\x22font-size\x22,\x22font-size\x22,-1847940346),\x221.2em\x22,new cljs.core.Keyword(null,\x22font-weight\x22,\x22font-weight\x22,2085804583),\x22bold\x22], null)], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22span\x22,\x22span\x22,1394872991),\x22WARNING in \x22], null),shadow.cljs.devtools.client.hud.file_link(warning)], null),(cljs.core.truth_(source_excerpt)?(function (){var map__29068 \x3d source_excerpt;\nvar map__29068__$1 \x3d cljs.core.__destructure_map(map__29068);\nvar start_idx \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29068__$1,new cljs.core.Keyword(null,\x22start-idx\x22,\x22start-idx\x22,-1600773745));\nvar before \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29068__$1,new cljs.core.Keyword(null,\x22before\x22,\x22before\x22,-1633692388));\nvar line__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29068__$1,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235));\nvar after \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29068__$1,new cljs.core.Keyword(null,\x22after\x22,\x22after\x22,594996914));\nreturn new cljs.core.PersistentVector(null, 8, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),\x2210px 10px\x22,new cljs.core.Keyword(null,\x22background-color\x22,\x22background-color\x22,570434026),\x22#fff\x22,new cljs.core.Keyword(null,\x22border-top\x22,\x22border-top\x22,-158897573),\x222px solid #ccc\x22], null)], null),shadow.cljs.devtools.client.hud.source_line_html(start_idx,before,shadow.cljs.devtools.client.hud.source_line_styles),shadow.cljs.devtools.client.hud.source_line_html((start_idx + cljs.core.count(before)),new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [line__$1], null),shadow.cljs.devtools.client.hud.source_highlight_styles),(function (){var arrow_idx \x3d ((6) + (function (){var or__5002__auto__ \x3d column;\nif(cljs.core.truth_(or__5002__auto__)){\nreturn or__5002__auto__;\n} else {\nreturn (1);\n}\n})());\nreturn new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22pre\x22,\x22pre\x22,2118456869),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),shadow.cljs.devtools.client.hud.source_highlight_styles], null),shadow.cljs.devtools.client.hud.sep_line.cljs$core$IFn$_invoke$arity$2(\x22^\x22,arrow_idx)], null);\n})(),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22font-weight\x22,\x22font-weight\x22,2085804583),\x22bold\x22,new cljs.core.Keyword(null,\x22font-size\x22,\x22font-size\x22,-1847940346),\x221.2em\x22,new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),\x2210px 0\x22], null)], null),msg], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22pre\x22,\x22pre\x22,2118456869),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),shadow.cljs.devtools.client.hud.source_highlight_styles], null),shadow.cljs.devtools.client.hud.sep_line.cljs$core$IFn$_invoke$arity$0()], null),shadow.cljs.devtools.client.hud.source_line_html(((start_idx + cljs.core.count(before)) + (1)),after,shadow.cljs.devtools.client.hud.source_line_styles)], null);\n})():null)], null);\n});\nshadow.cljs.devtools.client.hud.hud_warnings \x3d (function shadow$cljs$devtools$client$hud$hud_warnings(p__29070){\nvar map__29071 \x3d p__29070;\nvar map__29071__$1 \x3d cljs.core.__destructure_map(map__29071);\nvar msg \x3d map__29071__$1;\nvar type \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29071__$1,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348));\nvar info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29071__$1,new cljs.core.Keyword(null,\x22info\x22,\x22info\x22,-317069002));\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nvar map__29072 \x3d info;\nvar map__29072__$1 \x3d cljs.core.__destructure_map(map__29072);\nvar sources \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29072__$1,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424));\nvar sources_with_warnings \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__29069_SHARP_){\nreturn cljs.core.seq(new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651).cljs$core$IFn$_invoke$arity$1(p1__29069_SHARP_));\n}),cljs.core.remove.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22from-jar\x22,\x22from-jar\x22,1050932827),sources)));\nif(cljs.core.seq(sources_with_warnings)){\nshadow.cljs.devtools.client.hud.load_end();\n\nif(shadow.cljs.devtools.client.hud.show_warnings){\nreturn shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),shadow.cljs.devtools.client.hud.hud_id,new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),cljs.core.PersistentHashMap.fromArrays([new cljs.core.Keyword(null,\x22color\x22,\x22color\x22,1011675173),new cljs.core.Keyword(null,\x22bottom\x22,\x22bottom\x22,-1550509018),new cljs.core.Keyword(null,\x22font-size\x22,\x22font-size\x22,-1847940346),new cljs.core.Keyword(null,\x22z-index\x22,\x22z-index\x22,1892827090),new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833),new cljs.core.Keyword(null,\x22display\x22,\x22display\x22,242065432),new cljs.core.Keyword(null,\x22position\x22,\x22position\x22,-2011731912),new cljs.core.Keyword(null,\x22font-family\x22,\x22font-family\x22,-667419874),new cljs.core.Keyword(null,\x22flex-direction\x22,\x22flex-direction\x22,364609438),new cljs.core.Keyword(null,\x22left\x22,\x22left\x22,-399115937)],[\x22#000\x22,\x220px\x22,\x2212px\x22,\x2210000\x22,\x220px\x22,\x22flex\x22,\x22fixed\x22,\x22monospace\x22,\x22column\x22,\x220px\x22])], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 8, [new cljs.core.Keyword(null,\x22align-self\x22,\x22align-self\x22,1475936794),\x22flex-end\x22,new cljs.core.Keyword(null,\x22background\x22,\x22background\x22,-863952629),\x22#fff\x22,new cljs.core.Keyword(null,\x22border\x22,\x22border\x22,1444987323),\x222px solid #ccc\x22,new cljs.core.Keyword(null,\x22border-bottom\x22,\x22border-bottom\x22,2110948415),\x220px\x22,new cljs.core.Keyword(null,\x22cursor\x22,\x22cursor\x22,1011937484),\x22pointer\x22,new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),\x226px\x22,new cljs.core.Keyword(null,\x22margin-bottom\x22,\x22margin-bottom\x22,388334941),\x22-2px\x22,new cljs.core.Keyword(null,\x22z-index\x22,\x22z-index\x22,1892827090),\x2210000\x22], null),new cljs.core.Keyword(null,\x22on\x22,\x22on\x22,173873944),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22click\x22,\x22click\x22,1912301393),shadow.cljs.devtools.client.hud.hud_hide], null)], null),\x22Close\x22], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 6, [new cljs.core.Keyword(null,\x22background\x22,\x22background\x22,-863952629),\x22#fff\x22,new cljs.core.Keyword(null,\x22border-top\x22,\x22border-top\x22,-158897573),\x222px solid #ccc\x22,new cljs.core.Keyword(null,\x22flex\x22,\x22flex\x22,-1425124628),\x221\x22,new cljs.core.Keyword(null,\x22max-height\x22,\x22max-height\x22,-612563804),\x22300px\x22,new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),\x2210px 10px 0\x22,new cljs.core.Keyword(null,\x22overflow\x22,\x22overflow\x22,2058931880),\x22auto\x22], null)], null),(function (){var iter__5480__auto__ \x3d (function shadow$cljs$devtools$client$hud$hud_warnings_$_iter__29073(s__29074){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__29074__$1 \x3d s__29074;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__29074__$1);\nif(temp__5804__auto__){\nvar xs__6360__auto__ \x3d temp__5804__auto__;\nvar map__29079 \x3d cljs.core.first(xs__6360__auto__);\nvar map__29079__$1 \x3d cljs.core.__destructure_map(map__29079);\nvar warnings \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29079__$1,new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651));\nvar iterys__5476__auto__ \x3d ((function (s__29074__$1,map__29079,map__29079__$1,warnings,xs__6360__auto__,temp__5804__auto__,map__29072,map__29072__$1,sources,sources_with_warnings,map__29071,map__29071__$1,msg,type,info){\nreturn (function shadow$cljs$devtools$client$hud$hud_warnings_$_iter__29073_$_iter__29075(s__29076){\nreturn (new cljs.core.LazySeq(null,((function (s__29074__$1,map__29079,map__29079__$1,warnings,xs__6360__auto__,temp__5804__auto__,map__29072,map__29072__$1,sources,sources_with_warnings,map__29071,map__29071__$1,msg,type,info){\nreturn (function (){\nvar s__29076__$1 \x3d s__29076;\nwhile(true){\nvar temp__5804__auto____$1 \x3d cljs.core.seq(s__29076__$1);\nif(temp__5804__auto____$1){\nvar s__29076__$2 \x3d temp__5804__auto____$1;\nif(cljs.core.chunked_seq_QMARK_(s__29076__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__29076__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__29078 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__29077 \x3d (0);\nwhile(true){\nif((i__29077 \x3c size__5479__auto__)){\nvar warning \x3d cljs.core._nth(c__5478__auto__,i__29077);\ncljs.core.chunk_append(b__29078,shadow.cljs.devtools.client.hud.html_for_warning(warning));\n\nvar G__29090 \x3d (i__29077 + (1));\ni__29077 \x3d G__29090;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__29078),shadow$cljs$devtools$client$hud$hud_warnings_$_iter__29073_$_iter__29075(cljs.core.chunk_rest(s__29076__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__29078),null);\n}\n} else {\nvar warning \x3d cljs.core.first(s__29076__$2);\nreturn cljs.core.cons(shadow.cljs.devtools.client.hud.html_for_warning(warning),shadow$cljs$devtools$client$hud$hud_warnings_$_iter__29073_$_iter__29075(cljs.core.rest(s__29076__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});})(s__29074__$1,map__29079,map__29079__$1,warnings,xs__6360__auto__,temp__5804__auto__,map__29072,map__29072__$1,sources,sources_with_warnings,map__29071,map__29071__$1,msg,type,info))\n,null,null));\n});})(s__29074__$1,map__29079,map__29079__$1,warnings,xs__6360__auto__,temp__5804__auto__,map__29072,map__29072__$1,sources,sources_with_warnings,map__29071,map__29071__$1,msg,type,info))\n;\nvar fs__5477__auto__ \x3d cljs.core.seq(iterys__5476__auto__(warnings));\nif(fs__5477__auto__){\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$2(fs__5477__auto__,shadow$cljs$devtools$client$hud$hud_warnings_$_iter__29073(cljs.core.rest(s__29074__$1)));\n} else {\nvar G__29091 \x3d cljs.core.rest(s__29074__$1);\ns__29074__$1 \x3d G__29091;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(sources_with_warnings);\n})()], null)], null));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.hud_error \x3d (function shadow$cljs$devtools$client$hud$hud_error(p__29080){\nvar map__29081 \x3d p__29080;\nvar map__29081__$1 \x3d cljs.core.__destructure_map(map__29081);\nvar msg \x3d map__29081__$1;\nvar report \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29081__$1,new cljs.core.Keyword(null,\x22report\x22,\x22report\x22,1394055010));\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nif(shadow.cljs.devtools.client.hud.show_errors){\nreturn shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),shadow.cljs.devtools.client.hud.hud_id,new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),cljs.core.PersistentHashMap.fromArrays([new cljs.core.Keyword(null,\x22color\x22,\x22color\x22,1011675173),new cljs.core.Keyword(null,\x22bottom\x22,\x22bottom\x22,-1550509018),new cljs.core.Keyword(null,\x22font-size\x22,\x22font-size\x22,-1847940346),new cljs.core.Keyword(null,\x22top\x22,\x22top\x22,-1856271961),new cljs.core.Keyword(null,\x22overflow\x22,\x22overflow\x22,2058931880),new cljs.core.Keyword(null,\x22background-color\x22,\x22background-color\x22,570434026),new cljs.core.Keyword(null,\x22z-index\x22,\x22z-index\x22,1892827090),new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),new cljs.core.Keyword(null,\x22right\x22,\x22right\x22,-452581833),new cljs.core.Keyword(null,\x22position\x22,\x22position\x22,-2011731912),new cljs.core.Keyword(null,\x22border\x22,\x22border\x22,1444987323),new cljs.core.Keyword(null,\x22font-family\x22,\x22font-family\x22,-667419874),new cljs.core.Keyword(null,\x22left\x22,\x22left\x22,-399115937)],[\x22#000\x22,\x220px\x22,\x2212px\x22,\x220px\x22,\x22auto\x22,\x22#fff\x22,\x2210000\x22,\x2220px\x22,\x220px\x22,\x22fixed\x22,\x225px solid red\x22,\x22monospace\x22,\x220px\x22])], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),\x22color: red; margin-bottom: 10px; font-size: 2em;\x22], null),\x22Compilation failed!\x22], null),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22pre\x22,\x22pre\x22,2118456869),report], null)], null));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.connection_error_id \x3d \x22shadow-connection-error\x22;\nshadow.cljs.devtools.client.hud.connection_error_clear_BANG_ \x3d (function shadow$cljs$devtools$client$hud$connection_error_clear_BANG_(){\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nvar temp__5808__auto__ \x3d shadow.dom.by_id.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.hud.connection_error_id);\nif((temp__5808__auto__ \x3d\x3d null)){\nreturn null;\n} else {\nvar x \x3d temp__5808__auto__;\nreturn shadow.dom.remove(x);\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.connection_error \x3d (function shadow$cljs$devtools$client$hud$connection_error(msg){\nif(shadow.cljs.devtools.client.hud.dom_available_QMARK_){\nif(shadow.cljs.devtools.client.hud.show_errors){\nreturn shadow.cljs.devtools.client.hud.dom_insert.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,\x22id\x22,\x22id\x22,-1388402092),shadow.cljs.devtools.client.hud.connection_error_id,new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null,\x22position\x22,\x22position\x22,-2011731912),\x22fixed\x22,new cljs.core.Keyword(null,\x22pointer-events\x22,\x22pointer-events\x22,-1053858853),\x22none\x22,new cljs.core.Keyword(null,\x22left\x22,\x22left\x22,-399115937),\x220px\x22,new cljs.core.Keyword(null,\x22bottom\x22,\x22bottom\x22,-1550509018),\x2220px\x22,new cljs.core.Keyword(null,\x22z-index\x22,\x22z-index\x22,1892827090),\x2210000\x22], null)], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22div\x22,\x22div\x22,1057191632),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22style\x22,\x22style\x22,-496642736),cljs.core.PersistentHashMap.fromArrays([new cljs.core.Keyword(null,\x22box-shadow\x22,\x22box-shadow\x22,1600206755),new cljs.core.Keyword(null,\x22color\x22,\x22color\x22,1011675173),new cljs.core.Keyword(null,\x22font-size\x22,\x22font-size\x22,-1847940346),new cljs.core.Keyword(null,\x22font-weight\x22,\x22font-weight\x22,2085804583),new cljs.core.Keyword(null,\x22border-top-right-radius\x22,\x22border-top-right-radius\x22,1678770792),new cljs.core.Keyword(null,\x22background\x22,\x22background\x22,-863952629),new cljs.core.Keyword(null,\x22padding\x22,\x22padding\x22,1660304693),new cljs.core.Keyword(null,\x22border-bottom-right-radius\x22,\x22border-bottom-right-radius\x22,414899772),new cljs.core.Keyword(null,\x22font-family\x22,\x22font-family\x22,-667419874)],[\x222px 2px 10px #aaa\x22,\x22#fff\x22,\x2214px\x22,\x22bold\x22,\x2240px\x22,\x22#c00\x22,\x2210px\x22,\x2240px\x22,\x22monospace\x22])], null),[\x22shadow-cljs - \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(msg)].join(\x27\x27)], null)], null));\n} else {\nreturn null;\n}\n} else {\nreturn null;\n}\n});\nshadow.cljs.devtools.client.hud.load_failure \x3d (function shadow$cljs$devtools$client$hud$load_failure(error,task,remaining){\nshadow.cljs.devtools.client.hud.load_end();\n\nconsole.error(\x22reload-failed\x22,error);\n\nreturn shadow.cljs.devtools.client.hud.connection_error([\x22[reload failed] \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(error.message)].join(\x27\x27));\n});\n");
SHADOW_ENV.evalLoad("shadow.cljs.devtools.client.websocket.js", true, "goog.provide(\x27shadow.cljs.devtools.client.websocket\x27);\nshadow.cljs.devtools.client.websocket.start \x3d (function shadow$cljs$devtools$client$websocket$start(var_args){\nvar G__28899 \x3d arguments.length;\nswitch (G__28899) {\ncase 1:\nreturn shadow.cljs.devtools.client.websocket.start.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));\n\nbreak;\ncase 2:\nreturn shadow.cljs.devtools.client.websocket.start.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));\n\nbreak;\ndefault:\nthrow (new Error([\x22Invalid arity: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(\x27\x27)));\n\n}\n});\n\n(shadow.cljs.devtools.client.websocket.start.cljs$core$IFn$_invoke$arity$1 \x3d (function (runtime){\nreturn shadow.cljs.devtools.client.websocket.start.cljs$core$IFn$_invoke$arity$2(WebSocket,runtime);\n}));\n\n(shadow.cljs.devtools.client.websocket.start.cljs$core$IFn$_invoke$arity$2 \x3d (function (ws_impl,runtime){\nvar ws_url \x3d shadow.cljs.devtools.client.env.get_ws_relay_url();\nvar socket \x3d (new ws_impl(ws_url));\n(socket.onmessage \x3d (function (e){\nreturn shadow.cljs.devtools.client.shared.remote_msg(runtime,e.data);\n}));\n\n(socket.onopen \x3d (function (e){\nreturn shadow.cljs.devtools.client.shared.remote_open(runtime,e);\n}));\n\n(socket.onclose \x3d (function (e){\nreturn shadow.cljs.devtools.client.shared.remote_close(runtime,e,ws_url);\n}));\n\n(socket.onerror \x3d (function (e){\nreturn shadow.cljs.devtools.client.shared.remote_error(runtime,e);\n}));\n\nreturn socket;\n}));\n\n(shadow.cljs.devtools.client.websocket.start.cljs$lang$maxFixedArity \x3d 2);\n\nshadow.cljs.devtools.client.websocket.send \x3d (function shadow$cljs$devtools$client$websocket$send(socket,msg){\nreturn socket.send(msg);\n});\nshadow.cljs.devtools.client.websocket.stop \x3d (function shadow$cljs$devtools$client$websocket$stop(socket){\n(socket.onopen \x3d null);\n\n(socket.onclose \x3d null);\n\n(socket.onmessage \x3d null);\n\n(socket.onerror \x3d null);\n\nreturn socket.close();\n});\n");
SHADOW_ENV.evalLoad("shadow.cljs.devtools.client.browser.js", true, "goog.provide(\x27shadow.cljs.devtools.client.browser\x27);\nshadow.cljs.devtools.client.browser.devtools_msg \x3d (function shadow$cljs$devtools$client$browser$devtools_msg(var_args){\nvar args__5732__auto__ \x3d [];\nvar len__5726__auto___29370 \x3d arguments.length;\nvar i__5727__auto___29371 \x3d (0);\nwhile(true){\nif((i__5727__auto___29371 \x3c len__5726__auto___29370)){\nargs__5732__auto__.push((arguments[i__5727__auto___29371]));\n\nvar G__29372 \x3d (i__5727__auto___29371 + (1));\ni__5727__auto___29371 \x3d G__29372;\ncontinue;\n} else {\n}\nbreak;\n}\n\nvar argseq__5733__auto__ \x3d ((((1) \x3c args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((1)),(0),null)):null);\nreturn shadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5733__auto__);\n});\n\n(shadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic \x3d (function (msg,args){\nif(shadow.cljs.devtools.client.env.log){\nif(cljs.core.seq(shadow.cljs.devtools.client.env.log_style)){\nreturn console.log.apply(console,cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(cljs.core.into.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [[\x22%cshadow-cljs: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(msg)].join(\x27\x27),shadow.cljs.devtools.client.env.log_style], null),args)));\n} else {\nreturn console.log.apply(console,cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(cljs.core.into.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [[\x22shadow-cljs: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(msg)].join(\x27\x27)], null),args)));\n}\n} else {\nreturn null;\n}\n}));\n\n(shadow.cljs.devtools.client.browser.devtools_msg.cljs$lang$maxFixedArity \x3d (1));\n\n/** @this {Function} */\n(shadow.cljs.devtools.client.browser.devtools_msg.cljs$lang$applyTo \x3d (function (seq29092){\nvar G__29093 \x3d cljs.core.first(seq29092);\nvar seq29092__$1 \x3d cljs.core.next(seq29092);\nvar self__5711__auto__ \x3d this;\nreturn self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__29093,seq29092__$1);\n}));\n\nshadow.cljs.devtools.client.browser.script_eval \x3d (function shadow$cljs$devtools$client$browser$script_eval(code){\nreturn goog.globalEval(code);\n});\nshadow.cljs.devtools.client.browser.do_js_load \x3d (function shadow$cljs$devtools$client$browser$do_js_load(sources){\nvar seq__29094 \x3d cljs.core.seq(sources);\nvar chunk__29095 \x3d null;\nvar count__29096 \x3d (0);\nvar i__29097 \x3d (0);\nwhile(true){\nif((i__29097 \x3c count__29096)){\nvar map__29102 \x3d chunk__29095.cljs$core$IIndexed$_nth$arity$2(null, i__29097);\nvar map__29102__$1 \x3d cljs.core.__destructure_map(map__29102);\nvar src \x3d map__29102__$1;\nvar resource_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29102__$1,new cljs.core.Keyword(null,\x22resource-id\x22,\x22resource-id\x22,-1308422582));\nvar output_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29102__$1,new cljs.core.Keyword(null,\x22output-name\x22,\x22output-name\x22,-1769107767));\nvar resource_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29102__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nvar js \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29102__$1,new cljs.core.Keyword(null,\x22js\x22,\x22js\x22,1768080579));\n$CLJS.SHADOW_ENV.setLoaded(output_name);\n\nshadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic(\x22load JS\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([resource_name], 0));\n\nshadow.cljs.devtools.client.env.before_load_src(src);\n\ntry{shadow.cljs.devtools.client.browser.script_eval([cljs.core.str.cljs$core$IFn$_invoke$arity$1(js),\x22\\n//# sourceURL\x3d\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1($CLJS.SHADOW_ENV.scriptBase),cljs.core.str.cljs$core$IFn$_invoke$arity$1(output_name)].join(\x27\x27));\n}catch (e29103){var e_29373 \x3d e29103;\nif(shadow.cljs.devtools.client.env.log){\nconsole.error([\x22Failed to load \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(resource_name)].join(\x27\x27),e_29373);\n} else {\n}\n\nthrow (new Error([\x22Failed to load \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(resource_name),\x22: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(e_29373.message)].join(\x27\x27)));\n}\n\nvar G__29374 \x3d seq__29094;\nvar G__29375 \x3d chunk__29095;\nvar G__29376 \x3d count__29096;\nvar G__29377 \x3d (i__29097 + (1));\nseq__29094 \x3d G__29374;\nchunk__29095 \x3d G__29375;\ncount__29096 \x3d G__29376;\ni__29097 \x3d G__29377;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__29094);\nif(temp__5804__auto__){\nvar seq__29094__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__29094__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__29094__$1);\nvar G__29378 \x3d cljs.core.chunk_rest(seq__29094__$1);\nvar G__29379 \x3d c__5525__auto__;\nvar G__29380 \x3d cljs.core.count(c__5525__auto__);\nvar G__29381 \x3d (0);\nseq__29094 \x3d G__29378;\nchunk__29095 \x3d G__29379;\ncount__29096 \x3d G__29380;\ni__29097 \x3d G__29381;\ncontinue;\n} else {\nvar map__29104 \x3d cljs.core.first(seq__29094__$1);\nvar map__29104__$1 \x3d cljs.core.__destructure_map(map__29104);\nvar src \x3d map__29104__$1;\nvar resource_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29104__$1,new cljs.core.Keyword(null,\x22resource-id\x22,\x22resource-id\x22,-1308422582));\nvar output_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29104__$1,new cljs.core.Keyword(null,\x22output-name\x22,\x22output-name\x22,-1769107767));\nvar resource_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29104__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nvar js \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29104__$1,new cljs.core.Keyword(null,\x22js\x22,\x22js\x22,1768080579));\n$CLJS.SHADOW_ENV.setLoaded(output_name);\n\nshadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic(\x22load JS\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([resource_name], 0));\n\nshadow.cljs.devtools.client.env.before_load_src(src);\n\ntry{shadow.cljs.devtools.client.browser.script_eval([cljs.core.str.cljs$core$IFn$_invoke$arity$1(js),\x22\\n//# sourceURL\x3d\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1($CLJS.SHADOW_ENV.scriptBase),cljs.core.str.cljs$core$IFn$_invoke$arity$1(output_name)].join(\x27\x27));\n}catch (e29105){var e_29382 \x3d e29105;\nif(shadow.cljs.devtools.client.env.log){\nconsole.error([\x22Failed to load \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(resource_name)].join(\x27\x27),e_29382);\n} else {\n}\n\nthrow (new Error([\x22Failed to load \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(resource_name),\x22: \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(e_29382.message)].join(\x27\x27)));\n}\n\nvar G__29383 \x3d cljs.core.next(seq__29094__$1);\nvar G__29384 \x3d null;\nvar G__29385 \x3d (0);\nvar G__29386 \x3d (0);\nseq__29094 \x3d G__29383;\nchunk__29095 \x3d G__29384;\ncount__29096 \x3d G__29385;\ni__29097 \x3d G__29386;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.cljs.devtools.client.browser.do_js_reload \x3d (function shadow$cljs$devtools$client$browser$do_js_reload(msg,sources,complete_fn,failure_fn){\nreturn shadow.cljs.devtools.client.env.do_js_reload.cljs$core$IFn$_invoke$arity$4(cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(msg,new cljs.core.Keyword(null,\x22log-missing-fn\x22,\x22log-missing-fn\x22,732676765),(function (fn_sym){\nreturn null;\n}),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,\x22log-call-async\x22,\x22log-call-async\x22,183826192),(function (fn_sym){\nreturn shadow.cljs.devtools.client.browser.devtools_msg([\x22call async \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym)].join(\x27\x27));\n}),new cljs.core.Keyword(null,\x22log-call\x22,\x22log-call\x22,412404391),(function (fn_sym){\nreturn shadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym)].join(\x27\x27));\n})], 0)),(function (){\nreturn shadow.cljs.devtools.client.browser.do_js_load(sources);\n}),complete_fn,failure_fn);\n});\n/**\n * when (require \x27[\x22some-str\x22 :as x]) is done at the REPL we need to manually call the shadow.js.require for it\n * since the file only adds the shadow$provide. only need to do this for shadow-js.\n */\nshadow.cljs.devtools.client.browser.do_js_requires \x3d (function shadow$cljs$devtools$client$browser$do_js_requires(js_requires){\nvar seq__29106 \x3d cljs.core.seq(js_requires);\nvar chunk__29107 \x3d null;\nvar count__29108 \x3d (0);\nvar i__29109 \x3d (0);\nwhile(true){\nif((i__29109 \x3c count__29108)){\nvar js_ns \x3d chunk__29107.cljs$core$IIndexed$_nth$arity$2(null, i__29109);\nvar require_str_29387 \x3d [\x22var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(js_ns),\x22 \x3d shadow.js.require(\\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(js_ns),\x22\\\x22);\x22].join(\x27\x27);\nshadow.cljs.devtools.client.browser.script_eval(require_str_29387);\n\n\nvar G__29388 \x3d seq__29106;\nvar G__29389 \x3d chunk__29107;\nvar G__29390 \x3d count__29108;\nvar G__29391 \x3d (i__29109 + (1));\nseq__29106 \x3d G__29388;\nchunk__29107 \x3d G__29389;\ncount__29108 \x3d G__29390;\ni__29109 \x3d G__29391;\ncontinue;\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__29106);\nif(temp__5804__auto__){\nvar seq__29106__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__29106__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__29106__$1);\nvar G__29392 \x3d cljs.core.chunk_rest(seq__29106__$1);\nvar G__29393 \x3d c__5525__auto__;\nvar G__29394 \x3d cljs.core.count(c__5525__auto__);\nvar G__29395 \x3d (0);\nseq__29106 \x3d G__29392;\nchunk__29107 \x3d G__29393;\ncount__29108 \x3d G__29394;\ni__29109 \x3d G__29395;\ncontinue;\n} else {\nvar js_ns \x3d cljs.core.first(seq__29106__$1);\nvar require_str_29396 \x3d [\x22var \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(js_ns),\x22 \x3d shadow.js.require(\\\x22\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(js_ns),\x22\\\x22);\x22].join(\x27\x27);\nshadow.cljs.devtools.client.browser.script_eval(require_str_29396);\n\n\nvar G__29397 \x3d cljs.core.next(seq__29106__$1);\nvar G__29398 \x3d null;\nvar G__29399 \x3d (0);\nvar G__29400 \x3d (0);\nseq__29106 \x3d G__29397;\nchunk__29107 \x3d G__29398;\ncount__29108 \x3d G__29399;\ni__29109 \x3d G__29400;\ncontinue;\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.cljs.devtools.client.browser.handle_build_complete \x3d (function shadow$cljs$devtools$client$browser$handle_build_complete(runtime,p__29111){\nvar map__29112 \x3d p__29111;\nvar map__29112__$1 \x3d cljs.core.__destructure_map(map__29112);\nvar msg \x3d map__29112__$1;\nvar info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29112__$1,new cljs.core.Keyword(null,\x22info\x22,\x22info\x22,-317069002));\nvar reload_info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29112__$1,new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086));\nvar warnings \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.distinct.cljs$core$IFn$_invoke$arity$1((function (){var iter__5480__auto__ \x3d (function shadow$cljs$devtools$client$browser$handle_build_complete_$_iter__29113(s__29114){\nreturn (new cljs.core.LazySeq(null,(function (){\nvar s__29114__$1 \x3d s__29114;\nwhile(true){\nvar temp__5804__auto__ \x3d cljs.core.seq(s__29114__$1);\nif(temp__5804__auto__){\nvar xs__6360__auto__ \x3d temp__5804__auto__;\nvar map__29119 \x3d cljs.core.first(xs__6360__auto__);\nvar map__29119__$1 \x3d cljs.core.__destructure_map(map__29119);\nvar src \x3d map__29119__$1;\nvar resource_name \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29119__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nvar warnings \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29119__$1,new cljs.core.Keyword(null,\x22warnings\x22,\x22warnings\x22,-735437651));\nif(cljs.core.not(new cljs.core.Keyword(null,\x22from-jar\x22,\x22from-jar\x22,1050932827).cljs$core$IFn$_invoke$arity$1(src))){\nvar iterys__5476__auto__ \x3d ((function (s__29114__$1,map__29119,map__29119__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__29112,map__29112__$1,msg,info,reload_info){\nreturn (function shadow$cljs$devtools$client$browser$handle_build_complete_$_iter__29113_$_iter__29115(s__29116){\nreturn (new cljs.core.LazySeq(null,((function (s__29114__$1,map__29119,map__29119__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__29112,map__29112__$1,msg,info,reload_info){\nreturn (function (){\nvar s__29116__$1 \x3d s__29116;\nwhile(true){\nvar temp__5804__auto____$1 \x3d cljs.core.seq(s__29116__$1);\nif(temp__5804__auto____$1){\nvar s__29116__$2 \x3d temp__5804__auto____$1;\nif(cljs.core.chunked_seq_QMARK_(s__29116__$2)){\nvar c__5478__auto__ \x3d cljs.core.chunk_first(s__29116__$2);\nvar size__5479__auto__ \x3d cljs.core.count(c__5478__auto__);\nvar b__29118 \x3d cljs.core.chunk_buffer(size__5479__auto__);\nif((function (){var i__29117 \x3d (0);\nwhile(true){\nif((i__29117 \x3c size__5479__auto__)){\nvar warning \x3d cljs.core._nth(c__5478__auto__,i__29117);\ncljs.core.chunk_append(b__29118,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(warning,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100),resource_name));\n\nvar G__29401 \x3d (i__29117 + (1));\ni__29117 \x3d G__29401;\ncontinue;\n} else {\nreturn true;\n}\nbreak;\n}\n})()){\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__29118),shadow$cljs$devtools$client$browser$handle_build_complete_$_iter__29113_$_iter__29115(cljs.core.chunk_rest(s__29116__$2)));\n} else {\nreturn cljs.core.chunk_cons(cljs.core.chunk(b__29118),null);\n}\n} else {\nvar warning \x3d cljs.core.first(s__29116__$2);\nreturn cljs.core.cons(cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(warning,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100),resource_name),shadow$cljs$devtools$client$browser$handle_build_complete_$_iter__29113_$_iter__29115(cljs.core.rest(s__29116__$2)));\n}\n} else {\nreturn null;\n}\nbreak;\n}\n});})(s__29114__$1,map__29119,map__29119__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__29112,map__29112__$1,msg,info,reload_info))\n,null,null));\n});})(s__29114__$1,map__29119,map__29119__$1,src,resource_name,warnings,xs__6360__auto__,temp__5804__auto__,map__29112,map__29112__$1,msg,info,reload_info))\n;\nvar fs__5477__auto__ \x3d cljs.core.seq(iterys__5476__auto__(warnings));\nif(fs__5477__auto__){\nreturn cljs.core.concat.cljs$core$IFn$_invoke$arity$2(fs__5477__auto__,shadow$cljs$devtools$client$browser$handle_build_complete_$_iter__29113(cljs.core.rest(s__29114__$1)));\n} else {\nvar G__29402 \x3d cljs.core.rest(s__29114__$1);\ns__29114__$1 \x3d G__29402;\ncontinue;\n}\n} else {\nvar G__29403 \x3d cljs.core.rest(s__29114__$1);\ns__29114__$1 \x3d G__29403;\ncontinue;\n}\n} else {\nreturn null;\n}\nbreak;\n}\n}),null,null));\n});\nreturn iter__5480__auto__(new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424).cljs$core$IFn$_invoke$arity$1(info));\n})()));\nif(shadow.cljs.devtools.client.env.log){\nvar seq__29120_29404 \x3d cljs.core.seq(warnings);\nvar chunk__29121_29405 \x3d null;\nvar count__29122_29406 \x3d (0);\nvar i__29123_29407 \x3d (0);\nwhile(true){\nif((i__29123_29407 \x3c count__29122_29406)){\nvar map__29126_29408 \x3d chunk__29121_29405.cljs$core$IIndexed$_nth$arity$2(null, i__29123_29407);\nvar map__29126_29409__$1 \x3d cljs.core.__destructure_map(map__29126_29408);\nvar w_29410 \x3d map__29126_29409__$1;\nvar msg_29411__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29126_29409__$1,new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444));\nvar line_29412 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29126_29409__$1,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235));\nvar column_29413 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29126_29409__$1,new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095));\nvar resource_name_29414 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29126_29409__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nconsole.warn([\x22BUILD-WARNING in \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(resource_name_29414),\x22 at [\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(line_29412),\x22:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(column_29413),\x22]\\n\\t\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(msg_29411__$1)].join(\x27\x27));\n\n\nvar G__29415 \x3d seq__29120_29404;\nvar G__29416 \x3d chunk__29121_29405;\nvar G__29417 \x3d count__29122_29406;\nvar G__29418 \x3d (i__29123_29407 + (1));\nseq__29120_29404 \x3d G__29415;\nchunk__29121_29405 \x3d G__29416;\ncount__29122_29406 \x3d G__29417;\ni__29123_29407 \x3d G__29418;\ncontinue;\n} else {\nvar temp__5804__auto___29419 \x3d cljs.core.seq(seq__29120_29404);\nif(temp__5804__auto___29419){\nvar seq__29120_29420__$1 \x3d temp__5804__auto___29419;\nif(cljs.core.chunked_seq_QMARK_(seq__29120_29420__$1)){\nvar c__5525__auto___29421 \x3d cljs.core.chunk_first(seq__29120_29420__$1);\nvar G__29422 \x3d cljs.core.chunk_rest(seq__29120_29420__$1);\nvar G__29423 \x3d c__5525__auto___29421;\nvar G__29424 \x3d cljs.core.count(c__5525__auto___29421);\nvar G__29425 \x3d (0);\nseq__29120_29404 \x3d G__29422;\nchunk__29121_29405 \x3d G__29423;\ncount__29122_29406 \x3d G__29424;\ni__29123_29407 \x3d G__29425;\ncontinue;\n} else {\nvar map__29127_29426 \x3d cljs.core.first(seq__29120_29420__$1);\nvar map__29127_29427__$1 \x3d cljs.core.__destructure_map(map__29127_29426);\nvar w_29428 \x3d map__29127_29427__$1;\nvar msg_29429__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29127_29427__$1,new cljs.core.Keyword(null,\x22msg\x22,\x22msg\x22,-1386103444));\nvar line_29430 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29127_29427__$1,new cljs.core.Keyword(null,\x22line\x22,\x22line\x22,212345235));\nvar column_29431 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29127_29427__$1,new cljs.core.Keyword(null,\x22column\x22,\x22column\x22,2078222095));\nvar resource_name_29432 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29127_29427__$1,new cljs.core.Keyword(null,\x22resource-name\x22,\x22resource-name\x22,2001617100));\nconsole.warn([\x22BUILD-WARNING in \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(resource_name_29432),\x22 at [\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(line_29430),\x22:\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(column_29431),\x22]\\n\\t\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(msg_29429__$1)].join(\x27\x27));\n\n\nvar G__29433 \x3d cljs.core.next(seq__29120_29420__$1);\nvar G__29434 \x3d null;\nvar G__29435 \x3d (0);\nvar G__29436 \x3d (0);\nseq__29120_29404 \x3d G__29433;\nchunk__29121_29405 \x3d G__29434;\ncount__29122_29406 \x3d G__29435;\ni__29123_29407 \x3d G__29436;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n} else {\n}\n\nif((!(shadow.cljs.devtools.client.env.autoload))){\nreturn shadow.cljs.devtools.client.hud.load_end_success();\n} else {\nif(((cljs.core.empty_QMARK_(warnings)) || (shadow.cljs.devtools.client.env.ignore_warnings))){\nvar sources_to_get \x3d shadow.cljs.devtools.client.env.filter_reload_sources(info,reload_info);\nif(cljs.core.not(cljs.core.seq(sources_to_get))){\nreturn shadow.cljs.devtools.client.hud.load_end_success();\n} else {\nif(cljs.core.seq(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(msg,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086),new cljs.core.Keyword(null,\x22after-load\x22,\x22after-load\x22,-1278503285)], null)))){\n} else {\nshadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic(\x22reloading code but no :after-load hooks are configured!\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22https://shadow-cljs.github.io/docs/UsersGuide.html#_lifecycle_hooks\x22], 0));\n}\n\nreturn shadow.cljs.devtools.client.shared.load_sources(runtime,sources_to_get,(function (p1__29110_SHARP_){\nreturn shadow.cljs.devtools.client.browser.do_js_reload(msg,p1__29110_SHARP_,shadow.cljs.devtools.client.hud.load_end_success,shadow.cljs.devtools.client.hud.load_failure);\n}));\n}\n} else {\nreturn null;\n}\n}\n});\nshadow.cljs.devtools.client.browser.page_load_uri \x3d (cljs.core.truth_(goog.global.document)?goog.Uri.parse(document.location.href):null);\nshadow.cljs.devtools.client.browser.match_paths \x3d (function shadow$cljs$devtools$client$browser$match_paths(old,new$){\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(\x22file\x22,shadow.cljs.devtools.client.browser.page_load_uri.getScheme())){\nvar rel_new \x3d cljs.core.subs.cljs$core$IFn$_invoke$arity$2(new$,(1));\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(old,rel_new)) || (clojure.string.starts_with_QMARK_(old,[rel_new,\x22?\x22].join(\x27\x27))))){\nreturn rel_new;\n} else {\nreturn null;\n}\n} else {\nvar node_uri \x3d goog.Uri.parse(old);\nvar node_uri_resolved \x3d shadow.cljs.devtools.client.browser.page_load_uri.resolve(node_uri);\nvar node_abs \x3d node_uri_resolved.getPath();\nvar and__5000__auto__ \x3d ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$1(shadow.cljs.devtools.client.browser.page_load_uri.hasSameDomainAs(node_uri))) || (cljs.core.not(node_uri.hasDomain())));\nif(and__5000__auto__){\nvar and__5000__auto____$1 \x3d cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(node_abs,new$);\nif(and__5000__auto____$1){\nreturn new$;\n} else {\nreturn and__5000__auto____$1;\n}\n} else {\nreturn and__5000__auto__;\n}\n}\n});\nshadow.cljs.devtools.client.browser.handle_asset_update \x3d (function shadow$cljs$devtools$client$browser$handle_asset_update(p__29128){\nvar map__29129 \x3d p__29128;\nvar map__29129__$1 \x3d cljs.core.__destructure_map(map__29129);\nvar msg \x3d map__29129__$1;\nvar updates \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29129__$1,new cljs.core.Keyword(null,\x22updates\x22,\x22updates\x22,2013983452));\nvar reload_info \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29129__$1,new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086));\nvar seq__29130 \x3d cljs.core.seq(updates);\nvar chunk__29132 \x3d null;\nvar count__29133 \x3d (0);\nvar i__29134 \x3d (0);\nwhile(true){\nif((i__29134 \x3c count__29133)){\nvar path \x3d chunk__29132.cljs$core$IIndexed$_nth$arity$2(null, i__29134);\nif(clojure.string.ends_with_QMARK_(path,\x22css\x22)){\nvar seq__29244_29437 \x3d cljs.core.seq(cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1(document.querySelectorAll(\x22link[rel\x3d\\\x22stylesheet\\\x22]\x22)));\nvar chunk__29248_29438 \x3d null;\nvar count__29249_29439 \x3d (0);\nvar i__29250_29440 \x3d (0);\nwhile(true){\nif((i__29250_29440 \x3c count__29249_29439)){\nvar node_29441 \x3d chunk__29248_29438.cljs$core$IIndexed$_nth$arity$2(null, i__29250_29440);\nif(cljs.core.not(node_29441.shadow$old)){\nvar path_match_29442 \x3d shadow.cljs.devtools.client.browser.match_paths(node_29441.getAttribute(\x22href\x22),path);\nif(cljs.core.truth_(path_match_29442)){\nvar new_link_29443 \x3d (function (){var G__29276 \x3d node_29441.cloneNode(true);\nG__29276.setAttribute(\x22href\x22,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(path_match_29442),\x22?r\x3d\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.rand.cljs$core$IFn$_invoke$arity$0())].join(\x27\x27));\n\nreturn G__29276;\n})();\n(node_29441.shadow$old \x3d true);\n\n(new_link_29443.onload \x3d ((function (seq__29244_29437,chunk__29248_29438,count__29249_29439,i__29250_29440,seq__29130,chunk__29132,count__29133,i__29134,new_link_29443,path_match_29442,node_29441,path,map__29129,map__29129__$1,msg,updates,reload_info){\nreturn (function (e){\nvar seq__29277_29444 \x3d cljs.core.seq(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(msg,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086),new cljs.core.Keyword(null,\x22asset-load\x22,\x22asset-load\x22,-1925902322)], null)));\nvar chunk__29279_29445 \x3d null;\nvar count__29280_29446 \x3d (0);\nvar i__29281_29447 \x3d (0);\nwhile(true){\nif((i__29281_29447 \x3c count__29280_29446)){\nvar map__29285_29448 \x3d chunk__29279_29445.cljs$core$IIndexed$_nth$arity$2(null, i__29281_29447);\nvar map__29285_29449__$1 \x3d cljs.core.__destructure_map(map__29285_29448);\nvar task_29450 \x3d map__29285_29449__$1;\nvar fn_str_29451 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29285_29449__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29452 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29285_29449__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29453 \x3d goog.getObjectByName(fn_str_29451,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29452)].join(\x27\x27));\n\n(fn_obj_29453.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29453.cljs$core$IFn$_invoke$arity$2(path,new_link_29443) : fn_obj_29453.call(null, path,new_link_29443));\n\n\nvar G__29454 \x3d seq__29277_29444;\nvar G__29455 \x3d chunk__29279_29445;\nvar G__29456 \x3d count__29280_29446;\nvar G__29457 \x3d (i__29281_29447 + (1));\nseq__29277_29444 \x3d G__29454;\nchunk__29279_29445 \x3d G__29455;\ncount__29280_29446 \x3d G__29456;\ni__29281_29447 \x3d G__29457;\ncontinue;\n} else {\nvar temp__5804__auto___29458 \x3d cljs.core.seq(seq__29277_29444);\nif(temp__5804__auto___29458){\nvar seq__29277_29459__$1 \x3d temp__5804__auto___29458;\nif(cljs.core.chunked_seq_QMARK_(seq__29277_29459__$1)){\nvar c__5525__auto___29460 \x3d cljs.core.chunk_first(seq__29277_29459__$1);\nvar G__29461 \x3d cljs.core.chunk_rest(seq__29277_29459__$1);\nvar G__29462 \x3d c__5525__auto___29460;\nvar G__29463 \x3d cljs.core.count(c__5525__auto___29460);\nvar G__29464 \x3d (0);\nseq__29277_29444 \x3d G__29461;\nchunk__29279_29445 \x3d G__29462;\ncount__29280_29446 \x3d G__29463;\ni__29281_29447 \x3d G__29464;\ncontinue;\n} else {\nvar map__29286_29465 \x3d cljs.core.first(seq__29277_29459__$1);\nvar map__29286_29466__$1 \x3d cljs.core.__destructure_map(map__29286_29465);\nvar task_29467 \x3d map__29286_29466__$1;\nvar fn_str_29468 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29286_29466__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29469 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29286_29466__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29470 \x3d goog.getObjectByName(fn_str_29468,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29469)].join(\x27\x27));\n\n(fn_obj_29470.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29470.cljs$core$IFn$_invoke$arity$2(path,new_link_29443) : fn_obj_29470.call(null, path,new_link_29443));\n\n\nvar G__29471 \x3d cljs.core.next(seq__29277_29459__$1);\nvar G__29472 \x3d null;\nvar G__29473 \x3d (0);\nvar G__29474 \x3d (0);\nseq__29277_29444 \x3d G__29471;\nchunk__29279_29445 \x3d G__29472;\ncount__29280_29446 \x3d G__29473;\ni__29281_29447 \x3d G__29474;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn goog.dom.removeNode(node_29441);\n});})(seq__29244_29437,chunk__29248_29438,count__29249_29439,i__29250_29440,seq__29130,chunk__29132,count__29133,i__29134,new_link_29443,path_match_29442,node_29441,path,map__29129,map__29129__$1,msg,updates,reload_info))\n);\n\nshadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic(\x22load CSS\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([path_match_29442], 0));\n\ngoog.dom.insertSiblingAfter(new_link_29443,node_29441);\n\n\nvar G__29475 \x3d seq__29244_29437;\nvar G__29476 \x3d chunk__29248_29438;\nvar G__29477 \x3d count__29249_29439;\nvar G__29478 \x3d (i__29250_29440 + (1));\nseq__29244_29437 \x3d G__29475;\nchunk__29248_29438 \x3d G__29476;\ncount__29249_29439 \x3d G__29477;\ni__29250_29440 \x3d G__29478;\ncontinue;\n} else {\nvar G__29479 \x3d seq__29244_29437;\nvar G__29480 \x3d chunk__29248_29438;\nvar G__29481 \x3d count__29249_29439;\nvar G__29482 \x3d (i__29250_29440 + (1));\nseq__29244_29437 \x3d G__29479;\nchunk__29248_29438 \x3d G__29480;\ncount__29249_29439 \x3d G__29481;\ni__29250_29440 \x3d G__29482;\ncontinue;\n}\n} else {\nvar G__29483 \x3d seq__29244_29437;\nvar G__29484 \x3d chunk__29248_29438;\nvar G__29485 \x3d count__29249_29439;\nvar G__29486 \x3d (i__29250_29440 + (1));\nseq__29244_29437 \x3d G__29483;\nchunk__29248_29438 \x3d G__29484;\ncount__29249_29439 \x3d G__29485;\ni__29250_29440 \x3d G__29486;\ncontinue;\n}\n} else {\nvar temp__5804__auto___29487 \x3d cljs.core.seq(seq__29244_29437);\nif(temp__5804__auto___29487){\nvar seq__29244_29488__$1 \x3d temp__5804__auto___29487;\nif(cljs.core.chunked_seq_QMARK_(seq__29244_29488__$1)){\nvar c__5525__auto___29489 \x3d cljs.core.chunk_first(seq__29244_29488__$1);\nvar G__29490 \x3d cljs.core.chunk_rest(seq__29244_29488__$1);\nvar G__29491 \x3d c__5525__auto___29489;\nvar G__29492 \x3d cljs.core.count(c__5525__auto___29489);\nvar G__29493 \x3d (0);\nseq__29244_29437 \x3d G__29490;\nchunk__29248_29438 \x3d G__29491;\ncount__29249_29439 \x3d G__29492;\ni__29250_29440 \x3d G__29493;\ncontinue;\n} else {\nvar node_29494 \x3d cljs.core.first(seq__29244_29488__$1);\nif(cljs.core.not(node_29494.shadow$old)){\nvar path_match_29495 \x3d shadow.cljs.devtools.client.browser.match_paths(node_29494.getAttribute(\x22href\x22),path);\nif(cljs.core.truth_(path_match_29495)){\nvar new_link_29496 \x3d (function (){var G__29287 \x3d node_29494.cloneNode(true);\nG__29287.setAttribute(\x22href\x22,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(path_match_29495),\x22?r\x3d\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.rand.cljs$core$IFn$_invoke$arity$0())].join(\x27\x27));\n\nreturn G__29287;\n})();\n(node_29494.shadow$old \x3d true);\n\n(new_link_29496.onload \x3d ((function (seq__29244_29437,chunk__29248_29438,count__29249_29439,i__29250_29440,seq__29130,chunk__29132,count__29133,i__29134,new_link_29496,path_match_29495,node_29494,seq__29244_29488__$1,temp__5804__auto___29487,path,map__29129,map__29129__$1,msg,updates,reload_info){\nreturn (function (e){\nvar seq__29288_29497 \x3d cljs.core.seq(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(msg,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086),new cljs.core.Keyword(null,\x22asset-load\x22,\x22asset-load\x22,-1925902322)], null)));\nvar chunk__29290_29498 \x3d null;\nvar count__29291_29499 \x3d (0);\nvar i__29292_29500 \x3d (0);\nwhile(true){\nif((i__29292_29500 \x3c count__29291_29499)){\nvar map__29296_29501 \x3d chunk__29290_29498.cljs$core$IIndexed$_nth$arity$2(null, i__29292_29500);\nvar map__29296_29502__$1 \x3d cljs.core.__destructure_map(map__29296_29501);\nvar task_29503 \x3d map__29296_29502__$1;\nvar fn_str_29504 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29296_29502__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29505 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29296_29502__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29506 \x3d goog.getObjectByName(fn_str_29504,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29505)].join(\x27\x27));\n\n(fn_obj_29506.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29506.cljs$core$IFn$_invoke$arity$2(path,new_link_29496) : fn_obj_29506.call(null, path,new_link_29496));\n\n\nvar G__29507 \x3d seq__29288_29497;\nvar G__29508 \x3d chunk__29290_29498;\nvar G__29509 \x3d count__29291_29499;\nvar G__29510 \x3d (i__29292_29500 + (1));\nseq__29288_29497 \x3d G__29507;\nchunk__29290_29498 \x3d G__29508;\ncount__29291_29499 \x3d G__29509;\ni__29292_29500 \x3d G__29510;\ncontinue;\n} else {\nvar temp__5804__auto___29511__$1 \x3d cljs.core.seq(seq__29288_29497);\nif(temp__5804__auto___29511__$1){\nvar seq__29288_29512__$1 \x3d temp__5804__auto___29511__$1;\nif(cljs.core.chunked_seq_QMARK_(seq__29288_29512__$1)){\nvar c__5525__auto___29513 \x3d cljs.core.chunk_first(seq__29288_29512__$1);\nvar G__29514 \x3d cljs.core.chunk_rest(seq__29288_29512__$1);\nvar G__29515 \x3d c__5525__auto___29513;\nvar G__29516 \x3d cljs.core.count(c__5525__auto___29513);\nvar G__29517 \x3d (0);\nseq__29288_29497 \x3d G__29514;\nchunk__29290_29498 \x3d G__29515;\ncount__29291_29499 \x3d G__29516;\ni__29292_29500 \x3d G__29517;\ncontinue;\n} else {\nvar map__29297_29518 \x3d cljs.core.first(seq__29288_29512__$1);\nvar map__29297_29519__$1 \x3d cljs.core.__destructure_map(map__29297_29518);\nvar task_29520 \x3d map__29297_29519__$1;\nvar fn_str_29521 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29297_29519__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29522 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29297_29519__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29523 \x3d goog.getObjectByName(fn_str_29521,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29522)].join(\x27\x27));\n\n(fn_obj_29523.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29523.cljs$core$IFn$_invoke$arity$2(path,new_link_29496) : fn_obj_29523.call(null, path,new_link_29496));\n\n\nvar G__29524 \x3d cljs.core.next(seq__29288_29512__$1);\nvar G__29525 \x3d null;\nvar G__29526 \x3d (0);\nvar G__29527 \x3d (0);\nseq__29288_29497 \x3d G__29524;\nchunk__29290_29498 \x3d G__29525;\ncount__29291_29499 \x3d G__29526;\ni__29292_29500 \x3d G__29527;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn goog.dom.removeNode(node_29494);\n});})(seq__29244_29437,chunk__29248_29438,count__29249_29439,i__29250_29440,seq__29130,chunk__29132,count__29133,i__29134,new_link_29496,path_match_29495,node_29494,seq__29244_29488__$1,temp__5804__auto___29487,path,map__29129,map__29129__$1,msg,updates,reload_info))\n);\n\nshadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic(\x22load CSS\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([path_match_29495], 0));\n\ngoog.dom.insertSiblingAfter(new_link_29496,node_29494);\n\n\nvar G__29528 \x3d cljs.core.next(seq__29244_29488__$1);\nvar G__29529 \x3d null;\nvar G__29530 \x3d (0);\nvar G__29531 \x3d (0);\nseq__29244_29437 \x3d G__29528;\nchunk__29248_29438 \x3d G__29529;\ncount__29249_29439 \x3d G__29530;\ni__29250_29440 \x3d G__29531;\ncontinue;\n} else {\nvar G__29532 \x3d cljs.core.next(seq__29244_29488__$1);\nvar G__29533 \x3d null;\nvar G__29534 \x3d (0);\nvar G__29535 \x3d (0);\nseq__29244_29437 \x3d G__29532;\nchunk__29248_29438 \x3d G__29533;\ncount__29249_29439 \x3d G__29534;\ni__29250_29440 \x3d G__29535;\ncontinue;\n}\n} else {\nvar G__29536 \x3d cljs.core.next(seq__29244_29488__$1);\nvar G__29537 \x3d null;\nvar G__29538 \x3d (0);\nvar G__29539 \x3d (0);\nseq__29244_29437 \x3d G__29536;\nchunk__29248_29438 \x3d G__29537;\ncount__29249_29439 \x3d G__29538;\ni__29250_29440 \x3d G__29539;\ncontinue;\n}\n}\n} else {\n}\n}\nbreak;\n}\n\n\nvar G__29540 \x3d seq__29130;\nvar G__29541 \x3d chunk__29132;\nvar G__29542 \x3d count__29133;\nvar G__29543 \x3d (i__29134 + (1));\nseq__29130 \x3d G__29540;\nchunk__29132 \x3d G__29541;\ncount__29133 \x3d G__29542;\ni__29134 \x3d G__29543;\ncontinue;\n} else {\nvar G__29544 \x3d seq__29130;\nvar G__29545 \x3d chunk__29132;\nvar G__29546 \x3d count__29133;\nvar G__29547 \x3d (i__29134 + (1));\nseq__29130 \x3d G__29544;\nchunk__29132 \x3d G__29545;\ncount__29133 \x3d G__29546;\ni__29134 \x3d G__29547;\ncontinue;\n}\n} else {\nvar temp__5804__auto__ \x3d cljs.core.seq(seq__29130);\nif(temp__5804__auto__){\nvar seq__29130__$1 \x3d temp__5804__auto__;\nif(cljs.core.chunked_seq_QMARK_(seq__29130__$1)){\nvar c__5525__auto__ \x3d cljs.core.chunk_first(seq__29130__$1);\nvar G__29548 \x3d cljs.core.chunk_rest(seq__29130__$1);\nvar G__29549 \x3d c__5525__auto__;\nvar G__29550 \x3d cljs.core.count(c__5525__auto__);\nvar G__29551 \x3d (0);\nseq__29130 \x3d G__29548;\nchunk__29132 \x3d G__29549;\ncount__29133 \x3d G__29550;\ni__29134 \x3d G__29551;\ncontinue;\n} else {\nvar path \x3d cljs.core.first(seq__29130__$1);\nif(clojure.string.ends_with_QMARK_(path,\x22css\x22)){\nvar seq__29298_29552 \x3d cljs.core.seq(cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1(document.querySelectorAll(\x22link[rel\x3d\\\x22stylesheet\\\x22]\x22)));\nvar chunk__29302_29553 \x3d null;\nvar count__29303_29554 \x3d (0);\nvar i__29304_29555 \x3d (0);\nwhile(true){\nif((i__29304_29555 \x3c count__29303_29554)){\nvar node_29556 \x3d chunk__29302_29553.cljs$core$IIndexed$_nth$arity$2(null, i__29304_29555);\nif(cljs.core.not(node_29556.shadow$old)){\nvar path_match_29557 \x3d shadow.cljs.devtools.client.browser.match_paths(node_29556.getAttribute(\x22href\x22),path);\nif(cljs.core.truth_(path_match_29557)){\nvar new_link_29558 \x3d (function (){var G__29330 \x3d node_29556.cloneNode(true);\nG__29330.setAttribute(\x22href\x22,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(path_match_29557),\x22?r\x3d\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.rand.cljs$core$IFn$_invoke$arity$0())].join(\x27\x27));\n\nreturn G__29330;\n})();\n(node_29556.shadow$old \x3d true);\n\n(new_link_29558.onload \x3d ((function (seq__29298_29552,chunk__29302_29553,count__29303_29554,i__29304_29555,seq__29130,chunk__29132,count__29133,i__29134,new_link_29558,path_match_29557,node_29556,path,seq__29130__$1,temp__5804__auto__,map__29129,map__29129__$1,msg,updates,reload_info){\nreturn (function (e){\nvar seq__29331_29559 \x3d cljs.core.seq(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(msg,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086),new cljs.core.Keyword(null,\x22asset-load\x22,\x22asset-load\x22,-1925902322)], null)));\nvar chunk__29333_29560 \x3d null;\nvar count__29334_29561 \x3d (0);\nvar i__29335_29562 \x3d (0);\nwhile(true){\nif((i__29335_29562 \x3c count__29334_29561)){\nvar map__29339_29563 \x3d chunk__29333_29560.cljs$core$IIndexed$_nth$arity$2(null, i__29335_29562);\nvar map__29339_29564__$1 \x3d cljs.core.__destructure_map(map__29339_29563);\nvar task_29565 \x3d map__29339_29564__$1;\nvar fn_str_29566 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29339_29564__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29567 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29339_29564__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29568 \x3d goog.getObjectByName(fn_str_29566,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29567)].join(\x27\x27));\n\n(fn_obj_29568.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29568.cljs$core$IFn$_invoke$arity$2(path,new_link_29558) : fn_obj_29568.call(null, path,new_link_29558));\n\n\nvar G__29569 \x3d seq__29331_29559;\nvar G__29570 \x3d chunk__29333_29560;\nvar G__29571 \x3d count__29334_29561;\nvar G__29572 \x3d (i__29335_29562 + (1));\nseq__29331_29559 \x3d G__29569;\nchunk__29333_29560 \x3d G__29570;\ncount__29334_29561 \x3d G__29571;\ni__29335_29562 \x3d G__29572;\ncontinue;\n} else {\nvar temp__5804__auto___29573__$1 \x3d cljs.core.seq(seq__29331_29559);\nif(temp__5804__auto___29573__$1){\nvar seq__29331_29574__$1 \x3d temp__5804__auto___29573__$1;\nif(cljs.core.chunked_seq_QMARK_(seq__29331_29574__$1)){\nvar c__5525__auto___29575 \x3d cljs.core.chunk_first(seq__29331_29574__$1);\nvar G__29576 \x3d cljs.core.chunk_rest(seq__29331_29574__$1);\nvar G__29577 \x3d c__5525__auto___29575;\nvar G__29578 \x3d cljs.core.count(c__5525__auto___29575);\nvar G__29579 \x3d (0);\nseq__29331_29559 \x3d G__29576;\nchunk__29333_29560 \x3d G__29577;\ncount__29334_29561 \x3d G__29578;\ni__29335_29562 \x3d G__29579;\ncontinue;\n} else {\nvar map__29340_29580 \x3d cljs.core.first(seq__29331_29574__$1);\nvar map__29340_29581__$1 \x3d cljs.core.__destructure_map(map__29340_29580);\nvar task_29582 \x3d map__29340_29581__$1;\nvar fn_str_29583 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29340_29581__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29584 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29340_29581__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29585 \x3d goog.getObjectByName(fn_str_29583,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29584)].join(\x27\x27));\n\n(fn_obj_29585.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29585.cljs$core$IFn$_invoke$arity$2(path,new_link_29558) : fn_obj_29585.call(null, path,new_link_29558));\n\n\nvar G__29586 \x3d cljs.core.next(seq__29331_29574__$1);\nvar G__29587 \x3d null;\nvar G__29588 \x3d (0);\nvar G__29589 \x3d (0);\nseq__29331_29559 \x3d G__29586;\nchunk__29333_29560 \x3d G__29587;\ncount__29334_29561 \x3d G__29588;\ni__29335_29562 \x3d G__29589;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn goog.dom.removeNode(node_29556);\n});})(seq__29298_29552,chunk__29302_29553,count__29303_29554,i__29304_29555,seq__29130,chunk__29132,count__29133,i__29134,new_link_29558,path_match_29557,node_29556,path,seq__29130__$1,temp__5804__auto__,map__29129,map__29129__$1,msg,updates,reload_info))\n);\n\nshadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic(\x22load CSS\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([path_match_29557], 0));\n\ngoog.dom.insertSiblingAfter(new_link_29558,node_29556);\n\n\nvar G__29590 \x3d seq__29298_29552;\nvar G__29591 \x3d chunk__29302_29553;\nvar G__29592 \x3d count__29303_29554;\nvar G__29593 \x3d (i__29304_29555 + (1));\nseq__29298_29552 \x3d G__29590;\nchunk__29302_29553 \x3d G__29591;\ncount__29303_29554 \x3d G__29592;\ni__29304_29555 \x3d G__29593;\ncontinue;\n} else {\nvar G__29594 \x3d seq__29298_29552;\nvar G__29595 \x3d chunk__29302_29553;\nvar G__29596 \x3d count__29303_29554;\nvar G__29597 \x3d (i__29304_29555 + (1));\nseq__29298_29552 \x3d G__29594;\nchunk__29302_29553 \x3d G__29595;\ncount__29303_29554 \x3d G__29596;\ni__29304_29555 \x3d G__29597;\ncontinue;\n}\n} else {\nvar G__29598 \x3d seq__29298_29552;\nvar G__29599 \x3d chunk__29302_29553;\nvar G__29600 \x3d count__29303_29554;\nvar G__29601 \x3d (i__29304_29555 + (1));\nseq__29298_29552 \x3d G__29598;\nchunk__29302_29553 \x3d G__29599;\ncount__29303_29554 \x3d G__29600;\ni__29304_29555 \x3d G__29601;\ncontinue;\n}\n} else {\nvar temp__5804__auto___29602__$1 \x3d cljs.core.seq(seq__29298_29552);\nif(temp__5804__auto___29602__$1){\nvar seq__29298_29603__$1 \x3d temp__5804__auto___29602__$1;\nif(cljs.core.chunked_seq_QMARK_(seq__29298_29603__$1)){\nvar c__5525__auto___29604 \x3d cljs.core.chunk_first(seq__29298_29603__$1);\nvar G__29605 \x3d cljs.core.chunk_rest(seq__29298_29603__$1);\nvar G__29606 \x3d c__5525__auto___29604;\nvar G__29607 \x3d cljs.core.count(c__5525__auto___29604);\nvar G__29608 \x3d (0);\nseq__29298_29552 \x3d G__29605;\nchunk__29302_29553 \x3d G__29606;\ncount__29303_29554 \x3d G__29607;\ni__29304_29555 \x3d G__29608;\ncontinue;\n} else {\nvar node_29609 \x3d cljs.core.first(seq__29298_29603__$1);\nif(cljs.core.not(node_29609.shadow$old)){\nvar path_match_29610 \x3d shadow.cljs.devtools.client.browser.match_paths(node_29609.getAttribute(\x22href\x22),path);\nif(cljs.core.truth_(path_match_29610)){\nvar new_link_29611 \x3d (function (){var G__29341 \x3d node_29609.cloneNode(true);\nG__29341.setAttribute(\x22href\x22,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(path_match_29610),\x22?r\x3d\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.rand.cljs$core$IFn$_invoke$arity$0())].join(\x27\x27));\n\nreturn G__29341;\n})();\n(node_29609.shadow$old \x3d true);\n\n(new_link_29611.onload \x3d ((function (seq__29298_29552,chunk__29302_29553,count__29303_29554,i__29304_29555,seq__29130,chunk__29132,count__29133,i__29134,new_link_29611,path_match_29610,node_29609,seq__29298_29603__$1,temp__5804__auto___29602__$1,path,seq__29130__$1,temp__5804__auto__,map__29129,map__29129__$1,msg,updates,reload_info){\nreturn (function (e){\nvar seq__29342_29612 \x3d cljs.core.seq(cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(msg,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,\x22reload-info\x22,\x22reload-info\x22,1648088086),new cljs.core.Keyword(null,\x22asset-load\x22,\x22asset-load\x22,-1925902322)], null)));\nvar chunk__29344_29613 \x3d null;\nvar count__29345_29614 \x3d (0);\nvar i__29346_29615 \x3d (0);\nwhile(true){\nif((i__29346_29615 \x3c count__29345_29614)){\nvar map__29350_29616 \x3d chunk__29344_29613.cljs$core$IIndexed$_nth$arity$2(null, i__29346_29615);\nvar map__29350_29617__$1 \x3d cljs.core.__destructure_map(map__29350_29616);\nvar task_29618 \x3d map__29350_29617__$1;\nvar fn_str_29619 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29350_29617__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29620 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29350_29617__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29621 \x3d goog.getObjectByName(fn_str_29619,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29620)].join(\x27\x27));\n\n(fn_obj_29621.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29621.cljs$core$IFn$_invoke$arity$2(path,new_link_29611) : fn_obj_29621.call(null, path,new_link_29611));\n\n\nvar G__29622 \x3d seq__29342_29612;\nvar G__29623 \x3d chunk__29344_29613;\nvar G__29624 \x3d count__29345_29614;\nvar G__29625 \x3d (i__29346_29615 + (1));\nseq__29342_29612 \x3d G__29622;\nchunk__29344_29613 \x3d G__29623;\ncount__29345_29614 \x3d G__29624;\ni__29346_29615 \x3d G__29625;\ncontinue;\n} else {\nvar temp__5804__auto___29626__$2 \x3d cljs.core.seq(seq__29342_29612);\nif(temp__5804__auto___29626__$2){\nvar seq__29342_29627__$1 \x3d temp__5804__auto___29626__$2;\nif(cljs.core.chunked_seq_QMARK_(seq__29342_29627__$1)){\nvar c__5525__auto___29628 \x3d cljs.core.chunk_first(seq__29342_29627__$1);\nvar G__29629 \x3d cljs.core.chunk_rest(seq__29342_29627__$1);\nvar G__29630 \x3d c__5525__auto___29628;\nvar G__29631 \x3d cljs.core.count(c__5525__auto___29628);\nvar G__29632 \x3d (0);\nseq__29342_29612 \x3d G__29629;\nchunk__29344_29613 \x3d G__29630;\ncount__29345_29614 \x3d G__29631;\ni__29346_29615 \x3d G__29632;\ncontinue;\n} else {\nvar map__29351_29633 \x3d cljs.core.first(seq__29342_29627__$1);\nvar map__29351_29634__$1 \x3d cljs.core.__destructure_map(map__29351_29633);\nvar task_29635 \x3d map__29351_29634__$1;\nvar fn_str_29636 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29351_29634__$1,new cljs.core.Keyword(null,\x22fn-str\x22,\x22fn-str\x22,-1348506402));\nvar fn_sym_29637 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29351_29634__$1,new cljs.core.Keyword(null,\x22fn-sym\x22,\x22fn-sym\x22,1423988510));\nvar fn_obj_29638 \x3d goog.getObjectByName(fn_str_29636,$CLJS);\nshadow.cljs.devtools.client.browser.devtools_msg([\x22call \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(fn_sym_29637)].join(\x27\x27));\n\n(fn_obj_29638.cljs$core$IFn$_invoke$arity$2 ? fn_obj_29638.cljs$core$IFn$_invoke$arity$2(path,new_link_29611) : fn_obj_29638.call(null, path,new_link_29611));\n\n\nvar G__29639 \x3d cljs.core.next(seq__29342_29627__$1);\nvar G__29640 \x3d null;\nvar G__29641 \x3d (0);\nvar G__29642 \x3d (0);\nseq__29342_29612 \x3d G__29639;\nchunk__29344_29613 \x3d G__29640;\ncount__29345_29614 \x3d G__29641;\ni__29346_29615 \x3d G__29642;\ncontinue;\n}\n} else {\n}\n}\nbreak;\n}\n\nreturn goog.dom.removeNode(node_29609);\n});})(seq__29298_29552,chunk__29302_29553,count__29303_29554,i__29304_29555,seq__29130,chunk__29132,count__29133,i__29134,new_link_29611,path_match_29610,node_29609,seq__29298_29603__$1,temp__5804__auto___29602__$1,path,seq__29130__$1,temp__5804__auto__,map__29129,map__29129__$1,msg,updates,reload_info))\n);\n\nshadow.cljs.devtools.client.browser.devtools_msg.cljs$core$IFn$_invoke$arity$variadic(\x22load CSS\x22,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([path_match_29610], 0));\n\ngoog.dom.insertSiblingAfter(new_link_29611,node_29609);\n\n\nvar G__29643 \x3d cljs.core.next(seq__29298_29603__$1);\nvar G__29644 \x3d null;\nvar G__29645 \x3d (0);\nvar G__29646 \x3d (0);\nseq__29298_29552 \x3d G__29643;\nchunk__29302_29553 \x3d G__29644;\ncount__29303_29554 \x3d G__29645;\ni__29304_29555 \x3d G__29646;\ncontinue;\n} else {\nvar G__29647 \x3d cljs.core.next(seq__29298_29603__$1);\nvar G__29648 \x3d null;\nvar G__29649 \x3d (0);\nvar G__29650 \x3d (0);\nseq__29298_29552 \x3d G__29647;\nchunk__29302_29553 \x3d G__29648;\ncount__29303_29554 \x3d G__29649;\ni__29304_29555 \x3d G__29650;\ncontinue;\n}\n} else {\nvar G__29651 \x3d cljs.core.next(seq__29298_29603__$1);\nvar G__29652 \x3d null;\nvar G__29653 \x3d (0);\nvar G__29654 \x3d (0);\nseq__29298_29552 \x3d G__29651;\nchunk__29302_29553 \x3d G__29652;\ncount__29303_29554 \x3d G__29653;\ni__29304_29555 \x3d G__29654;\ncontinue;\n}\n}\n} else {\n}\n}\nbreak;\n}\n\n\nvar G__29655 \x3d cljs.core.next(seq__29130__$1);\nvar G__29656 \x3d null;\nvar G__29657 \x3d (0);\nvar G__29658 \x3d (0);\nseq__29130 \x3d G__29655;\nchunk__29132 \x3d G__29656;\ncount__29133 \x3d G__29657;\ni__29134 \x3d G__29658;\ncontinue;\n} else {\nvar G__29659 \x3d cljs.core.next(seq__29130__$1);\nvar G__29660 \x3d null;\nvar G__29661 \x3d (0);\nvar G__29662 \x3d (0);\nseq__29130 \x3d G__29659;\nchunk__29132 \x3d G__29660;\ncount__29133 \x3d G__29661;\ni__29134 \x3d G__29662;\ncontinue;\n}\n}\n} else {\nreturn null;\n}\n}\nbreak;\n}\n});\nshadow.cljs.devtools.client.browser.global_eval \x3d (function shadow$cljs$devtools$client$browser$global_eval(js){\nif(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(\x22undefined\x22,typeof(module))){\nreturn eval(js);\n} else {\nreturn (0,eval)(js);;\n}\n});\nshadow.cljs.devtools.client.browser.runtime_info \x3d (((typeof SHADOW_CONFIG !\x3d\x3d \x27undefined\x27))?shadow.json.to_clj.cljs$core$IFn$_invoke$arity$1(SHADOW_CONFIG):null);\nshadow.cljs.devtools.client.browser.client_info \x3d cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([shadow.cljs.devtools.client.browser.runtime_info,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22host\x22,\x22host\x22,-1558485167),(cljs.core.truth_(goog.global.document)?new cljs.core.Keyword(null,\x22browser\x22,\x22browser\x22,828191719):new cljs.core.Keyword(null,\x22browser-worker\x22,\x22browser-worker\x22,1638998282)),new cljs.core.Keyword(null,\x22user-agent\x22,\x22user-agent\x22,1220426212),[(cljs.core.truth_(goog.userAgent.OPERA)?\x22Opera\x22:(cljs.core.truth_(goog.userAgent.product.CHROME)?\x22Chrome\x22:(cljs.core.truth_(goog.userAgent.IE)?\x22MSIE\x22:(cljs.core.truth_(goog.userAgent.EDGE)?\x22Edge\x22:(cljs.core.truth_(goog.userAgent.GECKO)?\x22Firefox\x22:(cljs.core.truth_(goog.userAgent.SAFARI)?\x22Safari\x22:(cljs.core.truth_(goog.userAgent.WEBKIT)?\x22Webkit\x22:null))))))),\x22 \x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(goog.userAgent.VERSION),\x22 [\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(goog.userAgent.PLATFORM),\x22]\x22].join(\x27\x27),new cljs.core.Keyword(null,\x22dom\x22,\x22dom\x22,-1236537922),(!((goog.global.document \x3d\x3d null)))], null)], 0));\nif((typeof shadow !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.browser !\x3d\x3d \x27undefined\x27) \x26\x26 (typeof shadow.cljs.devtools.client.browser.ws_was_welcome_ref !\x3d\x3d \x27undefined\x27)){\n} else {\nshadow.cljs.devtools.client.browser.ws_was_welcome_ref \x3d cljs.core.atom.cljs$core$IFn$_invoke$arity$1(false);\n}\nif(((shadow.cljs.devtools.client.env.enabled) \x26\x26 ((shadow.cljs.devtools.client.env.worker_client_id \x3e (0))))){\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IEvalJS$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$remote$runtime$api$IEvalJS$_js_eval$arity$2 \x3d (function (this$,code){\nvar this$__$1 \x3d this;\nreturn shadow.cljs.devtools.client.browser.global_eval(code);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IHostSpecific$ \x3d cljs.core.PROTOCOL_SENTINEL);\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IHostSpecific$do_invoke$arity$3 \x3d (function (this$,ns,p__29352){\nvar map__29353 \x3d p__29352;\nvar map__29353__$1 \x3d cljs.core.__destructure_map(map__29353);\nvar js \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29353__$1,new cljs.core.Keyword(null,\x22js\x22,\x22js\x22,1768080579));\nvar this$__$1 \x3d this;\nreturn shadow.cljs.devtools.client.browser.global_eval(js);\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_init$arity$4 \x3d (function (runtime,p__29354,done,error){\nvar map__29355 \x3d p__29354;\nvar map__29355__$1 \x3d cljs.core.__destructure_map(map__29355);\nvar repl_sources \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29355__$1,new cljs.core.Keyword(null,\x22repl-sources\x22,\x22repl-sources\x22,723867535));\nvar runtime__$1 \x3d this;\nreturn shadow.cljs.devtools.client.shared.load_sources(runtime__$1,cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.remove.cljs$core$IFn$_invoke$arity$2(shadow.cljs.devtools.client.env.src_is_loaded_QMARK_,repl_sources)),(function (sources){\nshadow.cljs.devtools.client.browser.do_js_load(sources);\n\nreturn (done.cljs$core$IFn$_invoke$arity$0 ? done.cljs$core$IFn$_invoke$arity$0() : done.call(null, ));\n}));\n}));\n\n(shadow.cljs.devtools.client.shared.Runtime.prototype.shadow$cljs$devtools$client$shared$IHostSpecific$do_repl_require$arity$4 \x3d (function (runtime,p__29356,done,error){\nvar map__29357 \x3d p__29356;\nvar map__29357__$1 \x3d cljs.core.__destructure_map(map__29357);\nvar msg \x3d map__29357__$1;\nvar sources \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29357__$1,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424));\nvar reload_namespaces \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29357__$1,new cljs.core.Keyword(null,\x22reload-namespaces\x22,\x22reload-namespaces\x22,250210134));\nvar js_requires \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29357__$1,new cljs.core.Keyword(null,\x22js-requires\x22,\x22js-requires\x22,-1311472051));\nvar runtime__$1 \x3d this;\nvar sources_to_load \x3d cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.remove.cljs$core$IFn$_invoke$arity$2((function (p__29358){\nvar map__29359 \x3d p__29358;\nvar map__29359__$1 \x3d cljs.core.__destructure_map(map__29359);\nvar src \x3d map__29359__$1;\nvar provides \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29359__$1,new cljs.core.Keyword(null,\x22provides\x22,\x22provides\x22,-1634397992));\nvar and__5000__auto__ \x3d shadow.cljs.devtools.client.env.src_is_loaded_QMARK_(src);\nif(cljs.core.truth_(and__5000__auto__)){\nreturn cljs.core.not(cljs.core.some(reload_namespaces,provides));\n} else {\nreturn and__5000__auto__;\n}\n}),sources));\nif(cljs.core.not(cljs.core.seq(sources_to_load))){\nvar G__29360 \x3d cljs.core.PersistentVector.EMPTY;\nreturn (done.cljs$core$IFn$_invoke$arity$1 ? done.cljs$core$IFn$_invoke$arity$1(G__29360) : done.call(null, G__29360));\n} else {\nreturn shadow.remote.runtime.shared.call.cljs$core$IFn$_invoke$arity$3(runtime__$1,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,\x22op\x22,\x22op\x22,-1882987955),new cljs.core.Keyword(null,\x22cljs-load-sources\x22,\x22cljs-load-sources\x22,-1458295962),new cljs.core.Keyword(null,\x22to\x22,\x22to\x22,192099007),shadow.cljs.devtools.client.env.worker_client_id,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424),cljs.core.into.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22resource-id\x22,\x22resource-id\x22,-1308422582)),sources_to_load)], null),new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22cljs-sources\x22,\x22cljs-sources\x22,31121610),(function (p__29361){\nvar map__29362 \x3d p__29361;\nvar map__29362__$1 \x3d cljs.core.__destructure_map(map__29362);\nvar msg__$1 \x3d map__29362__$1;\nvar sources__$1 \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29362__$1,new cljs.core.Keyword(null,\x22sources\x22,\x22sources\x22,-321166424));\ntry{shadow.cljs.devtools.client.browser.do_js_load(sources__$1);\n\nif(cljs.core.seq(js_requires)){\nshadow.cljs.devtools.client.browser.do_js_requires(js_requires);\n} else {\n}\n\nreturn (done.cljs$core$IFn$_invoke$arity$1 ? done.cljs$core$IFn$_invoke$arity$1(sources_to_load) : done.call(null, sources_to_load));\n}catch (e29363){var ex \x3d e29363;\nreturn (error.cljs$core$IFn$_invoke$arity$1 ? error.cljs$core$IFn$_invoke$arity$1(ex) : error.call(null, ex));\n}})], null));\n}\n}));\n\nshadow.cljs.devtools.client.shared.add_plugin_BANG_(new cljs.core.Keyword(\x22shadow.cljs.devtools.client.browser\x22,\x22client\x22,\x22shadow.cljs.devtools.client.browser/client\x22,-1461019282),cljs.core.PersistentHashSet.EMPTY,(function (p__29364){\nvar map__29365 \x3d p__29364;\nvar map__29365__$1 \x3d cljs.core.__destructure_map(map__29365);\nvar env \x3d map__29365__$1;\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29365__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nvar svc \x3d new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996),runtime], null);\nshadow.remote.runtime.api.add_extension(runtime,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.browser\x22,\x22client\x22,\x22shadow.cljs.devtools.client.browser/client\x22,-1461019282),new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,\x22on-welcome\x22,\x22on-welcome\x22,1895317125),(function (){\ncljs.core.reset_BANG_(shadow.cljs.devtools.client.browser.ws_was_welcome_ref,true);\n\nshadow.cljs.devtools.client.hud.connection_error_clear_BANG_();\n\nshadow.cljs.devtools.client.env.patch_goog_BANG_();\n\nreturn shadow.cljs.devtools.client.browser.devtools_msg([\x22#\x22,cljs.core.str.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140).cljs$core$IFn$_invoke$arity$1(cljs.core.deref(new cljs.core.Keyword(null,\x22state-ref\x22,\x22state-ref\x22,2127874952).cljs$core$IFn$_invoke$arity$1(runtime)))),\x22 ready!\x22].join(\x27\x27));\n}),new cljs.core.Keyword(null,\x22on-disconnect\x22,\x22on-disconnect\x22,-809021814),(function (e){\nif(cljs.core.truth_(cljs.core.deref(shadow.cljs.devtools.client.browser.ws_was_welcome_ref))){\nshadow.cljs.devtools.client.hud.connection_error(\x22The Websocket connection was closed!\x22);\n\nreturn cljs.core.reset_BANG_(shadow.cljs.devtools.client.browser.ws_was_welcome_ref,false);\n} else {\nreturn null;\n}\n}),new cljs.core.Keyword(null,\x22on-reconnect\x22,\x22on-reconnect\x22,1239988702),(function (e){\nreturn shadow.cljs.devtools.client.hud.connection_error(\x22Reconnecting ...\x22);\n}),new cljs.core.Keyword(null,\x22ops\x22,\x22ops\x22,1237330063),new cljs.core.PersistentArrayMap(null, 7, [new cljs.core.Keyword(null,\x22access-denied\x22,\x22access-denied\x22,959449406),(function (msg){\ncljs.core.reset_BANG_(shadow.cljs.devtools.client.browser.ws_was_welcome_ref,false);\n\nreturn shadow.cljs.devtools.client.hud.connection_error([\x22Stale Output! Your loaded JS was not produced by the running shadow-cljs instance.\x22,\x22 Is the watch for this build running?\x22].join(\x27\x27));\n}),new cljs.core.Keyword(null,\x22cljs-asset-update\x22,\x22cljs-asset-update\x22,1224093028),(function (msg){\nreturn shadow.cljs.devtools.client.browser.handle_asset_update(msg);\n}),new cljs.core.Keyword(null,\x22cljs-build-configure\x22,\x22cljs-build-configure\x22,-2089891268),(function (msg){\nreturn null;\n}),new cljs.core.Keyword(null,\x22cljs-build-start\x22,\x22cljs-build-start\x22,-725781241),(function (msg){\nshadow.cljs.devtools.client.hud.hud_hide();\n\nshadow.cljs.devtools.client.hud.load_start();\n\nreturn shadow.cljs.devtools.client.env.run_custom_notify_BANG_(cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(msg,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),new cljs.core.Keyword(null,\x22build-start\x22,\x22build-start\x22,-959649480)));\n}),new cljs.core.Keyword(null,\x22cljs-build-complete\x22,\x22cljs-build-complete\x22,273626153),(function (msg){\nvar msg__$1 \x3d shadow.cljs.devtools.client.env.add_warnings_to_info(msg);\nshadow.cljs.devtools.client.hud.connection_error_clear_BANG_();\n\nshadow.cljs.devtools.client.hud.hud_warnings(msg__$1);\n\nshadow.cljs.devtools.client.browser.handle_build_complete(runtime,msg__$1);\n\nreturn shadow.cljs.devtools.client.env.run_custom_notify_BANG_(cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(msg__$1,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),new cljs.core.Keyword(null,\x22build-complete\x22,\x22build-complete\x22,-501868472)));\n}),new cljs.core.Keyword(null,\x22cljs-build-failure\x22,\x22cljs-build-failure\x22,1718154990),(function (msg){\nshadow.cljs.devtools.client.hud.load_end();\n\nshadow.cljs.devtools.client.hud.hud_error(msg);\n\nreturn shadow.cljs.devtools.client.env.run_custom_notify_BANG_(cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(msg,new cljs.core.Keyword(null,\x22type\x22,\x22type\x22,1174270348),new cljs.core.Keyword(null,\x22build-failure\x22,\x22build-failure\x22,-2107487466)));\n}),new cljs.core.Keyword(\x22shadow.cljs.devtools.client.env\x22,\x22worker-notify\x22,\x22shadow.cljs.devtools.client.env/worker-notify\x22,-1456820670),(function (p__29366){\nvar map__29367 \x3d p__29366;\nvar map__29367__$1 \x3d cljs.core.__destructure_map(map__29367);\nvar event_op \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29367__$1,new cljs.core.Keyword(null,\x22event-op\x22,\x22event-op\x22,200358057));\nvar client_id \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29367__$1,new cljs.core.Keyword(null,\x22client-id\x22,\x22client-id\x22,-464622140));\nif(((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22client-disconnect\x22,\x22client-disconnect\x22,640227957),event_op)) \x26\x26 (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(client_id,shadow.cljs.devtools.client.env.worker_client_id)))){\nshadow.cljs.devtools.client.hud.connection_error_clear_BANG_();\n\nreturn shadow.cljs.devtools.client.hud.connection_error(\x22The watch for this build was stopped!\x22);\n} else {\nif(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,\x22client-connect\x22,\x22client-connect\x22,-1113973888),event_op)){\nshadow.cljs.devtools.client.hud.connection_error_clear_BANG_();\n\nreturn shadow.cljs.devtools.client.hud.connection_error(\x22The watch for this build was restarted. Reload required!\x22);\n} else {\nreturn null;\n}\n}\n})], null)], null));\n\nreturn svc;\n}),(function (p__29368){\nvar map__29369 \x3d p__29368;\nvar map__29369__$1 \x3d cljs.core.__destructure_map(map__29369);\nvar svc \x3d map__29369__$1;\nvar runtime \x3d cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__29369__$1,new cljs.core.Keyword(null,\x22runtime\x22,\x22runtime\x22,-1331573996));\nreturn shadow.remote.runtime.api.del_extension(runtime,new cljs.core.Keyword(\x22shadow.cljs.devtools.client.browser\x22,\x22client\x22,\x22shadow.cljs.devtools.client.browser/client\x22,-1461019282));\n}));\n\nshadow.cljs.devtools.client.shared.init_runtime_BANG_(shadow.cljs.devtools.client.browser.client_info,shadow.cljs.devtools.client.websocket.start,shadow.cljs.devtools.client.websocket.send,shadow.cljs.devtools.client.websocket.stop);\n} else {\n}\n");
SHADOW_ENV.evalLoad("nothoughts.core.init.js", true, "goog.provide(\x27nothoughts.core.init\x27);\nnothoughts.core.init.init \x3d (function nothoughts$core$init$init(){\nreturn cljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([\x22hello\x22], 0));\n});\n");
SHADOW_ENV.evalLoad("shadow.module.main.append.js", false, "\nshadow.cljs.devtools.client.env.module_loaded(\x27main\x27);\n\ntry { nothoughts.core.init.init(); } catch (e) { console.error(\x22An error occurred when calling (nothoughts.core.init/init)\x22); console.error(e); }");