diff --git a/ionic/components/alert/alert.js b/ionic/components/alert/alert.js
index d5477a5db5..3d55bcb1d7 100644
--- a/ionic/components/alert/alert.js
+++ b/ionic/components/alert/alert.js
@@ -2,33 +2,39 @@
 // import {IonicComponent} from 'ionic/config/component'
 
 
-// @Component({
-//   selector: 'ion-alert'
-// })
-// @View({
-//   template: `
-//     <div class="overlay-backdrop"></div>
-//     <div class="overlay-container">
-//       <div class="alert-container">
-//         <div class="alert-header">
-//           Do you like cookies?
-//         </div>
-//         <div class="alert-content">
-//           Seriously, who does not like cookies.
-//         </div>
-//         <div class="alert-actions">
-//           <button class="button">OK</button>
-//         </div>
-//       </div>
-//     </div>`
-// })
-// export class Alert {
-//   constructor(
-//     @NgElement() ngElement:NgElement
-//   ) {
-//     this.domElement = ngElement.domElement
-//     this.config = Alert.config.invoke(this)
-//   }
-// }
+/*
+@Component({
+  selector: 'ion-alert'
+})
+@NgView({
+  template: `
+    <div class="overlay-backdrop"></div>
+    <div class="overlay-container">
+      <div class="alert-container">
+        <div class="alert-header">
+          Do you like cookies?
+        </div>
+        <div class="alert-content">
+          Seriously, who does not like cookies.
+        </div>
+        <div class="alert-actions">
+          <button class="button">OK</button>
+        </div>
+      </div>
+    </div>`
+})
+export class Alert {
+  constructor(
+    @NgElement() ngElement:NgElement
+  ) {
+    this.domElement = ngElement.domElement
+    this.config = Alert.config.invoke(this)
+  }
+
+  static open(opts) {
+    let alert = new Alert();
+  }
+}
+*/
 
 // new IonicComponent(Alert, {})
diff --git a/ionic/components/alert/test/basic/main.html b/ionic/components/alert/test/basic/main.html
index b7ec13fdde..b0d903c9b2 100644
--- a/ionic/components/alert/test/basic/main.html
+++ b/ionic/components/alert/test/basic/main.html
@@ -1,4 +1,8 @@
+<ion-view>
+  <button (click)="showAlert()">Alert</button>
+  <!--
+  <ion-alert>
 
-<ion-alert>
-
-</ion-alert>
+  </ion-alert>
+  -->
+</ion-view>
diff --git a/ionic/components/alert/test/basic/main.js b/ionic/components/alert/test/basic/main.js
index 5451f02497..87d1337ce9 100644
--- a/ionic/components/alert/test/basic/main.js
+++ b/ionic/components/alert/test/basic/main.js
@@ -11,6 +11,12 @@ class IonicApp {
   constructor() {
     console.log('IonicApp Start')
   }
+  showAlert() {
+    console.log('Show alert');
+
+    Alert.open({
+    });
+  }
 }
 
 bootstrap(IonicApp)
diff --git a/ionic/components/app/test/hn/firebase-debug.js b/ionic/components/app/test/hn/firebase-debug.js
new file mode 100644
index 0000000000..f3b7c8dde5
--- /dev/null
+++ b/ionic/components/app/test/hn/firebase-debug.js
@@ -0,0 +1,13050 @@
+/*! @license Firebase v2.2.4
+    License: https://www.firebase.com/terms/terms-of-service.html */
+var CLOSURE_NO_DEPS = true;
+var COMPILED = false;
+var goog = goog || {};
+goog.global = this;
+goog.global.CLOSURE_UNCOMPILED_DEFINES;
+goog.global.CLOSURE_DEFINES;
+goog.isDef = function(val) {
+  return val !== void 0;
+};
+goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
+  var parts = name.split(".");
+  var cur = opt_objectToExportTo || goog.global;
+  if (!(parts[0] in cur) && cur.execScript) {
+    cur.execScript("var " + parts[0]);
+  }
+  for (var part;parts.length && (part = parts.shift());) {
+    if (!parts.length && goog.isDef(opt_object)) {
+      cur[part] = opt_object;
+    } else {
+      if (cur[part]) {
+        cur = cur[part];
+      } else {
+        cur = cur[part] = {};
+      }
+    }
+  }
+};
+goog.define = function(name, defaultValue) {
+  var value = defaultValue;
+  if (!COMPILED) {
+    if (goog.global.CLOSURE_UNCOMPILED_DEFINES && Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_UNCOMPILED_DEFINES, name)) {
+      value = goog.global.CLOSURE_UNCOMPILED_DEFINES[name];
+    } else {
+      if (goog.global.CLOSURE_DEFINES && Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_DEFINES, name)) {
+        value = goog.global.CLOSURE_DEFINES[name];
+      }
+    }
+  }
+  goog.exportPath_(name, value);
+};
+goog.define("goog.DEBUG", true);
+goog.define("goog.LOCALE", "en");
+goog.define("goog.TRUSTED_SITE", true);
+goog.define("goog.STRICT_MODE_COMPATIBLE", false);
+goog.define("goog.DISALLOW_TEST_ONLY_CODE", COMPILED && !goog.DEBUG);
+goog.provide = function(name) {
+  if (!COMPILED) {
+    if (goog.isProvided_(name)) {
+      throw Error('Namespace "' + name + '" already declared.');
+    }
+  }
+  goog.constructNamespace_(name);
+};
+goog.constructNamespace_ = function(name, opt_obj) {
+  if (!COMPILED) {
+    delete goog.implicitNamespaces_[name];
+    var namespace = name;
+    while (namespace = namespace.substring(0, namespace.lastIndexOf("."))) {
+      if (goog.getObjectByName(namespace)) {
+        break;
+      }
+      goog.implicitNamespaces_[namespace] = true;
+    }
+  }
+  goog.exportPath_(name, opt_obj);
+};
+goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
+goog.module = function(name) {
+  if (!goog.isString(name) || !name || name.search(goog.VALID_MODULE_RE_) == -1) {
+    throw Error("Invalid module identifier");
+  }
+  if (!goog.isInModuleLoader_()) {
+    throw Error("Module " + name + " has been loaded incorrectly.");
+  }
+  if (goog.moduleLoaderState_.moduleName) {
+    throw Error("goog.module may only be called once per module.");
+  }
+  goog.moduleLoaderState_.moduleName = name;
+  if (!COMPILED) {
+    if (goog.isProvided_(name)) {
+      throw Error('Namespace "' + name + '" already declared.');
+    }
+    delete goog.implicitNamespaces_[name];
+  }
+};
+goog.module.get = function(name) {
+  return goog.module.getInternal_(name);
+};
+goog.module.getInternal_ = function(name) {
+  if (!COMPILED) {
+    if (goog.isProvided_(name)) {
+      return name in goog.loadedModules_ ? goog.loadedModules_[name] : goog.getObjectByName(name);
+    } else {
+      return null;
+    }
+  }
+};
+goog.moduleLoaderState_ = null;
+goog.isInModuleLoader_ = function() {
+  return goog.moduleLoaderState_ != null;
+};
+goog.module.declareTestMethods = function() {
+  if (!goog.isInModuleLoader_()) {
+    throw new Error("goog.module.declareTestMethods must be called from " + "within a goog.module");
+  }
+  goog.moduleLoaderState_.declareTestMethods = true;
+};
+goog.module.declareLegacyNamespace = function() {
+  if (!COMPILED && !goog.isInModuleLoader_()) {
+    throw new Error("goog.module.declareLegacyNamespace must be called from " + "within a goog.module");
+  }
+  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
+    throw Error("goog.module must be called prior to " + "goog.module.declareLegacyNamespace.");
+  }
+  goog.moduleLoaderState_.declareLegacyNamespace = true;
+};
+goog.setTestOnly = function(opt_message) {
+  if (goog.DISALLOW_TEST_ONLY_CODE) {
+    opt_message = opt_message || "";
+    throw Error("Importing test-only code into non-debug environment" + (opt_message ? ": " + opt_message : "."));
+  }
+};
+goog.forwardDeclare = function(name) {
+};
+if (!COMPILED) {
+  goog.isProvided_ = function(name) {
+    return name in goog.loadedModules_ || !goog.implicitNamespaces_[name] && goog.isDefAndNotNull(goog.getObjectByName(name));
+  };
+  goog.implicitNamespaces_ = {"goog.module":true};
+}
+goog.getObjectByName = function(name, opt_obj) {
+  var parts = name.split(".");
+  var cur = opt_obj || goog.global;
+  for (var part;part = parts.shift();) {
+    if (goog.isDefAndNotNull(cur[part])) {
+      cur = cur[part];
+    } else {
+      return null;
+    }
+  }
+  return cur;
+};
+goog.globalize = function(obj, opt_global) {
+  var global = opt_global || goog.global;
+  for (var x in obj) {
+    global[x] = obj[x];
+  }
+};
+goog.addDependency = function(relPath, provides, requires, opt_isModule) {
+  if (goog.DEPENDENCIES_ENABLED) {
+    var provide, require;
+    var path = relPath.replace(/\\/g, "/");
+    var deps = goog.dependencies_;
+    for (var i = 0;provide = provides[i];i++) {
+      deps.nameToPath[provide] = path;
+      deps.pathIsModule[path] = !!opt_isModule;
+    }
+    for (var j = 0;require = requires[j];j++) {
+      if (!(path in deps.requires)) {
+        deps.requires[path] = {};
+      }
+      deps.requires[path][require] = true;
+    }
+  }
+};
+goog.define("goog.ENABLE_DEBUG_LOADER", true);
+goog.logToConsole_ = function(msg) {
+  if (goog.global.console) {
+    goog.global.console["error"](msg);
+  }
+};
+goog.require = function(name) {
+  if (!COMPILED) {
+    if (goog.ENABLE_DEBUG_LOADER && goog.IS_OLD_IE_) {
+      goog.maybeProcessDeferredDep_(name);
+    }
+    if (goog.isProvided_(name)) {
+      if (goog.isInModuleLoader_()) {
+        return goog.module.getInternal_(name);
+      } else {
+        return null;
+      }
+    }
+    if (goog.ENABLE_DEBUG_LOADER) {
+      var path = goog.getPathFromDeps_(name);
+      if (path) {
+        goog.included_[path] = true;
+        goog.writeScripts_();
+        return null;
+      }
+    }
+    var errorMessage = "goog.require could not find: " + name;
+    goog.logToConsole_(errorMessage);
+    throw Error(errorMessage);
+  }
+};
+goog.basePath = "";
+goog.global.CLOSURE_BASE_PATH;
+goog.global.CLOSURE_NO_DEPS;
+goog.global.CLOSURE_IMPORT_SCRIPT;
+goog.nullFunction = function() {
+};
+goog.identityFunction = function(opt_returnValue, var_args) {
+  return opt_returnValue;
+};
+goog.abstractMethod = function() {
+  throw Error("unimplemented abstract method");
+};
+goog.addSingletonGetter = function(ctor) {
+  ctor.getInstance = function() {
+    if (ctor.instance_) {
+      return ctor.instance_;
+    }
+    if (goog.DEBUG) {
+      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
+    }
+    return ctor.instance_ = new ctor;
+  };
+};
+goog.instantiatedSingletons_ = [];
+goog.define("goog.LOAD_MODULE_USING_EVAL", true);
+goog.define("goog.SEAL_MODULE_EXPORTS", goog.DEBUG);
+goog.loadedModules_ = {};
+goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
+if (goog.DEPENDENCIES_ENABLED) {
+  goog.included_ = {};
+  goog.dependencies_ = {pathIsModule:{}, nameToPath:{}, requires:{}, visited:{}, written:{}, deferred:{}};
+  goog.inHtmlDocument_ = function() {
+    var doc = goog.global.document;
+    return typeof doc != "undefined" && "write" in doc;
+  };
+  goog.findBasePath_ = function() {
+    if (goog.global.CLOSURE_BASE_PATH) {
+      goog.basePath = goog.global.CLOSURE_BASE_PATH;
+      return;
+    } else {
+      if (!goog.inHtmlDocument_()) {
+        return;
+      }
+    }
+    var doc = goog.global.document;
+    var scripts = doc.getElementsByTagName("script");
+    for (var i = scripts.length - 1;i >= 0;--i) {
+      var script = (scripts[i]);
+      var src = script.src;
+      var qmark = src.lastIndexOf("?");
+      var l = qmark == -1 ? src.length : qmark;
+      if (src.substr(l - 7, 7) == "base.js") {
+        goog.basePath = src.substr(0, l - 7);
+        return;
+      }
+    }
+  };
+  goog.importScript_ = function(src, opt_sourceText) {
+    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
+    if (importScript(src, opt_sourceText)) {
+      goog.dependencies_.written[src] = true;
+    }
+  };
+  goog.IS_OLD_IE_ = !goog.global.atob && goog.global.document && goog.global.document.all;
+  goog.importModule_ = function(src) {
+    var bootstrap = 'goog.retrieveAndExecModule_("' + src + '");';
+    if (goog.importScript_("", bootstrap)) {
+      goog.dependencies_.written[src] = true;
+    }
+  };
+  goog.queuedModules_ = [];
+  goog.wrapModule_ = function(srcUrl, scriptText) {
+    if (!goog.LOAD_MODULE_USING_EVAL || !goog.isDef(goog.global.JSON)) {
+      return "" + "goog.loadModule(function(exports) {" + '"use strict";' + scriptText + "\n" + ";return exports" + "});" + "\n//# sourceURL=" + srcUrl + "\n";
+    } else {
+      return "" + "goog.loadModule(" + goog.global.JSON.stringify(scriptText + "\n//# sourceURL=" + srcUrl + "\n") + ");";
+    }
+  };
+  goog.loadQueuedModules_ = function() {
+    var count = goog.queuedModules_.length;
+    if (count > 0) {
+      var queue = goog.queuedModules_;
+      goog.queuedModules_ = [];
+      for (var i = 0;i < count;i++) {
+        var path = queue[i];
+        goog.maybeProcessDeferredPath_(path);
+      }
+    }
+  };
+  goog.maybeProcessDeferredDep_ = function(name) {
+    if (goog.isDeferredModule_(name) && goog.allDepsAreAvailable_(name)) {
+      var path = goog.getPathFromDeps_(name);
+      goog.maybeProcessDeferredPath_(goog.basePath + path);
+    }
+  };
+  goog.isDeferredModule_ = function(name) {
+    var path = goog.getPathFromDeps_(name);
+    if (path && goog.dependencies_.pathIsModule[path]) {
+      var abspath = goog.basePath + path;
+      return abspath in goog.dependencies_.deferred;
+    }
+    return false;
+  };
+  goog.allDepsAreAvailable_ = function(name) {
+    var path = goog.getPathFromDeps_(name);
+    if (path && path in goog.dependencies_.requires) {
+      for (var requireName in goog.dependencies_.requires[path]) {
+        if (!goog.isProvided_(requireName) && !goog.isDeferredModule_(requireName)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+  goog.maybeProcessDeferredPath_ = function(abspath) {
+    if (abspath in goog.dependencies_.deferred) {
+      var src = goog.dependencies_.deferred[abspath];
+      delete goog.dependencies_.deferred[abspath];
+      goog.globalEval(src);
+    }
+  };
+  goog.loadModule = function(moduleDef) {
+    var previousState = goog.moduleLoaderState_;
+    try {
+      goog.moduleLoaderState_ = {moduleName:undefined, declareTestMethods:false};
+      var exports;
+      if (goog.isFunction(moduleDef)) {
+        exports = moduleDef.call(goog.global, {});
+      } else {
+        if (goog.isString(moduleDef)) {
+          exports = goog.loadModuleFromSource_.call(goog.global, moduleDef);
+        } else {
+          throw Error("Invalid module definition");
+        }
+      }
+      var moduleName = goog.moduleLoaderState_.moduleName;
+      if (!goog.isString(moduleName) || !moduleName) {
+        throw Error('Invalid module name "' + moduleName + '"');
+      }
+      if (goog.moduleLoaderState_.declareLegacyNamespace) {
+        goog.constructNamespace_(moduleName, exports);
+      } else {
+        if (goog.SEAL_MODULE_EXPORTS && Object.seal) {
+          Object.seal(exports);
+        }
+      }
+      goog.loadedModules_[moduleName] = exports;
+      if (goog.moduleLoaderState_.declareTestMethods) {
+        for (var entry in exports) {
+          if (entry.indexOf("test", 0) === 0 || entry == "tearDown" || entry == "setUp" || entry == "setUpPage" || entry == "tearDownPage") {
+            goog.global[entry] = exports[entry];
+          }
+        }
+      }
+    } finally {
+      goog.moduleLoaderState_ = previousState;
+    }
+  };
+  goog.loadModuleFromSource_ = function(source) {
+    var exports = {};
+    eval(arguments[0]);
+    return exports;
+  };
+  goog.writeScriptTag_ = function(src, opt_sourceText) {
+    if (goog.inHtmlDocument_()) {
+      var doc = goog.global.document;
+      if (doc.readyState == "complete") {
+        var isDeps = /\bdeps.js$/.test(src);
+        if (isDeps) {
+          return false;
+        } else {
+          throw Error('Cannot write "' + src + '" after document load');
+        }
+      }
+      var isOldIE = goog.IS_OLD_IE_;
+      if (opt_sourceText === undefined) {
+        if (!isOldIE) {
+          doc.write('<script type="text/javascript" src="' + src + '"></' + "script>");
+        } else {
+          var state = " onreadystatechange='goog.onScriptLoad_(this, " + ++goog.lastNonModuleScriptIndex_ + ")' ";
+          doc.write('<script type="text/javascript" src="' + src + '"' + state + "></" + "script>");
+        }
+      } else {
+        doc.write('<script type="text/javascript">' + opt_sourceText + "</" + "script>");
+      }
+      return true;
+    } else {
+      return false;
+    }
+  };
+  goog.lastNonModuleScriptIndex_ = 0;
+  goog.onScriptLoad_ = function(script, scriptIndex) {
+    if (script.readyState == "complete" && goog.lastNonModuleScriptIndex_ == scriptIndex) {
+      goog.loadQueuedModules_();
+    }
+    return true;
+  };
+  goog.writeScripts_ = function() {
+    var scripts = [];
+    var seenScript = {};
+    var deps = goog.dependencies_;
+    function visitNode(path) {
+      if (path in deps.written) {
+        return;
+      }
+      if (path in deps.visited) {
+        if (!(path in seenScript)) {
+          seenScript[path] = true;
+          scripts.push(path);
+        }
+        return;
+      }
+      deps.visited[path] = true;
+      if (path in deps.requires) {
+        for (var requireName in deps.requires[path]) {
+          if (!goog.isProvided_(requireName)) {
+            if (requireName in deps.nameToPath) {
+              visitNode(deps.nameToPath[requireName]);
+            } else {
+              throw Error("Undefined nameToPath for " + requireName);
+            }
+          }
+        }
+      }
+      if (!(path in seenScript)) {
+        seenScript[path] = true;
+        scripts.push(path);
+      }
+    }
+    for (var path in goog.included_) {
+      if (!deps.written[path]) {
+        visitNode(path);
+      }
+    }
+    for (var i = 0;i < scripts.length;i++) {
+      var path = scripts[i];
+      goog.dependencies_.written[path] = true;
+    }
+    var moduleState = goog.moduleLoaderState_;
+    goog.moduleLoaderState_ = null;
+    var loadingModule = false;
+    for (var i = 0;i < scripts.length;i++) {
+      var path = scripts[i];
+      if (path) {
+        if (!deps.pathIsModule[path]) {
+          goog.importScript_(goog.basePath + path);
+        } else {
+          loadingModule = true;
+          goog.importModule_(goog.basePath + path);
+        }
+      } else {
+        goog.moduleLoaderState_ = moduleState;
+        throw Error("Undefined script input");
+      }
+    }
+    goog.moduleLoaderState_ = moduleState;
+  };
+  goog.getPathFromDeps_ = function(rule) {
+    if (rule in goog.dependencies_.nameToPath) {
+      return goog.dependencies_.nameToPath[rule];
+    } else {
+      return null;
+    }
+  };
+  goog.findBasePath_();
+  if (!goog.global.CLOSURE_NO_DEPS) {
+    goog.importScript_(goog.basePath + "deps.js");
+  }
+}
+goog.normalizePath_ = function(path) {
+  var components = path.split("/");
+  var i = 0;
+  while (i < components.length) {
+    if (components[i] == ".") {
+      components.splice(i, 1);
+    } else {
+      if (i && components[i] == ".." && components[i - 1] && components[i - 1] != "..") {
+        components.splice(--i, 2);
+      } else {
+        i++;
+      }
+    }
+  }
+  return components.join("/");
+};
+goog.retrieveAndExecModule_ = function(src) {
+  if (!COMPILED) {
+    var originalPath = src;
+    src = goog.normalizePath_(src);
+    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
+    var scriptText = null;
+    var xhr = new goog.global["XMLHttpRequest"];
+    xhr.onload = function() {
+      scriptText = this.responseText;
+    };
+    xhr.open("get", src, false);
+    xhr.send();
+    scriptText = xhr.responseText;
+    if (scriptText != null) {
+      var execModuleScript = goog.wrapModule_(src, scriptText);
+      var isOldIE = goog.IS_OLD_IE_;
+      if (isOldIE) {
+        goog.dependencies_.deferred[originalPath] = execModuleScript;
+        goog.queuedModules_.push(originalPath);
+      } else {
+        importScript(src, execModuleScript);
+      }
+    } else {
+      throw new Error("load of " + src + "failed");
+    }
+  }
+};
+goog.typeOf = function(value) {
+  var s = typeof value;
+  if (s == "object") {
+    if (value) {
+      if (value instanceof Array) {
+        return "array";
+      } else {
+        if (value instanceof Object) {
+          return s;
+        }
+      }
+      var className = Object.prototype.toString.call((value));
+      if (className == "[object Window]") {
+        return "object";
+      }
+      if (className == "[object Array]" || typeof value.length == "number" && typeof value.splice != "undefined" && typeof value.propertyIsEnumerable != "undefined" && !value.propertyIsEnumerable("splice")) {
+        return "array";
+      }
+      if (className == "[object Function]" || typeof value.call != "undefined" && typeof value.propertyIsEnumerable != "undefined" && !value.propertyIsEnumerable("call")) {
+        return "function";
+      }
+    } else {
+      return "null";
+    }
+  } else {
+    if (s == "function" && typeof value.call == "undefined") {
+      return "object";
+    }
+  }
+  return s;
+};
+goog.isNull = function(val) {
+  return val === null;
+};
+goog.isDefAndNotNull = function(val) {
+  return val != null;
+};
+goog.isArray = function(val) {
+  return goog.typeOf(val) == "array";
+};
+goog.isArrayLike = function(val) {
+  var type = goog.typeOf(val);
+  return type == "array" || type == "object" && typeof val.length == "number";
+};
+goog.isDateLike = function(val) {
+  return goog.isObject(val) && typeof val.getFullYear == "function";
+};
+goog.isString = function(val) {
+  return typeof val == "string";
+};
+goog.isBoolean = function(val) {
+  return typeof val == "boolean";
+};
+goog.isNumber = function(val) {
+  return typeof val == "number";
+};
+goog.isFunction = function(val) {
+  return goog.typeOf(val) == "function";
+};
+goog.isObject = function(val) {
+  var type = typeof val;
+  return type == "object" && val != null || type == "function";
+};
+goog.getUid = function(obj) {
+  return obj[goog.UID_PROPERTY_] || (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
+};
+goog.hasUid = function(obj) {
+  return!!obj[goog.UID_PROPERTY_];
+};
+goog.removeUid = function(obj) {
+  if ("removeAttribute" in obj) {
+    obj.removeAttribute(goog.UID_PROPERTY_);
+  }
+  try {
+    delete obj[goog.UID_PROPERTY_];
+  } catch (ex) {
+  }
+};
+goog.UID_PROPERTY_ = "closure_uid_" + (Math.random() * 1E9 >>> 0);
+goog.uidCounter_ = 0;
+goog.getHashCode = goog.getUid;
+goog.removeHashCode = goog.removeUid;
+goog.cloneObject = function(obj) {
+  var type = goog.typeOf(obj);
+  if (type == "object" || type == "array") {
+    if (obj.clone) {
+      return obj.clone();
+    }
+    var clone = type == "array" ? [] : {};
+    for (var key in obj) {
+      clone[key] = goog.cloneObject(obj[key]);
+    }
+    return clone;
+  }
+  return obj;
+};
+goog.bindNative_ = function(fn, selfObj, var_args) {
+  return(fn.call.apply(fn.bind, arguments));
+};
+goog.bindJs_ = function(fn, selfObj, var_args) {
+  if (!fn) {
+    throw new Error;
+  }
+  if (arguments.length > 2) {
+    var boundArgs = Array.prototype.slice.call(arguments, 2);
+    return function() {
+      var newArgs = Array.prototype.slice.call(arguments);
+      Array.prototype.unshift.apply(newArgs, boundArgs);
+      return fn.apply(selfObj, newArgs);
+    };
+  } else {
+    return function() {
+      return fn.apply(selfObj, arguments);
+    };
+  }
+};
+goog.bind = function(fn, selfObj, var_args) {
+  if (Function.prototype.bind && Function.prototype.bind.toString().indexOf("native code") != -1) {
+    goog.bind = goog.bindNative_;
+  } else {
+    goog.bind = goog.bindJs_;
+  }
+  return goog.bind.apply(null, arguments);
+};
+goog.partial = function(fn, var_args) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  return function() {
+    var newArgs = args.slice();
+    newArgs.push.apply(newArgs, arguments);
+    return fn.apply(this, newArgs);
+  };
+};
+goog.mixin = function(target, source) {
+  for (var x in source) {
+    target[x] = source[x];
+  }
+};
+goog.now = goog.TRUSTED_SITE && Date.now || function() {
+  return+new Date;
+};
+goog.globalEval = function(script) {
+  if (goog.global.execScript) {
+    goog.global.execScript(script, "JavaScript");
+  } else {
+    if (goog.global.eval) {
+      if (goog.evalWorksForGlobals_ == null) {
+        goog.global.eval("var _et_ = 1;");
+        if (typeof goog.global["_et_"] != "undefined") {
+          delete goog.global["_et_"];
+          goog.evalWorksForGlobals_ = true;
+        } else {
+          goog.evalWorksForGlobals_ = false;
+        }
+      }
+      if (goog.evalWorksForGlobals_) {
+        goog.global.eval(script);
+      } else {
+        var doc = goog.global.document;
+        var scriptElt = doc.createElement("script");
+        scriptElt.type = "text/javascript";
+        scriptElt.defer = false;
+        scriptElt.appendChild(doc.createTextNode(script));
+        doc.body.appendChild(scriptElt);
+        doc.body.removeChild(scriptElt);
+      }
+    } else {
+      throw Error("goog.globalEval not available");
+    }
+  }
+};
+goog.evalWorksForGlobals_ = null;
+goog.cssNameMapping_;
+goog.cssNameMappingStyle_;
+goog.getCssName = function(className, opt_modifier) {
+  var getMapping = function(cssName) {
+    return goog.cssNameMapping_[cssName] || cssName;
+  };
+  var renameByParts = function(cssName) {
+    var parts = cssName.split("-");
+    var mapped = [];
+    for (var i = 0;i < parts.length;i++) {
+      mapped.push(getMapping(parts[i]));
+    }
+    return mapped.join("-");
+  };
+  var rename;
+  if (goog.cssNameMapping_) {
+    rename = goog.cssNameMappingStyle_ == "BY_WHOLE" ? getMapping : renameByParts;
+  } else {
+    rename = function(a) {
+      return a;
+    };
+  }
+  if (opt_modifier) {
+    return className + "-" + rename(opt_modifier);
+  } else {
+    return rename(className);
+  }
+};
+goog.setCssNameMapping = function(mapping, opt_style) {
+  goog.cssNameMapping_ = mapping;
+  goog.cssNameMappingStyle_ = opt_style;
+};
+goog.global.CLOSURE_CSS_NAME_MAPPING;
+if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
+  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
+}
+goog.getMsg = function(str, opt_values) {
+  if (opt_values) {
+    str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
+      return key in opt_values ? opt_values[key] : match;
+    });
+  }
+  return str;
+};
+goog.getMsgWithFallback = function(a, b) {
+  return a;
+};
+goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
+  goog.exportPath_(publicPath, object, opt_objectToExportTo);
+};
+goog.exportProperty = function(object, publicName, symbol) {
+  object[publicName] = symbol;
+};
+goog.inherits = function(childCtor, parentCtor) {
+  function tempCtor() {
+  }
+  tempCtor.prototype = parentCtor.prototype;
+  childCtor.superClass_ = parentCtor.prototype;
+  childCtor.prototype = new tempCtor;
+  childCtor.prototype.constructor = childCtor;
+  childCtor.base = function(me, methodName, var_args) {
+    var args = new Array(arguments.length - 2);
+    for (var i = 2;i < arguments.length;i++) {
+      args[i - 2] = arguments[i];
+    }
+    return parentCtor.prototype[methodName].apply(me, args);
+  };
+};
+goog.base = function(me, opt_methodName, var_args) {
+  var caller = arguments.callee.caller;
+  if (goog.STRICT_MODE_COMPATIBLE || goog.DEBUG && !caller) {
+    throw Error("arguments.caller not defined.  goog.base() cannot be used " + "with strict mode code. See " + "http://www.ecma-international.org/ecma-262/5.1/#sec-C");
+  }
+  if (caller.superClass_) {
+    var ctorArgs = new Array(arguments.length - 1);
+    for (var i = 1;i < arguments.length;i++) {
+      ctorArgs[i - 1] = arguments[i];
+    }
+    return caller.superClass_.constructor.apply(me, ctorArgs);
+  }
+  var args = new Array(arguments.length - 2);
+  for (var i = 2;i < arguments.length;i++) {
+    args[i - 2] = arguments[i];
+  }
+  var foundCaller = false;
+  for (var ctor = me.constructor;ctor;ctor = ctor.superClass_ && ctor.superClass_.constructor) {
+    if (ctor.prototype[opt_methodName] === caller) {
+      foundCaller = true;
+    } else {
+      if (foundCaller) {
+        return ctor.prototype[opt_methodName].apply(me, args);
+      }
+    }
+  }
+  if (me[opt_methodName] === caller) {
+    return me.constructor.prototype[opt_methodName].apply(me, args);
+  } else {
+    throw Error("goog.base called from a method of one name " + "to a method of a different name");
+  }
+};
+goog.scope = function(fn) {
+  fn.call(goog.global);
+};
+if (!COMPILED) {
+  goog.global["COMPILED"] = COMPILED;
+}
+goog.defineClass = function(superClass, def) {
+  var constructor = def.constructor;
+  var statics = def.statics;
+  if (!constructor || constructor == Object.prototype.constructor) {
+    constructor = function() {
+      throw Error("cannot instantiate an interface (no constructor defined).");
+    };
+  }
+  var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
+  if (superClass) {
+    goog.inherits(cls, superClass);
+  }
+  delete def.constructor;
+  delete def.statics;
+  goog.defineClass.applyProperties_(cls.prototype, def);
+  if (statics != null) {
+    if (statics instanceof Function) {
+      statics(cls);
+    } else {
+      goog.defineClass.applyProperties_(cls, statics);
+    }
+  }
+  return cls;
+};
+goog.defineClass.ClassDescriptor;
+goog.define("goog.defineClass.SEAL_CLASS_INSTANCES", goog.DEBUG);
+goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
+  if (goog.defineClass.SEAL_CLASS_INSTANCES && Object.seal instanceof Function) {
+    if (superClass && superClass.prototype && superClass.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_]) {
+      return ctr;
+    }
+    var wrappedCtr = function() {
+      var instance = ctr.apply(this, arguments) || this;
+      instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
+      if (this.constructor === wrappedCtr) {
+        Object.seal(instance);
+      }
+      return instance;
+    };
+    return wrappedCtr;
+  }
+  return ctr;
+};
+goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
+goog.defineClass.applyProperties_ = function(target, source) {
+  var key;
+  for (key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      target[key] = source[key];
+    }
+  }
+  for (var i = 0;i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;i++) {
+    key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      target[key] = source[key];
+    }
+  }
+};
+goog.tagUnsealableClass = function(ctr) {
+  if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
+    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
+  }
+};
+goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = "goog_defineClass_legacy_unsealable";
+goog.provide("goog.debug.Error");
+goog.debug.Error = function(opt_msg) {
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, goog.debug.Error);
+  } else {
+    var stack = (new Error).stack;
+    if (stack) {
+      this.stack = stack;
+    }
+  }
+  if (opt_msg) {
+    this.message = String(opt_msg);
+  }
+};
+goog.inherits(goog.debug.Error, Error);
+goog.debug.Error.prototype.name = "CustomError";
+goog.provide("goog.object");
+goog.object.forEach = function(obj, f, opt_obj) {
+  for (var key in obj) {
+    f.call(opt_obj, obj[key], key, obj);
+  }
+};
+goog.object.filter = function(obj, f, opt_obj) {
+  var res = {};
+  for (var key in obj) {
+    if (f.call(opt_obj, obj[key], key, obj)) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+};
+goog.object.map = function(obj, f, opt_obj) {
+  var res = {};
+  for (var key in obj) {
+    res[key] = f.call(opt_obj, obj[key], key, obj);
+  }
+  return res;
+};
+goog.object.some = function(obj, f, opt_obj) {
+  for (var key in obj) {
+    if (f.call(opt_obj, obj[key], key, obj)) {
+      return true;
+    }
+  }
+  return false;
+};
+goog.object.every = function(obj, f, opt_obj) {
+  for (var key in obj) {
+    if (!f.call(opt_obj, obj[key], key, obj)) {
+      return false;
+    }
+  }
+  return true;
+};
+goog.object.getCount = function(obj) {
+  var rv = 0;
+  for (var key in obj) {
+    rv++;
+  }
+  return rv;
+};
+goog.object.getAnyKey = function(obj) {
+  for (var key in obj) {
+    return key;
+  }
+};
+goog.object.getAnyValue = function(obj) {
+  for (var key in obj) {
+    return obj[key];
+  }
+};
+goog.object.contains = function(obj, val) {
+  return goog.object.containsValue(obj, val);
+};
+goog.object.getValues = function(obj) {
+  var res = [];
+  var i = 0;
+  for (var key in obj) {
+    res[i++] = obj[key];
+  }
+  return res;
+};
+goog.object.getKeys = function(obj) {
+  var res = [];
+  var i = 0;
+  for (var key in obj) {
+    res[i++] = key;
+  }
+  return res;
+};
+goog.object.getValueByKeys = function(obj, var_args) {
+  var isArrayLike = goog.isArrayLike(var_args);
+  var keys = isArrayLike ? var_args : arguments;
+  for (var i = isArrayLike ? 0 : 1;i < keys.length;i++) {
+    obj = obj[keys[i]];
+    if (!goog.isDef(obj)) {
+      break;
+    }
+  }
+  return obj;
+};
+goog.object.containsKey = function(obj, key) {
+  return key in obj;
+};
+goog.object.containsValue = function(obj, val) {
+  for (var key in obj) {
+    if (obj[key] == val) {
+      return true;
+    }
+  }
+  return false;
+};
+goog.object.findKey = function(obj, f, opt_this) {
+  for (var key in obj) {
+    if (f.call(opt_this, obj[key], key, obj)) {
+      return key;
+    }
+  }
+  return undefined;
+};
+goog.object.findValue = function(obj, f, opt_this) {
+  var key = goog.object.findKey(obj, f, opt_this);
+  return key && obj[key];
+};
+goog.object.isEmpty = function(obj) {
+  for (var key in obj) {
+    return false;
+  }
+  return true;
+};
+goog.object.clear = function(obj) {
+  for (var i in obj) {
+    delete obj[i];
+  }
+};
+goog.object.remove = function(obj, key) {
+  var rv;
+  if (rv = key in obj) {
+    delete obj[key];
+  }
+  return rv;
+};
+goog.object.add = function(obj, key, val) {
+  if (key in obj) {
+    throw Error('The object already contains the key "' + key + '"');
+  }
+  goog.object.set(obj, key, val);
+};
+goog.object.get = function(obj, key, opt_val) {
+  if (key in obj) {
+    return obj[key];
+  }
+  return opt_val;
+};
+goog.object.set = function(obj, key, value) {
+  obj[key] = value;
+};
+goog.object.setIfUndefined = function(obj, key, value) {
+  return key in obj ? obj[key] : obj[key] = value;
+};
+goog.object.setWithReturnValueIfNotSet = function(obj, key, f) {
+  if (key in obj) {
+    return obj[key];
+  }
+  var val = f();
+  obj[key] = val;
+  return val;
+};
+goog.object.equals = function(a, b) {
+  for (var k in a) {
+    if (!(k in b) || a[k] !== b[k]) {
+      return false;
+    }
+  }
+  for (var k in b) {
+    if (!(k in a)) {
+      return false;
+    }
+  }
+  return true;
+};
+goog.object.clone = function(obj) {
+  var res = {};
+  for (var key in obj) {
+    res[key] = obj[key];
+  }
+  return res;
+};
+goog.object.unsafeClone = function(obj) {
+  var type = goog.typeOf(obj);
+  if (type == "object" || type == "array") {
+    if (obj.clone) {
+      return obj.clone();
+    }
+    var clone = type == "array" ? [] : {};
+    for (var key in obj) {
+      clone[key] = goog.object.unsafeClone(obj[key]);
+    }
+    return clone;
+  }
+  return obj;
+};
+goog.object.transpose = function(obj) {
+  var transposed = {};
+  for (var key in obj) {
+    transposed[obj[key]] = key;
+  }
+  return transposed;
+};
+goog.object.PROTOTYPE_FIELDS_ = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
+goog.object.extend = function(target, var_args) {
+  var key, source;
+  for (var i = 1;i < arguments.length;i++) {
+    source = arguments[i];
+    for (key in source) {
+      target[key] = source[key];
+    }
+    for (var j = 0;j < goog.object.PROTOTYPE_FIELDS_.length;j++) {
+      key = goog.object.PROTOTYPE_FIELDS_[j];
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+};
+goog.object.create = function(var_args) {
+  var argLength = arguments.length;
+  if (argLength == 1 && goog.isArray(arguments[0])) {
+    return goog.object.create.apply(null, arguments[0]);
+  }
+  if (argLength % 2) {
+    throw Error("Uneven number of arguments");
+  }
+  var rv = {};
+  for (var i = 0;i < argLength;i += 2) {
+    rv[arguments[i]] = arguments[i + 1];
+  }
+  return rv;
+};
+goog.object.createSet = function(var_args) {
+  var argLength = arguments.length;
+  if (argLength == 1 && goog.isArray(arguments[0])) {
+    return goog.object.createSet.apply(null, arguments[0]);
+  }
+  var rv = {};
+  for (var i = 0;i < argLength;i++) {
+    rv[arguments[i]] = true;
+  }
+  return rv;
+};
+goog.object.createImmutableView = function(obj) {
+  var result = obj;
+  if (Object.isFrozen && !Object.isFrozen(obj)) {
+    result = Object.create(obj);
+    Object.freeze(result);
+  }
+  return result;
+};
+goog.object.isImmutableView = function(obj) {
+  return!!Object.isFrozen && Object.isFrozen(obj);
+};
+goog.provide("goog.dom.NodeType");
+goog.dom.NodeType = {ELEMENT:1, ATTRIBUTE:2, TEXT:3, CDATA_SECTION:4, ENTITY_REFERENCE:5, ENTITY:6, PROCESSING_INSTRUCTION:7, COMMENT:8, DOCUMENT:9, DOCUMENT_TYPE:10, DOCUMENT_FRAGMENT:11, NOTATION:12};
+goog.provide("goog.json");
+goog.provide("goog.json.Replacer");
+goog.provide("goog.json.Reviver");
+goog.provide("goog.json.Serializer");
+goog.define("goog.json.USE_NATIVE_JSON", false);
+goog.json.isValid = function(s) {
+  if (/^\s*$/.test(s)) {
+    return false;
+  }
+  var backslashesRe = /\\["\\\/bfnrtu]/g;
+  var simpleValuesRe = /"[^"\\\n\r\u2028\u2029\x00-\x08\x0a-\x1f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
+  var openBracketsRe = /(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g;
+  var remainderRe = /^[\],:{}\s\u2028\u2029]*$/;
+  return remainderRe.test(s.replace(backslashesRe, "@").replace(simpleValuesRe, "]").replace(openBracketsRe, ""));
+};
+goog.json.parse = goog.json.USE_NATIVE_JSON ? (goog.global["JSON"]["parse"]) : function(s) {
+  var o = String(s);
+  if (goog.json.isValid(o)) {
+    try {
+      return(eval("(" + o + ")"));
+    } catch (ex) {
+    }
+  }
+  throw Error("Invalid JSON string: " + o);
+};
+goog.json.unsafeParse = goog.json.USE_NATIVE_JSON ? (goog.global["JSON"]["parse"]) : function(s) {
+  return(eval("(" + s + ")"));
+};
+goog.json.Replacer;
+goog.json.Reviver;
+goog.json.serialize = goog.json.USE_NATIVE_JSON ? (goog.global["JSON"]["stringify"]) : function(object, opt_replacer) {
+  return(new goog.json.Serializer(opt_replacer)).serialize(object);
+};
+goog.json.Serializer = function(opt_replacer) {
+  this.replacer_ = opt_replacer;
+};
+goog.json.Serializer.prototype.serialize = function(object) {
+  var sb = [];
+  this.serializeInternal(object, sb);
+  return sb.join("");
+};
+goog.json.Serializer.prototype.serializeInternal = function(object, sb) {
+  switch(typeof object) {
+    case "string":
+      this.serializeString_((object), sb);
+      break;
+    case "number":
+      this.serializeNumber_((object), sb);
+      break;
+    case "boolean":
+      sb.push(object);
+      break;
+    case "undefined":
+      sb.push("null");
+      break;
+    case "object":
+      if (object == null) {
+        sb.push("null");
+        break;
+      }
+      if (goog.isArray(object)) {
+        this.serializeArray((object), sb);
+        break;
+      }
+      this.serializeObject_((object), sb);
+      break;
+    case "function":
+      break;
+    default:
+      throw Error("Unknown type: " + typeof object);;
+  }
+};
+goog.json.Serializer.charToJsonCharCache_ = {'"':'\\"', "\\":"\\\\", "/":"\\/", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\u000b"};
+goog.json.Serializer.charsToReplace_ = /\uffff/.test("\uffff") ? /[\\\"\x00-\x1f\x7f-\uffff]/g : /[\\\"\x00-\x1f\x7f-\xff]/g;
+goog.json.Serializer.prototype.serializeString_ = function(s, sb) {
+  sb.push('"', s.replace(goog.json.Serializer.charsToReplace_, function(c) {
+    if (c in goog.json.Serializer.charToJsonCharCache_) {
+      return goog.json.Serializer.charToJsonCharCache_[c];
+    }
+    var cc = c.charCodeAt(0);
+    var rv = "\\u";
+    if (cc < 16) {
+      rv += "000";
+    } else {
+      if (cc < 256) {
+        rv += "00";
+      } else {
+        if (cc < 4096) {
+          rv += "0";
+        }
+      }
+    }
+    return goog.json.Serializer.charToJsonCharCache_[c] = rv + cc.toString(16);
+  }), '"');
+};
+goog.json.Serializer.prototype.serializeNumber_ = function(n, sb) {
+  sb.push(isFinite(n) && !isNaN(n) ? n : "null");
+};
+goog.json.Serializer.prototype.serializeArray = function(arr, sb) {
+  var l = arr.length;
+  sb.push("[");
+  var sep = "";
+  for (var i = 0;i < l;i++) {
+    sb.push(sep);
+    var value = arr[i];
+    this.serializeInternal(this.replacer_ ? this.replacer_.call(arr, String(i), value) : value, sb);
+    sep = ",";
+  }
+  sb.push("]");
+};
+goog.json.Serializer.prototype.serializeObject_ = function(obj, sb) {
+  sb.push("{");
+  var sep = "";
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var value = obj[key];
+      if (typeof value != "function") {
+        sb.push(sep);
+        this.serializeString_(key, sb);
+        sb.push(":");
+        this.serializeInternal(this.replacer_ ? this.replacer_.call(obj, key, value) : value, sb);
+        sep = ",";
+      }
+    }
+  }
+  sb.push("}");
+};
+goog.provide("goog.string");
+goog.provide("goog.string.Unicode");
+goog.define("goog.string.DETECT_DOUBLE_ESCAPING", false);
+goog.define("goog.string.FORCE_NON_DOM_HTML_UNESCAPING", false);
+goog.string.Unicode = {NBSP:"\u00a0"};
+goog.string.startsWith = function(str, prefix) {
+  return str.lastIndexOf(prefix, 0) == 0;
+};
+goog.string.endsWith = function(str, suffix) {
+  var l = str.length - suffix.length;
+  return l >= 0 && str.indexOf(suffix, l) == l;
+};
+goog.string.caseInsensitiveStartsWith = function(str, prefix) {
+  return goog.string.caseInsensitiveCompare(prefix, str.substr(0, prefix.length)) == 0;
+};
+goog.string.caseInsensitiveEndsWith = function(str, suffix) {
+  return goog.string.caseInsensitiveCompare(suffix, str.substr(str.length - suffix.length, suffix.length)) == 0;
+};
+goog.string.caseInsensitiveEquals = function(str1, str2) {
+  return str1.toLowerCase() == str2.toLowerCase();
+};
+goog.string.subs = function(str, var_args) {
+  var splitParts = str.split("%s");
+  var returnString = "";
+  var subsArguments = Array.prototype.slice.call(arguments, 1);
+  while (subsArguments.length && splitParts.length > 1) {
+    returnString += splitParts.shift() + subsArguments.shift();
+  }
+  return returnString + splitParts.join("%s");
+};
+goog.string.collapseWhitespace = function(str) {
+  return str.replace(/[\s\xa0]+/g, " ").replace(/^\s+|\s+$/g, "");
+};
+goog.string.isEmptyOrWhitespace = function(str) {
+  return/^[\s\xa0]*$/.test(str);
+};
+goog.string.isEmptyString = function(str) {
+  return str.length == 0;
+};
+goog.string.isEmpty = goog.string.isEmptyOrWhitespace;
+goog.string.isEmptyOrWhitespaceSafe = function(str) {
+  return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(str));
+};
+goog.string.isEmptySafe = goog.string.isEmptyOrWhitespaceSafe;
+goog.string.isBreakingWhitespace = function(str) {
+  return!/[^\t\n\r ]/.test(str);
+};
+goog.string.isAlpha = function(str) {
+  return!/[^a-zA-Z]/.test(str);
+};
+goog.string.isNumeric = function(str) {
+  return!/[^0-9]/.test(str);
+};
+goog.string.isAlphaNumeric = function(str) {
+  return!/[^a-zA-Z0-9]/.test(str);
+};
+goog.string.isSpace = function(ch) {
+  return ch == " ";
+};
+goog.string.isUnicodeChar = function(ch) {
+  return ch.length == 1 && ch >= " " && ch <= "~" || ch >= "\u0080" && ch <= "\ufffd";
+};
+goog.string.stripNewlines = function(str) {
+  return str.replace(/(\r\n|\r|\n)+/g, " ");
+};
+goog.string.canonicalizeNewlines = function(str) {
+  return str.replace(/(\r\n|\r|\n)/g, "\n");
+};
+goog.string.normalizeWhitespace = function(str) {
+  return str.replace(/\xa0|\s/g, " ");
+};
+goog.string.normalizeSpaces = function(str) {
+  return str.replace(/\xa0|[ \t]+/g, " ");
+};
+goog.string.collapseBreakingSpaces = function(str) {
+  return str.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, "");
+};
+goog.string.trim = goog.TRUSTED_SITE && String.prototype.trim ? function(str) {
+  return str.trim();
+} : function(str) {
+  return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
+};
+goog.string.trimLeft = function(str) {
+  return str.replace(/^[\s\xa0]+/, "");
+};
+goog.string.trimRight = function(str) {
+  return str.replace(/[\s\xa0]+$/, "");
+};
+goog.string.caseInsensitiveCompare = function(str1, str2) {
+  var test1 = String(str1).toLowerCase();
+  var test2 = String(str2).toLowerCase();
+  if (test1 < test2) {
+    return-1;
+  } else {
+    if (test1 == test2) {
+      return 0;
+    } else {
+      return 1;
+    }
+  }
+};
+goog.string.numerateCompareRegExp_ = /(\.\d+)|(\d+)|(\D+)/g;
+goog.string.numerateCompare = function(str1, str2) {
+  if (str1 == str2) {
+    return 0;
+  }
+  if (!str1) {
+    return-1;
+  }
+  if (!str2) {
+    return 1;
+  }
+  var tokens1 = str1.toLowerCase().match(goog.string.numerateCompareRegExp_);
+  var tokens2 = str2.toLowerCase().match(goog.string.numerateCompareRegExp_);
+  var count = Math.min(tokens1.length, tokens2.length);
+  for (var i = 0;i < count;i++) {
+    var a = tokens1[i];
+    var b = tokens2[i];
+    if (a != b) {
+      var num1 = parseInt(a, 10);
+      if (!isNaN(num1)) {
+        var num2 = parseInt(b, 10);
+        if (!isNaN(num2) && num1 - num2) {
+          return num1 - num2;
+        }
+      }
+      return a < b ? -1 : 1;
+    }
+  }
+  if (tokens1.length != tokens2.length) {
+    return tokens1.length - tokens2.length;
+  }
+  return str1 < str2 ? -1 : 1;
+};
+goog.string.urlEncode = function(str) {
+  return encodeURIComponent(String(str));
+};
+goog.string.urlDecode = function(str) {
+  return decodeURIComponent(str.replace(/\+/g, " "));
+};
+goog.string.newLineToBr = function(str, opt_xml) {
+  return str.replace(/(\r\n|\r|\n)/g, opt_xml ? "<br />" : "<br>");
+};
+goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
+  if (opt_isLikelyToContainHtmlChars) {
+    str = str.replace(goog.string.AMP_RE_, "&amp;").replace(goog.string.LT_RE_, "&lt;").replace(goog.string.GT_RE_, "&gt;").replace(goog.string.QUOT_RE_, "&quot;").replace(goog.string.SINGLE_QUOTE_RE_, "&#39;").replace(goog.string.NULL_RE_, "&#0;");
+    if (goog.string.DETECT_DOUBLE_ESCAPING) {
+      str = str.replace(goog.string.E_RE_, "&#101;");
+    }
+    return str;
+  } else {
+    if (!goog.string.ALL_RE_.test(str)) {
+      return str;
+    }
+    if (str.indexOf("&") != -1) {
+      str = str.replace(goog.string.AMP_RE_, "&amp;");
+    }
+    if (str.indexOf("<") != -1) {
+      str = str.replace(goog.string.LT_RE_, "&lt;");
+    }
+    if (str.indexOf(">") != -1) {
+      str = str.replace(goog.string.GT_RE_, "&gt;");
+    }
+    if (str.indexOf('"') != -1) {
+      str = str.replace(goog.string.QUOT_RE_, "&quot;");
+    }
+    if (str.indexOf("'") != -1) {
+      str = str.replace(goog.string.SINGLE_QUOTE_RE_, "&#39;");
+    }
+    if (str.indexOf("\x00") != -1) {
+      str = str.replace(goog.string.NULL_RE_, "&#0;");
+    }
+    if (goog.string.DETECT_DOUBLE_ESCAPING && str.indexOf("e") != -1) {
+      str = str.replace(goog.string.E_RE_, "&#101;");
+    }
+    return str;
+  }
+};
+goog.string.AMP_RE_ = /&/g;
+goog.string.LT_RE_ = /</g;
+goog.string.GT_RE_ = />/g;
+goog.string.QUOT_RE_ = /"/g;
+goog.string.SINGLE_QUOTE_RE_ = /'/g;
+goog.string.NULL_RE_ = /\x00/g;
+goog.string.E_RE_ = /e/g;
+goog.string.ALL_RE_ = goog.string.DETECT_DOUBLE_ESCAPING ? /[\x00&<>"'e]/ : /[\x00&<>"']/;
+goog.string.unescapeEntities = function(str) {
+  if (goog.string.contains(str, "&")) {
+    if (!goog.string.FORCE_NON_DOM_HTML_UNESCAPING && "document" in goog.global) {
+      return goog.string.unescapeEntitiesUsingDom_(str);
+    } else {
+      return goog.string.unescapePureXmlEntities_(str);
+    }
+  }
+  return str;
+};
+goog.string.unescapeEntitiesWithDocument = function(str, document) {
+  if (goog.string.contains(str, "&")) {
+    return goog.string.unescapeEntitiesUsingDom_(str, document);
+  }
+  return str;
+};
+goog.string.unescapeEntitiesUsingDom_ = function(str, opt_document) {
+  var seen = {"&amp;":"&", "&lt;":"<", "&gt;":">", "&quot;":'"'};
+  var div;
+  if (opt_document) {
+    div = opt_document.createElement("div");
+  } else {
+    div = goog.global.document.createElement("div");
+  }
+  return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {
+    var value = seen[s];
+    if (value) {
+      return value;
+    }
+    if (entity.charAt(0) == "#") {
+      var n = Number("0" + entity.substr(1));
+      if (!isNaN(n)) {
+        value = String.fromCharCode(n);
+      }
+    }
+    if (!value) {
+      div.innerHTML = s + " ";
+      value = div.firstChild.nodeValue.slice(0, -1);
+    }
+    return seen[s] = value;
+  });
+};
+goog.string.unescapePureXmlEntities_ = function(str) {
+  return str.replace(/&([^;]+);/g, function(s, entity) {
+    switch(entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return'"';
+      default:
+        if (entity.charAt(0) == "#") {
+          var n = Number("0" + entity.substr(1));
+          if (!isNaN(n)) {
+            return String.fromCharCode(n);
+          }
+        }
+        return s;
+    }
+  });
+};
+goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
+goog.string.whitespaceEscape = function(str, opt_xml) {
+  return goog.string.newLineToBr(str.replace(/  /g, " &#160;"), opt_xml);
+};
+goog.string.preserveSpaces = function(str) {
+  return str.replace(/(^|[\n ]) /g, "$1" + goog.string.Unicode.NBSP);
+};
+goog.string.stripQuotes = function(str, quoteChars) {
+  var length = quoteChars.length;
+  for (var i = 0;i < length;i++) {
+    var quoteChar = length == 1 ? quoteChars : quoteChars.charAt(i);
+    if (str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar) {
+      return str.substring(1, str.length - 1);
+    }
+  }
+  return str;
+};
+goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
+  if (opt_protectEscapedCharacters) {
+    str = goog.string.unescapeEntities(str);
+  }
+  if (str.length > chars) {
+    str = str.substring(0, chars - 3) + "...";
+  }
+  if (opt_protectEscapedCharacters) {
+    str = goog.string.htmlEscape(str);
+  }
+  return str;
+};
+goog.string.truncateMiddle = function(str, chars, opt_protectEscapedCharacters, opt_trailingChars) {
+  if (opt_protectEscapedCharacters) {
+    str = goog.string.unescapeEntities(str);
+  }
+  if (opt_trailingChars && str.length > chars) {
+    if (opt_trailingChars > chars) {
+      opt_trailingChars = chars;
+    }
+    var endPoint = str.length - opt_trailingChars;
+    var startPoint = chars - opt_trailingChars;
+    str = str.substring(0, startPoint) + "..." + str.substring(endPoint);
+  } else {
+    if (str.length > chars) {
+      var half = Math.floor(chars / 2);
+      var endPos = str.length - half;
+      half += chars % 2;
+      str = str.substring(0, half) + "..." + str.substring(endPos);
+    }
+  }
+  if (opt_protectEscapedCharacters) {
+    str = goog.string.htmlEscape(str);
+  }
+  return str;
+};
+goog.string.specialEscapeChars_ = {"\x00":"\\0", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\x0B", '"':'\\"', "\\":"\\\\"};
+goog.string.jsEscapeCache_ = {"'":"\\'"};
+goog.string.quote = function(s) {
+  s = String(s);
+  if (s.quote) {
+    return s.quote();
+  } else {
+    var sb = ['"'];
+    for (var i = 0;i < s.length;i++) {
+      var ch = s.charAt(i);
+      var cc = ch.charCodeAt(0);
+      sb[i + 1] = goog.string.specialEscapeChars_[ch] || (cc > 31 && cc < 127 ? ch : goog.string.escapeChar(ch));
+    }
+    sb.push('"');
+    return sb.join("");
+  }
+};
+goog.string.escapeString = function(str) {
+  var sb = [];
+  for (var i = 0;i < str.length;i++) {
+    sb[i] = goog.string.escapeChar(str.charAt(i));
+  }
+  return sb.join("");
+};
+goog.string.escapeChar = function(c) {
+  if (c in goog.string.jsEscapeCache_) {
+    return goog.string.jsEscapeCache_[c];
+  }
+  if (c in goog.string.specialEscapeChars_) {
+    return goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c];
+  }
+  var rv = c;
+  var cc = c.charCodeAt(0);
+  if (cc > 31 && cc < 127) {
+    rv = c;
+  } else {
+    if (cc < 256) {
+      rv = "\\x";
+      if (cc < 16 || cc > 256) {
+        rv += "0";
+      }
+    } else {
+      rv = "\\u";
+      if (cc < 4096) {
+        rv += "0";
+      }
+    }
+    rv += cc.toString(16).toUpperCase();
+  }
+  return goog.string.jsEscapeCache_[c] = rv;
+};
+goog.string.contains = function(str, subString) {
+  return str.indexOf(subString) != -1;
+};
+goog.string.caseInsensitiveContains = function(str, subString) {
+  return goog.string.contains(str.toLowerCase(), subString.toLowerCase());
+};
+goog.string.countOf = function(s, ss) {
+  return s && ss ? s.split(ss).length - 1 : 0;
+};
+goog.string.removeAt = function(s, index, stringLength) {
+  var resultStr = s;
+  if (index >= 0 && index < s.length && stringLength > 0) {
+    resultStr = s.substr(0, index) + s.substr(index + stringLength, s.length - index - stringLength);
+  }
+  return resultStr;
+};
+goog.string.remove = function(s, ss) {
+  var re = new RegExp(goog.string.regExpEscape(ss), "");
+  return s.replace(re, "");
+};
+goog.string.removeAll = function(s, ss) {
+  var re = new RegExp(goog.string.regExpEscape(ss), "g");
+  return s.replace(re, "");
+};
+goog.string.regExpEscape = function(s) {
+  return String(s).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08");
+};
+goog.string.repeat = function(string, length) {
+  return(new Array(length + 1)).join(string);
+};
+goog.string.padNumber = function(num, length, opt_precision) {
+  var s = goog.isDef(opt_precision) ? num.toFixed(opt_precision) : String(num);
+  var index = s.indexOf(".");
+  if (index == -1) {
+    index = s.length;
+  }
+  return goog.string.repeat("0", Math.max(0, length - index)) + s;
+};
+goog.string.makeSafe = function(obj) {
+  return obj == null ? "" : String(obj);
+};
+goog.string.buildString = function(var_args) {
+  return Array.prototype.join.call(arguments, "");
+};
+goog.string.getRandomString = function() {
+  var x = 2147483648;
+  return Math.floor(Math.random() * x).toString(36) + Math.abs(Math.floor(Math.random() * x) ^ goog.now()).toString(36);
+};
+goog.string.compareVersions = function(version1, version2) {
+  var order = 0;
+  var v1Subs = goog.string.trim(String(version1)).split(".");
+  var v2Subs = goog.string.trim(String(version2)).split(".");
+  var subCount = Math.max(v1Subs.length, v2Subs.length);
+  for (var subIdx = 0;order == 0 && subIdx < subCount;subIdx++) {
+    var v1Sub = v1Subs[subIdx] || "";
+    var v2Sub = v2Subs[subIdx] || "";
+    var v1CompParser = new RegExp("(\\d*)(\\D*)", "g");
+    var v2CompParser = new RegExp("(\\d*)(\\D*)", "g");
+    do {
+      var v1Comp = v1CompParser.exec(v1Sub) || ["", "", ""];
+      var v2Comp = v2CompParser.exec(v2Sub) || ["", "", ""];
+      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) {
+        break;
+      }
+      var v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);
+      var v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);
+      order = goog.string.compareElements_(v1CompNum, v2CompNum) || goog.string.compareElements_(v1Comp[2].length == 0, v2Comp[2].length == 0) || goog.string.compareElements_(v1Comp[2], v2Comp[2]);
+    } while (order == 0);
+  }
+  return order;
+};
+goog.string.compareElements_ = function(left, right) {
+  if (left < right) {
+    return-1;
+  } else {
+    if (left > right) {
+      return 1;
+    }
+  }
+  return 0;
+};
+goog.string.HASHCODE_MAX_ = 4294967296;
+goog.string.hashCode = function(str) {
+  var result = 0;
+  for (var i = 0;i < str.length;++i) {
+    result = 31 * result + str.charCodeAt(i);
+    result %= goog.string.HASHCODE_MAX_;
+  }
+  return result;
+};
+goog.string.uniqueStringCounter_ = Math.random() * 2147483648 | 0;
+goog.string.createUniqueString = function() {
+  return "goog_" + goog.string.uniqueStringCounter_++;
+};
+goog.string.toNumber = function(str) {
+  var num = Number(str);
+  if (num == 0 && goog.string.isEmptyOrWhitespace(str)) {
+    return NaN;
+  }
+  return num;
+};
+goog.string.isLowerCamelCase = function(str) {
+  return/^[a-z]+([A-Z][a-z]*)*$/.test(str);
+};
+goog.string.isUpperCamelCase = function(str) {
+  return/^([A-Z][a-z]*)+$/.test(str);
+};
+goog.string.toCamelCase = function(str) {
+  return String(str).replace(/\-([a-z])/g, function(all, match) {
+    return match.toUpperCase();
+  });
+};
+goog.string.toSelectorCase = function(str) {
+  return String(str).replace(/([A-Z])/g, "-$1").toLowerCase();
+};
+goog.string.toTitleCase = function(str, opt_delimiters) {
+  var delimiters = goog.isString(opt_delimiters) ? goog.string.regExpEscape(opt_delimiters) : "\\s";
+  delimiters = delimiters ? "|[" + delimiters + "]+" : "";
+  var regexp = new RegExp("(^" + delimiters + ")([a-z])", "g");
+  return str.replace(regexp, function(all, p1, p2) {
+    return p1 + p2.toUpperCase();
+  });
+};
+goog.string.capitalize = function(str) {
+  return String(str.charAt(0)).toUpperCase() + String(str.substr(1)).toLowerCase();
+};
+goog.string.parseInt = function(value) {
+  if (isFinite(value)) {
+    value = String(value);
+  }
+  if (goog.isString(value)) {
+    return/^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10);
+  }
+  return NaN;
+};
+goog.string.splitLimit = function(str, separator, limit) {
+  var parts = str.split(separator);
+  var returnVal = [];
+  while (limit > 0 && parts.length) {
+    returnVal.push(parts.shift());
+    limit--;
+  }
+  if (parts.length) {
+    returnVal.push(parts.join(separator));
+  }
+  return returnVal;
+};
+goog.string.editDistance = function(a, b) {
+  var v0 = [];
+  var v1 = [];
+  if (a == b) {
+    return 0;
+  }
+  if (!a.length || !b.length) {
+    return Math.max(a.length, b.length);
+  }
+  for (var i = 0;i < b.length + 1;i++) {
+    v0[i] = i;
+  }
+  for (var i = 0;i < a.length;i++) {
+    v1[0] = i + 1;
+    for (var j = 0;j < b.length;j++) {
+      var cost = a[i] != b[j];
+      v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
+    }
+    for (var j = 0;j < v0.length;j++) {
+      v0[j] = v1[j];
+    }
+  }
+  return v1[b.length];
+};
+goog.provide("goog.labs.userAgent.util");
+goog.require("goog.string");
+goog.labs.userAgent.util.getNativeUserAgentString_ = function() {
+  var navigator = goog.labs.userAgent.util.getNavigator_();
+  if (navigator) {
+    var userAgent = navigator.userAgent;
+    if (userAgent) {
+      return userAgent;
+    }
+  }
+  return "";
+};
+goog.labs.userAgent.util.getNavigator_ = function() {
+  return goog.global.navigator;
+};
+goog.labs.userAgent.util.userAgent_ = goog.labs.userAgent.util.getNativeUserAgentString_();
+goog.labs.userAgent.util.setUserAgent = function(opt_userAgent) {
+  goog.labs.userAgent.util.userAgent_ = opt_userAgent || goog.labs.userAgent.util.getNativeUserAgentString_();
+};
+goog.labs.userAgent.util.getUserAgent = function() {
+  return goog.labs.userAgent.util.userAgent_;
+};
+goog.labs.userAgent.util.matchUserAgent = function(str) {
+  var userAgent = goog.labs.userAgent.util.getUserAgent();
+  return goog.string.contains(userAgent, str);
+};
+goog.labs.userAgent.util.matchUserAgentIgnoreCase = function(str) {
+  var userAgent = goog.labs.userAgent.util.getUserAgent();
+  return goog.string.caseInsensitiveContains(userAgent, str);
+};
+goog.labs.userAgent.util.extractVersionTuples = function(userAgent) {
+  var versionRegExp = new RegExp("(\\w[\\w ]+)" + "/" + "([^\\s]+)" + "\\s*" + "(?:\\((.*?)\\))?", "g");
+  var data = [];
+  var match;
+  while (match = versionRegExp.exec(userAgent)) {
+    data.push([match[1], match[2], match[3] || undefined]);
+  }
+  return data;
+};
+goog.provide("goog.labs.userAgent.platform");
+goog.require("goog.labs.userAgent.util");
+goog.require("goog.string");
+goog.labs.userAgent.platform.isAndroid = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Android");
+};
+goog.labs.userAgent.platform.isIpod = function() {
+  return goog.labs.userAgent.util.matchUserAgent("iPod");
+};
+goog.labs.userAgent.platform.isIphone = function() {
+  return goog.labs.userAgent.util.matchUserAgent("iPhone") && !goog.labs.userAgent.util.matchUserAgent("iPod") && !goog.labs.userAgent.util.matchUserAgent("iPad");
+};
+goog.labs.userAgent.platform.isIpad = function() {
+  return goog.labs.userAgent.util.matchUserAgent("iPad");
+};
+goog.labs.userAgent.platform.isIos = function() {
+  return goog.labs.userAgent.platform.isIphone() || goog.labs.userAgent.platform.isIpad() || goog.labs.userAgent.platform.isIpod();
+};
+goog.labs.userAgent.platform.isMacintosh = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Macintosh");
+};
+goog.labs.userAgent.platform.isLinux = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Linux");
+};
+goog.labs.userAgent.platform.isWindows = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Windows");
+};
+goog.labs.userAgent.platform.isChromeOS = function() {
+  return goog.labs.userAgent.util.matchUserAgent("CrOS");
+};
+goog.labs.userAgent.platform.getVersion = function() {
+  var userAgentString = goog.labs.userAgent.util.getUserAgent();
+  var version = "", re;
+  if (goog.labs.userAgent.platform.isWindows()) {
+    re = /Windows (?:NT|Phone) ([0-9.]+)/;
+    var match = re.exec(userAgentString);
+    if (match) {
+      version = match[1];
+    } else {
+      version = "0.0";
+    }
+  } else {
+    if (goog.labs.userAgent.platform.isIos()) {
+      re = /(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/;
+      var match = re.exec(userAgentString);
+      version = match && match[1].replace(/_/g, ".");
+    } else {
+      if (goog.labs.userAgent.platform.isMacintosh()) {
+        re = /Mac OS X ([0-9_.]+)/;
+        var match = re.exec(userAgentString);
+        version = match ? match[1].replace(/_/g, ".") : "10";
+      } else {
+        if (goog.labs.userAgent.platform.isAndroid()) {
+          re = /Android\s+([^\);]+)(\)|;)/;
+          var match = re.exec(userAgentString);
+          version = match && match[1];
+        } else {
+          if (goog.labs.userAgent.platform.isChromeOS()) {
+            re = /(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/;
+            var match = re.exec(userAgentString);
+            version = match && match[1];
+          }
+        }
+      }
+    }
+  }
+  return version || "";
+};
+goog.labs.userAgent.platform.isVersionOrHigher = function(version) {
+  return goog.string.compareVersions(goog.labs.userAgent.platform.getVersion(), version) >= 0;
+};
+goog.provide("goog.crypt.Hash");
+goog.crypt.Hash = function() {
+  this.blockSize = -1;
+};
+goog.crypt.Hash.prototype.reset = goog.abstractMethod;
+goog.crypt.Hash.prototype.update = goog.abstractMethod;
+goog.crypt.Hash.prototype.digest = goog.abstractMethod;
+goog.provide("goog.crypt.Sha1");
+goog.require("goog.crypt.Hash");
+goog.crypt.Sha1 = function() {
+  goog.crypt.Sha1.base(this, "constructor");
+  this.blockSize = 512 / 8;
+  this.chain_ = [];
+  this.buf_ = [];
+  this.W_ = [];
+  this.pad_ = [];
+  this.pad_[0] = 128;
+  for (var i = 1;i < this.blockSize;++i) {
+    this.pad_[i] = 0;
+  }
+  this.inbuf_ = 0;
+  this.total_ = 0;
+  this.reset();
+};
+goog.inherits(goog.crypt.Sha1, goog.crypt.Hash);
+goog.crypt.Sha1.prototype.reset = function() {
+  this.chain_[0] = 1732584193;
+  this.chain_[1] = 4023233417;
+  this.chain_[2] = 2562383102;
+  this.chain_[3] = 271733878;
+  this.chain_[4] = 3285377520;
+  this.inbuf_ = 0;
+  this.total_ = 0;
+};
+goog.crypt.Sha1.prototype.compress_ = function(buf, opt_offset) {
+  if (!opt_offset) {
+    opt_offset = 0;
+  }
+  var W = this.W_;
+  if (goog.isString(buf)) {
+    for (var i = 0;i < 16;i++) {
+      W[i] = buf.charCodeAt(opt_offset) << 24 | buf.charCodeAt(opt_offset + 1) << 16 | buf.charCodeAt(opt_offset + 2) << 8 | buf.charCodeAt(opt_offset + 3);
+      opt_offset += 4;
+    }
+  } else {
+    for (var i = 0;i < 16;i++) {
+      W[i] = buf[opt_offset] << 24 | buf[opt_offset + 1] << 16 | buf[opt_offset + 2] << 8 | buf[opt_offset + 3];
+      opt_offset += 4;
+    }
+  }
+  for (var i = 16;i < 80;i++) {
+    var t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+    W[i] = (t << 1 | t >>> 31) & 4294967295;
+  }
+  var a = this.chain_[0];
+  var b = this.chain_[1];
+  var c = this.chain_[2];
+  var d = this.chain_[3];
+  var e = this.chain_[4];
+  var f, k;
+  for (var i = 0;i < 80;i++) {
+    if (i < 40) {
+      if (i < 20) {
+        f = d ^ b & (c ^ d);
+        k = 1518500249;
+      } else {
+        f = b ^ c ^ d;
+        k = 1859775393;
+      }
+    } else {
+      if (i < 60) {
+        f = b & c | d & (b | c);
+        k = 2400959708;
+      } else {
+        f = b ^ c ^ d;
+        k = 3395469782;
+      }
+    }
+    var t = (a << 5 | a >>> 27) + f + e + k + W[i] & 4294967295;
+    e = d;
+    d = c;
+    c = (b << 30 | b >>> 2) & 4294967295;
+    b = a;
+    a = t;
+  }
+  this.chain_[0] = this.chain_[0] + a & 4294967295;
+  this.chain_[1] = this.chain_[1] + b & 4294967295;
+  this.chain_[2] = this.chain_[2] + c & 4294967295;
+  this.chain_[3] = this.chain_[3] + d & 4294967295;
+  this.chain_[4] = this.chain_[4] + e & 4294967295;
+};
+goog.crypt.Sha1.prototype.update = function(bytes, opt_length) {
+  if (bytes == null) {
+    return;
+  }
+  if (!goog.isDef(opt_length)) {
+    opt_length = bytes.length;
+  }
+  var lengthMinusBlock = opt_length - this.blockSize;
+  var n = 0;
+  var buf = this.buf_;
+  var inbuf = this.inbuf_;
+  while (n < opt_length) {
+    if (inbuf == 0) {
+      while (n <= lengthMinusBlock) {
+        this.compress_(bytes, n);
+        n += this.blockSize;
+      }
+    }
+    if (goog.isString(bytes)) {
+      while (n < opt_length) {
+        buf[inbuf] = bytes.charCodeAt(n);
+        ++inbuf;
+        ++n;
+        if (inbuf == this.blockSize) {
+          this.compress_(buf);
+          inbuf = 0;
+          break;
+        }
+      }
+    } else {
+      while (n < opt_length) {
+        buf[inbuf] = bytes[n];
+        ++inbuf;
+        ++n;
+        if (inbuf == this.blockSize) {
+          this.compress_(buf);
+          inbuf = 0;
+          break;
+        }
+      }
+    }
+  }
+  this.inbuf_ = inbuf;
+  this.total_ += opt_length;
+};
+goog.crypt.Sha1.prototype.digest = function() {
+  var digest = [];
+  var totalBits = this.total_ * 8;
+  if (this.inbuf_ < 56) {
+    this.update(this.pad_, 56 - this.inbuf_);
+  } else {
+    this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));
+  }
+  for (var i = this.blockSize - 1;i >= 56;i--) {
+    this.buf_[i] = totalBits & 255;
+    totalBits /= 256;
+  }
+  this.compress_(this.buf_);
+  var n = 0;
+  for (var i = 0;i < 5;i++) {
+    for (var j = 24;j >= 0;j -= 8) {
+      digest[n] = this.chain_[i] >> j & 255;
+      ++n;
+    }
+  }
+  return digest;
+};
+goog.provide("goog.asserts");
+goog.provide("goog.asserts.AssertionError");
+goog.require("goog.debug.Error");
+goog.require("goog.dom.NodeType");
+goog.require("goog.string");
+goog.define("goog.asserts.ENABLE_ASSERTS", goog.DEBUG);
+goog.asserts.AssertionError = function(messagePattern, messageArgs) {
+  messageArgs.unshift(messagePattern);
+  goog.debug.Error.call(this, goog.string.subs.apply(null, messageArgs));
+  messageArgs.shift();
+  this.messagePattern = messagePattern;
+};
+goog.inherits(goog.asserts.AssertionError, goog.debug.Error);
+goog.asserts.AssertionError.prototype.name = "AssertionError";
+goog.asserts.DEFAULT_ERROR_HANDLER = function(e) {
+  throw e;
+};
+goog.asserts.errorHandler_ = goog.asserts.DEFAULT_ERROR_HANDLER;
+goog.asserts.doAssertFailure_ = function(defaultMessage, defaultArgs, givenMessage, givenArgs) {
+  var message = "Assertion failed";
+  if (givenMessage) {
+    message += ": " + givenMessage;
+    var args = givenArgs;
+  } else {
+    if (defaultMessage) {
+      message += ": " + defaultMessage;
+      args = defaultArgs;
+    }
+  }
+  var e = new goog.asserts.AssertionError("" + message, args || []);
+  goog.asserts.errorHandler_(e);
+};
+goog.asserts.setErrorHandler = function(errorHandler) {
+  if (goog.asserts.ENABLE_ASSERTS) {
+    goog.asserts.errorHandler_ = errorHandler;
+  }
+};
+goog.asserts.assert = function(condition, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !condition) {
+    goog.asserts.doAssertFailure_("", null, opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return condition;
+};
+goog.asserts.fail = function(opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS) {
+    goog.asserts.errorHandler_(new goog.asserts.AssertionError("Failure" + (opt_message ? ": " + opt_message : ""), Array.prototype.slice.call(arguments, 1)));
+  }
+};
+goog.asserts.assertNumber = function(value, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !goog.isNumber(value)) {
+    goog.asserts.doAssertFailure_("Expected number but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return(value);
+};
+goog.asserts.assertString = function(value, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !goog.isString(value)) {
+    goog.asserts.doAssertFailure_("Expected string but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return(value);
+};
+goog.asserts.assertFunction = function(value, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !goog.isFunction(value)) {
+    goog.asserts.doAssertFailure_("Expected function but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return(value);
+};
+goog.asserts.assertObject = function(value, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !goog.isObject(value)) {
+    goog.asserts.doAssertFailure_("Expected object but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return(value);
+};
+goog.asserts.assertArray = function(value, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !goog.isArray(value)) {
+    goog.asserts.doAssertFailure_("Expected array but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return(value);
+};
+goog.asserts.assertBoolean = function(value, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !goog.isBoolean(value)) {
+    goog.asserts.doAssertFailure_("Expected boolean but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return(value);
+};
+goog.asserts.assertElement = function(value, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && (!goog.isObject(value) || value.nodeType != goog.dom.NodeType.ELEMENT)) {
+    goog.asserts.doAssertFailure_("Expected Element but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
+  }
+  return(value);
+};
+goog.asserts.assertInstanceof = function(value, type, opt_message, var_args) {
+  if (goog.asserts.ENABLE_ASSERTS && !(value instanceof type)) {
+    goog.asserts.doAssertFailure_("Expected instanceof %s but got %s.", [goog.asserts.getType_(type), goog.asserts.getType_(value)], opt_message, Array.prototype.slice.call(arguments, 3));
+  }
+  return value;
+};
+goog.asserts.assertObjectPrototypeIsIntact = function() {
+  for (var key in Object.prototype) {
+    goog.asserts.fail(key + " should not be enumerable in Object.prototype.");
+  }
+};
+goog.asserts.getType_ = function(value) {
+  if (value instanceof Function) {
+    return value.displayName || value.name || "unknown type name";
+  } else {
+    if (value instanceof Object) {
+      return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);
+    } else {
+      return value === null ? "null" : typeof value;
+    }
+  }
+};
+goog.provide("goog.array");
+goog.provide("goog.array.ArrayLike");
+goog.require("goog.asserts");
+goog.define("goog.NATIVE_ARRAY_PROTOTYPES", goog.TRUSTED_SITE);
+goog.define("goog.array.ASSUME_NATIVE_FUNCTIONS", false);
+goog.array.ArrayLike;
+goog.array.peek = function(array) {
+  return array[array.length - 1];
+};
+goog.array.last = goog.array.peek;
+goog.array.ARRAY_PROTOTYPE_ = Array.prototype;
+goog.array.indexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.indexOf) ? function(arr, obj, opt_fromIndex) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.indexOf.call(arr, obj, opt_fromIndex);
+} : function(arr, obj, opt_fromIndex) {
+  var fromIndex = opt_fromIndex == null ? 0 : opt_fromIndex < 0 ? Math.max(0, arr.length + opt_fromIndex) : opt_fromIndex;
+  if (goog.isString(arr)) {
+    if (!goog.isString(obj) || obj.length != 1) {
+      return-1;
+    }
+    return arr.indexOf(obj, fromIndex);
+  }
+  for (var i = fromIndex;i < arr.length;i++) {
+    if (i in arr && arr[i] === obj) {
+      return i;
+    }
+  }
+  return-1;
+};
+goog.array.lastIndexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.lastIndexOf) ? function(arr, obj, opt_fromIndex) {
+  goog.asserts.assert(arr.length != null);
+  var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
+  return goog.array.ARRAY_PROTOTYPE_.lastIndexOf.call(arr, obj, fromIndex);
+} : function(arr, obj, opt_fromIndex) {
+  var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
+  if (fromIndex < 0) {
+    fromIndex = Math.max(0, arr.length + fromIndex);
+  }
+  if (goog.isString(arr)) {
+    if (!goog.isString(obj) || obj.length != 1) {
+      return-1;
+    }
+    return arr.lastIndexOf(obj, fromIndex);
+  }
+  for (var i = fromIndex;i >= 0;i--) {
+    if (i in arr && arr[i] === obj) {
+      return i;
+    }
+  }
+  return-1;
+};
+goog.array.forEach = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.forEach) ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  goog.array.ARRAY_PROTOTYPE_.forEach.call(arr, f, opt_obj);
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = 0;i < l;i++) {
+    if (i in arr2) {
+      f.call(opt_obj, arr2[i], i, arr);
+    }
+  }
+};
+goog.array.forEachRight = function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = l - 1;i >= 0;--i) {
+    if (i in arr2) {
+      f.call(opt_obj, arr2[i], i, arr);
+    }
+  }
+};
+goog.array.filter = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.filter) ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.filter.call(arr, f, opt_obj);
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var res = [];
+  var resLength = 0;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = 0;i < l;i++) {
+    if (i in arr2) {
+      var val = arr2[i];
+      if (f.call(opt_obj, val, i, arr)) {
+        res[resLength++] = val;
+      }
+    }
+  }
+  return res;
+};
+goog.array.map = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.map) ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.map.call(arr, f, opt_obj);
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var res = new Array(l);
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = 0;i < l;i++) {
+    if (i in arr2) {
+      res[i] = f.call(opt_obj, arr2[i], i, arr);
+    }
+  }
+  return res;
+};
+goog.array.reduce = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.reduce) ? function(arr, f, val, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  var params = [];
+  for (var i = 1, l = arguments.length;i < l;i++) {
+    params.push(arguments[i]);
+  }
+  if (opt_obj) {
+    params[0] = goog.bind(f, opt_obj);
+  }
+  return goog.array.ARRAY_PROTOTYPE_.reduce.apply(arr, params);
+} : function(arr, f, val, opt_obj) {
+  var rval = val;
+  goog.array.forEach(arr, function(val, index) {
+    rval = f.call(opt_obj, rval, val, index, arr);
+  });
+  return rval;
+};
+goog.array.reduceRight = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.reduceRight) ? function(arr, f, val, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  if (opt_obj) {
+    f = goog.bind(f, opt_obj);
+  }
+  return goog.array.ARRAY_PROTOTYPE_.reduceRight.call(arr, f, val);
+} : function(arr, f, val, opt_obj) {
+  var rval = val;
+  goog.array.forEachRight(arr, function(val, index) {
+    rval = f.call(opt_obj, rval, val, index, arr);
+  });
+  return rval;
+};
+goog.array.some = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.some) ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.some.call(arr, f, opt_obj);
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = 0;i < l;i++) {
+    if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
+      return true;
+    }
+  }
+  return false;
+};
+goog.array.every = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.every) ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.every.call(arr, f, opt_obj);
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = 0;i < l;i++) {
+    if (i in arr2 && !f.call(opt_obj, arr2[i], i, arr)) {
+      return false;
+    }
+  }
+  return true;
+};
+goog.array.count = function(arr, f, opt_obj) {
+  var count = 0;
+  goog.array.forEach(arr, function(element, index, arr) {
+    if (f.call(opt_obj, element, index, arr)) {
+      ++count;
+    }
+  }, opt_obj);
+  return count;
+};
+goog.array.find = function(arr, f, opt_obj) {
+  var i = goog.array.findIndex(arr, f, opt_obj);
+  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
+};
+goog.array.findIndex = function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = 0;i < l;i++) {
+    if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
+      return i;
+    }
+  }
+  return-1;
+};
+goog.array.findRight = function(arr, f, opt_obj) {
+  var i = goog.array.findIndexRight(arr, f, opt_obj);
+  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
+};
+goog.array.findIndexRight = function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for (var i = l - 1;i >= 0;i--) {
+    if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
+      return i;
+    }
+  }
+  return-1;
+};
+goog.array.contains = function(arr, obj) {
+  return goog.array.indexOf(arr, obj) >= 0;
+};
+goog.array.isEmpty = function(arr) {
+  return arr.length == 0;
+};
+goog.array.clear = function(arr) {
+  if (!goog.isArray(arr)) {
+    for (var i = arr.length - 1;i >= 0;i--) {
+      delete arr[i];
+    }
+  }
+  arr.length = 0;
+};
+goog.array.insert = function(arr, obj) {
+  if (!goog.array.contains(arr, obj)) {
+    arr.push(obj);
+  }
+};
+goog.array.insertAt = function(arr, obj, opt_i) {
+  goog.array.splice(arr, opt_i, 0, obj);
+};
+goog.array.insertArrayAt = function(arr, elementsToAdd, opt_i) {
+  goog.partial(goog.array.splice, arr, opt_i, 0).apply(null, elementsToAdd);
+};
+goog.array.insertBefore = function(arr, obj, opt_obj2) {
+  var i;
+  if (arguments.length == 2 || (i = goog.array.indexOf(arr, opt_obj2)) < 0) {
+    arr.push(obj);
+  } else {
+    goog.array.insertAt(arr, obj, i);
+  }
+};
+goog.array.remove = function(arr, obj) {
+  var i = goog.array.indexOf(arr, obj);
+  var rv;
+  if (rv = i >= 0) {
+    goog.array.removeAt(arr, i);
+  }
+  return rv;
+};
+goog.array.removeAt = function(arr, i) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.splice.call(arr, i, 1).length == 1;
+};
+goog.array.removeIf = function(arr, f, opt_obj) {
+  var i = goog.array.findIndex(arr, f, opt_obj);
+  if (i >= 0) {
+    goog.array.removeAt(arr, i);
+    return true;
+  }
+  return false;
+};
+goog.array.removeAllIf = function(arr, f, opt_obj) {
+  var removedCount = 0;
+  goog.array.forEachRight(arr, function(val, index) {
+    if (f.call(opt_obj, val, index, arr)) {
+      if (goog.array.removeAt(arr, index)) {
+        removedCount++;
+      }
+    }
+  });
+  return removedCount;
+};
+goog.array.concat = function(var_args) {
+  return goog.array.ARRAY_PROTOTYPE_.concat.apply(goog.array.ARRAY_PROTOTYPE_, arguments);
+};
+goog.array.join = function(var_args) {
+  return goog.array.ARRAY_PROTOTYPE_.concat.apply(goog.array.ARRAY_PROTOTYPE_, arguments);
+};
+goog.array.toArray = function(object) {
+  var length = object.length;
+  if (length > 0) {
+    var rv = new Array(length);
+    for (var i = 0;i < length;i++) {
+      rv[i] = object[i];
+    }
+    return rv;
+  }
+  return[];
+};
+goog.array.clone = goog.array.toArray;
+goog.array.extend = function(arr1, var_args) {
+  for (var i = 1;i < arguments.length;i++) {
+    var arr2 = arguments[i];
+    if (goog.isArrayLike(arr2)) {
+      var len1 = arr1.length || 0;
+      var len2 = arr2.length || 0;
+      arr1.length = len1 + len2;
+      for (var j = 0;j < len2;j++) {
+        arr1[len1 + j] = arr2[j];
+      }
+    } else {
+      arr1.push(arr2);
+    }
+  }
+};
+goog.array.splice = function(arr, index, howMany, var_args) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.splice.apply(arr, goog.array.slice(arguments, 1));
+};
+goog.array.slice = function(arr, start, opt_end) {
+  goog.asserts.assert(arr.length != null);
+  if (arguments.length <= 2) {
+    return goog.array.ARRAY_PROTOTYPE_.slice.call(arr, start);
+  } else {
+    return goog.array.ARRAY_PROTOTYPE_.slice.call(arr, start, opt_end);
+  }
+};
+goog.array.removeDuplicates = function(arr, opt_rv, opt_hashFn) {
+  var returnArray = opt_rv || arr;
+  var defaultHashFn = function(item) {
+    return goog.isObject(current) ? "o" + goog.getUid(current) : (typeof current).charAt(0) + current;
+  };
+  var hashFn = opt_hashFn || defaultHashFn;
+  var seen = {}, cursorInsert = 0, cursorRead = 0;
+  while (cursorRead < arr.length) {
+    var current = arr[cursorRead++];
+    var key = hashFn(current);
+    if (!Object.prototype.hasOwnProperty.call(seen, key)) {
+      seen[key] = true;
+      returnArray[cursorInsert++] = current;
+    }
+  }
+  returnArray.length = cursorInsert;
+};
+goog.array.binarySearch = function(arr, target, opt_compareFn) {
+  return goog.array.binarySearch_(arr, opt_compareFn || goog.array.defaultCompare, false, target);
+};
+goog.array.binarySelect = function(arr, evaluator, opt_obj) {
+  return goog.array.binarySearch_(arr, evaluator, true, undefined, opt_obj);
+};
+goog.array.binarySearch_ = function(arr, compareFn, isEvaluator, opt_target, opt_selfObj) {
+  var left = 0;
+  var right = arr.length;
+  var found;
+  while (left < right) {
+    var middle = left + right >> 1;
+    var compareResult;
+    if (isEvaluator) {
+      compareResult = compareFn.call(opt_selfObj, arr[middle], middle, arr);
+    } else {
+      compareResult = compareFn(opt_target, arr[middle]);
+    }
+    if (compareResult > 0) {
+      left = middle + 1;
+    } else {
+      right = middle;
+      found = !compareResult;
+    }
+  }
+  return found ? left : ~left;
+};
+goog.array.sort = function(arr, opt_compareFn) {
+  arr.sort(opt_compareFn || goog.array.defaultCompare);
+};
+goog.array.stableSort = function(arr, opt_compareFn) {
+  for (var i = 0;i < arr.length;i++) {
+    arr[i] = {index:i, value:arr[i]};
+  }
+  var valueCompareFn = opt_compareFn || goog.array.defaultCompare;
+  function stableCompareFn(obj1, obj2) {
+    return valueCompareFn(obj1.value, obj2.value) || obj1.index - obj2.index;
+  }
+  goog.array.sort(arr, stableCompareFn);
+  for (var i = 0;i < arr.length;i++) {
+    arr[i] = arr[i].value;
+  }
+};
+goog.array.sortByKey = function(arr, keyFn, opt_compareFn) {
+  var keyCompareFn = opt_compareFn || goog.array.defaultCompare;
+  goog.array.sort(arr, function(a, b) {
+    return keyCompareFn(keyFn(a), keyFn(b));
+  });
+};
+goog.array.sortObjectsByKey = function(arr, key, opt_compareFn) {
+  goog.array.sortByKey(arr, function(obj) {
+    return obj[key];
+  }, opt_compareFn);
+};
+goog.array.isSorted = function(arr, opt_compareFn, opt_strict) {
+  var compare = opt_compareFn || goog.array.defaultCompare;
+  for (var i = 1;i < arr.length;i++) {
+    var compareResult = compare(arr[i - 1], arr[i]);
+    if (compareResult > 0 || compareResult == 0 && opt_strict) {
+      return false;
+    }
+  }
+  return true;
+};
+goog.array.equals = function(arr1, arr2, opt_equalsFn) {
+  if (!goog.isArrayLike(arr1) || !goog.isArrayLike(arr2) || arr1.length != arr2.length) {
+    return false;
+  }
+  var l = arr1.length;
+  var equalsFn = opt_equalsFn || goog.array.defaultCompareEquality;
+  for (var i = 0;i < l;i++) {
+    if (!equalsFn(arr1[i], arr2[i])) {
+      return false;
+    }
+  }
+  return true;
+};
+goog.array.compare3 = function(arr1, arr2, opt_compareFn) {
+  var compare = opt_compareFn || goog.array.defaultCompare;
+  var l = Math.min(arr1.length, arr2.length);
+  for (var i = 0;i < l;i++) {
+    var result = compare(arr1[i], arr2[i]);
+    if (result != 0) {
+      return result;
+    }
+  }
+  return goog.array.defaultCompare(arr1.length, arr2.length);
+};
+goog.array.defaultCompare = function(a, b) {
+  return a > b ? 1 : a < b ? -1 : 0;
+};
+goog.array.inverseDefaultCompare = function(a, b) {
+  return-goog.array.defaultCompare(a, b);
+};
+goog.array.defaultCompareEquality = function(a, b) {
+  return a === b;
+};
+goog.array.binaryInsert = function(array, value, opt_compareFn) {
+  var index = goog.array.binarySearch(array, value, opt_compareFn);
+  if (index < 0) {
+    goog.array.insertAt(array, value, -(index + 1));
+    return true;
+  }
+  return false;
+};
+goog.array.binaryRemove = function(array, value, opt_compareFn) {
+  var index = goog.array.binarySearch(array, value, opt_compareFn);
+  return index >= 0 ? goog.array.removeAt(array, index) : false;
+};
+goog.array.bucket = function(array, sorter, opt_obj) {
+  var buckets = {};
+  for (var i = 0;i < array.length;i++) {
+    var value = array[i];
+    var key = sorter.call(opt_obj, value, i, array);
+    if (goog.isDef(key)) {
+      var bucket = buckets[key] || (buckets[key] = []);
+      bucket.push(value);
+    }
+  }
+  return buckets;
+};
+goog.array.toObject = function(arr, keyFunc, opt_obj) {
+  var ret = {};
+  goog.array.forEach(arr, function(element, index) {
+    ret[keyFunc.call(opt_obj, element, index, arr)] = element;
+  });
+  return ret;
+};
+goog.array.range = function(startOrEnd, opt_end, opt_step) {
+  var array = [];
+  var start = 0;
+  var end = startOrEnd;
+  var step = opt_step || 1;
+  if (opt_end !== undefined) {
+    start = startOrEnd;
+    end = opt_end;
+  }
+  if (step * (end - start) < 0) {
+    return[];
+  }
+  if (step > 0) {
+    for (var i = start;i < end;i += step) {
+      array.push(i);
+    }
+  } else {
+    for (var i = start;i > end;i += step) {
+      array.push(i);
+    }
+  }
+  return array;
+};
+goog.array.repeat = function(value, n) {
+  var array = [];
+  for (var i = 0;i < n;i++) {
+    array[i] = value;
+  }
+  return array;
+};
+goog.array.flatten = function(var_args) {
+  var CHUNK_SIZE = 8192;
+  var result = [];
+  for (var i = 0;i < arguments.length;i++) {
+    var element = arguments[i];
+    if (goog.isArray(element)) {
+      for (var c = 0;c < element.length;c += CHUNK_SIZE) {
+        var chunk = goog.array.slice(element, c, c + CHUNK_SIZE);
+        var recurseResult = goog.array.flatten.apply(null, chunk);
+        for (var r = 0;r < recurseResult.length;r++) {
+          result.push(recurseResult[r]);
+        }
+      }
+    } else {
+      result.push(element);
+    }
+  }
+  return result;
+};
+goog.array.rotate = function(array, n) {
+  goog.asserts.assert(array.length != null);
+  if (array.length) {
+    n %= array.length;
+    if (n > 0) {
+      goog.array.ARRAY_PROTOTYPE_.unshift.apply(array, array.splice(-n, n));
+    } else {
+      if (n < 0) {
+        goog.array.ARRAY_PROTOTYPE_.push.apply(array, array.splice(0, -n));
+      }
+    }
+  }
+  return array;
+};
+goog.array.moveItem = function(arr, fromIndex, toIndex) {
+  goog.asserts.assert(fromIndex >= 0 && fromIndex < arr.length);
+  goog.asserts.assert(toIndex >= 0 && toIndex < arr.length);
+  var removedItems = goog.array.ARRAY_PROTOTYPE_.splice.call(arr, fromIndex, 1);
+  goog.array.ARRAY_PROTOTYPE_.splice.call(arr, toIndex, 0, removedItems[0]);
+};
+goog.array.zip = function(var_args) {
+  if (!arguments.length) {
+    return[];
+  }
+  var result = [];
+  for (var i = 0;true;i++) {
+    var value = [];
+    for (var j = 0;j < arguments.length;j++) {
+      var arr = arguments[j];
+      if (i >= arr.length) {
+        return result;
+      }
+      value.push(arr[i]);
+    }
+    result.push(value);
+  }
+};
+goog.array.shuffle = function(arr, opt_randFn) {
+  var randFn = opt_randFn || Math.random;
+  for (var i = arr.length - 1;i > 0;i--) {
+    var j = Math.floor(randFn() * (i + 1));
+    var tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+  }
+};
+goog.array.copyByIndex = function(arr, index_arr) {
+  var result = [];
+  goog.array.forEach(index_arr, function(index) {
+    result.push(arr[index]);
+  });
+  return result;
+};
+goog.provide("goog.labs.userAgent.browser");
+goog.require("goog.array");
+goog.require("goog.labs.userAgent.util");
+goog.require("goog.object");
+goog.require("goog.string");
+goog.labs.userAgent.browser.matchOpera_ = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Opera") || goog.labs.userAgent.util.matchUserAgent("OPR");
+};
+goog.labs.userAgent.browser.matchIE_ = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Trident") || goog.labs.userAgent.util.matchUserAgent("MSIE");
+};
+goog.labs.userAgent.browser.matchFirefox_ = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Firefox");
+};
+goog.labs.userAgent.browser.matchSafari_ = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Safari") && !(goog.labs.userAgent.browser.matchChrome_() || goog.labs.userAgent.browser.matchCoast_() || goog.labs.userAgent.browser.matchOpera_() || goog.labs.userAgent.browser.isSilk() || goog.labs.userAgent.util.matchUserAgent("Android"));
+};
+goog.labs.userAgent.browser.matchCoast_ = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Coast");
+};
+goog.labs.userAgent.browser.matchIosWebview_ = function() {
+  return(goog.labs.userAgent.util.matchUserAgent("iPad") || goog.labs.userAgent.util.matchUserAgent("iPhone")) && !goog.labs.userAgent.browser.matchSafari_() && !goog.labs.userAgent.browser.matchChrome_() && !goog.labs.userAgent.browser.matchCoast_() && goog.labs.userAgent.util.matchUserAgent("AppleWebKit");
+};
+goog.labs.userAgent.browser.matchChrome_ = function() {
+  return(goog.labs.userAgent.util.matchUserAgent("Chrome") || goog.labs.userAgent.util.matchUserAgent("CriOS")) && !goog.labs.userAgent.browser.matchOpera_();
+};
+goog.labs.userAgent.browser.matchAndroidBrowser_ = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Android") && !(goog.labs.userAgent.browser.isChrome() || goog.labs.userAgent.browser.isFirefox() || goog.labs.userAgent.browser.isOpera() || goog.labs.userAgent.browser.isSilk());
+};
+goog.labs.userAgent.browser.isOpera = goog.labs.userAgent.browser.matchOpera_;
+goog.labs.userAgent.browser.isIE = goog.labs.userAgent.browser.matchIE_;
+goog.labs.userAgent.browser.isFirefox = goog.labs.userAgent.browser.matchFirefox_;
+goog.labs.userAgent.browser.isSafari = goog.labs.userAgent.browser.matchSafari_;
+goog.labs.userAgent.browser.isCoast = goog.labs.userAgent.browser.matchCoast_;
+goog.labs.userAgent.browser.isIosWebview = goog.labs.userAgent.browser.matchIosWebview_;
+goog.labs.userAgent.browser.isChrome = goog.labs.userAgent.browser.matchChrome_;
+goog.labs.userAgent.browser.isAndroidBrowser = goog.labs.userAgent.browser.matchAndroidBrowser_;
+goog.labs.userAgent.browser.isSilk = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Silk");
+};
+goog.labs.userAgent.browser.getVersion = function() {
+  var userAgentString = goog.labs.userAgent.util.getUserAgent();
+  if (goog.labs.userAgent.browser.isIE()) {
+    return goog.labs.userAgent.browser.getIEVersion_(userAgentString);
+  }
+  var versionTuples = goog.labs.userAgent.util.extractVersionTuples(userAgentString);
+  var versionMap = {};
+  goog.array.forEach(versionTuples, function(tuple) {
+    var key = tuple[0];
+    var value = tuple[1];
+    versionMap[key] = value;
+  });
+  var versionMapHasKey = goog.partial(goog.object.containsKey, versionMap);
+  function lookUpValueWithKeys(keys) {
+    var key = goog.array.find(keys, versionMapHasKey);
+    return versionMap[key] || "";
+  }
+  if (goog.labs.userAgent.browser.isOpera()) {
+    return lookUpValueWithKeys(["Version", "Opera", "OPR"]);
+  }
+  if (goog.labs.userAgent.browser.isChrome()) {
+    return lookUpValueWithKeys(["Chrome", "CriOS"]);
+  }
+  var tuple = versionTuples[2];
+  return tuple && tuple[1] || "";
+};
+goog.labs.userAgent.browser.isVersionOrHigher = function(version) {
+  return goog.string.compareVersions(goog.labs.userAgent.browser.getVersion(), version) >= 0;
+};
+goog.labs.userAgent.browser.getIEVersion_ = function(userAgent) {
+  var rv = /rv: *([\d\.]*)/.exec(userAgent);
+  if (rv && rv[1]) {
+    return rv[1];
+  }
+  var version = "";
+  var msie = /MSIE +([\d\.]+)/.exec(userAgent);
+  if (msie && msie[1]) {
+    var tridentVersion = /Trident\/(\d.\d)/.exec(userAgent);
+    if (msie[1] == "7.0") {
+      if (tridentVersion && tridentVersion[1]) {
+        switch(tridentVersion[1]) {
+          case "4.0":
+            version = "8.0";
+            break;
+          case "5.0":
+            version = "9.0";
+            break;
+          case "6.0":
+            version = "10.0";
+            break;
+          case "7.0":
+            version = "11.0";
+            break;
+        }
+      } else {
+        version = "7.0";
+      }
+    } else {
+      version = msie[1];
+    }
+  }
+  return version;
+};
+goog.provide("goog.labs.userAgent.engine");
+goog.require("goog.array");
+goog.require("goog.labs.userAgent.util");
+goog.require("goog.string");
+goog.labs.userAgent.engine.isPresto = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Presto");
+};
+goog.labs.userAgent.engine.isTrident = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Trident") || goog.labs.userAgent.util.matchUserAgent("MSIE");
+};
+goog.labs.userAgent.engine.isWebKit = function() {
+  return goog.labs.userAgent.util.matchUserAgentIgnoreCase("WebKit");
+};
+goog.labs.userAgent.engine.isGecko = function() {
+  return goog.labs.userAgent.util.matchUserAgent("Gecko") && !goog.labs.userAgent.engine.isWebKit() && !goog.labs.userAgent.engine.isTrident();
+};
+goog.labs.userAgent.engine.getVersion = function() {
+  var userAgentString = goog.labs.userAgent.util.getUserAgent();
+  if (userAgentString) {
+    var tuples = goog.labs.userAgent.util.extractVersionTuples(userAgentString);
+    var engineTuple = tuples[1];
+    if (engineTuple) {
+      if (engineTuple[0] == "Gecko") {
+        return goog.labs.userAgent.engine.getVersionForKey_(tuples, "Firefox");
+      }
+      return engineTuple[1];
+    }
+    var browserTuple = tuples[0];
+    var info;
+    if (browserTuple && (info = browserTuple[2])) {
+      var match = /Trident\/([^\s;]+)/.exec(info);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+  return "";
+};
+goog.labs.userAgent.engine.isVersionOrHigher = function(version) {
+  return goog.string.compareVersions(goog.labs.userAgent.engine.getVersion(), version) >= 0;
+};
+goog.labs.userAgent.engine.getVersionForKey_ = function(tuples, key) {
+  var pair = goog.array.find(tuples, function(pair) {
+    return key == pair[0];
+  });
+  return pair && pair[1] || "";
+};
+goog.provide("goog.crypt");
+goog.require("goog.array");
+goog.require("goog.asserts");
+goog.crypt.stringToByteArray = function(str) {
+  var output = [], p = 0;
+  for (var i = 0;i < str.length;i++) {
+    var c = str.charCodeAt(i);
+    while (c > 255) {
+      output[p++] = c & 255;
+      c >>= 8;
+    }
+    output[p++] = c;
+  }
+  return output;
+};
+goog.crypt.byteArrayToString = function(bytes) {
+  var CHUNK_SIZE = 8192;
+  if (bytes.length < CHUNK_SIZE) {
+    return String.fromCharCode.apply(null, bytes);
+  }
+  var str = "";
+  for (var i = 0;i < bytes.length;i += CHUNK_SIZE) {
+    var chunk = goog.array.slice(bytes, i, i + CHUNK_SIZE);
+    str += String.fromCharCode.apply(null, chunk);
+  }
+  return str;
+};
+goog.crypt.byteArrayToHex = function(array) {
+  return goog.array.map(array, function(numByte) {
+    var hexByte = numByte.toString(16);
+    return hexByte.length > 1 ? hexByte : "0" + hexByte;
+  }).join("");
+};
+goog.crypt.hexToByteArray = function(hexString) {
+  goog.asserts.assert(hexString.length % 2 == 0, "Key string length must be multiple of 2");
+  var arr = [];
+  for (var i = 0;i < hexString.length;i += 2) {
+    arr.push(parseInt(hexString.substring(i, i + 2), 16));
+  }
+  return arr;
+};
+goog.crypt.stringToUtf8ByteArray = function(str) {
+  str = str.replace(/\r\n/g, "\n");
+  var out = [], p = 0;
+  for (var i = 0;i < str.length;i++) {
+    var c = str.charCodeAt(i);
+    if (c < 128) {
+      out[p++] = c;
+    } else {
+      if (c < 2048) {
+        out[p++] = c >> 6 | 192;
+        out[p++] = c & 63 | 128;
+      } else {
+        out[p++] = c >> 12 | 224;
+        out[p++] = c >> 6 & 63 | 128;
+        out[p++] = c & 63 | 128;
+      }
+    }
+  }
+  return out;
+};
+goog.crypt.utf8ByteArrayToString = function(bytes) {
+  var out = [], pos = 0, c = 0;
+  while (pos < bytes.length) {
+    var c1 = bytes[pos++];
+    if (c1 < 128) {
+      out[c++] = String.fromCharCode(c1);
+    } else {
+      if (c1 > 191 && c1 < 224) {
+        var c2 = bytes[pos++];
+        out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
+      } else {
+        var c2 = bytes[pos++];
+        var c3 = bytes[pos++];
+        out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
+      }
+    }
+  }
+  return out.join("");
+};
+goog.crypt.xorByteArray = function(bytes1, bytes2) {
+  goog.asserts.assert(bytes1.length == bytes2.length, "XOR array lengths must match");
+  var result = [];
+  for (var i = 0;i < bytes1.length;i++) {
+    result.push(bytes1[i] ^ bytes2[i]);
+  }
+  return result;
+};
+goog.provide("goog.userAgent");
+goog.require("goog.labs.userAgent.browser");
+goog.require("goog.labs.userAgent.engine");
+goog.require("goog.labs.userAgent.platform");
+goog.require("goog.labs.userAgent.util");
+goog.require("goog.string");
+goog.define("goog.userAgent.ASSUME_IE", false);
+goog.define("goog.userAgent.ASSUME_GECKO", false);
+goog.define("goog.userAgent.ASSUME_WEBKIT", false);
+goog.define("goog.userAgent.ASSUME_MOBILE_WEBKIT", false);
+goog.define("goog.userAgent.ASSUME_OPERA", false);
+goog.define("goog.userAgent.ASSUME_ANY_VERSION", false);
+goog.userAgent.BROWSER_KNOWN_ = goog.userAgent.ASSUME_IE || goog.userAgent.ASSUME_GECKO || goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_OPERA;
+goog.userAgent.getUserAgentString = function() {
+  return goog.labs.userAgent.util.getUserAgent();
+};
+goog.userAgent.getNavigator = function() {
+  return goog.global["navigator"] || null;
+};
+goog.userAgent.OPERA = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_OPERA : goog.labs.userAgent.browser.isOpera();
+goog.userAgent.IE = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_IE : goog.labs.userAgent.browser.isIE();
+goog.userAgent.GECKO = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_GECKO : goog.labs.userAgent.engine.isGecko();
+goog.userAgent.WEBKIT = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_MOBILE_WEBKIT : goog.labs.userAgent.engine.isWebKit();
+goog.userAgent.isMobile_ = function() {
+  return goog.userAgent.WEBKIT && goog.labs.userAgent.util.matchUserAgent("Mobile");
+};
+goog.userAgent.MOBILE = goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.isMobile_();
+goog.userAgent.SAFARI = goog.userAgent.WEBKIT;
+goog.userAgent.determinePlatform_ = function() {
+  var navigator = goog.userAgent.getNavigator();
+  return navigator && navigator.platform || "";
+};
+goog.userAgent.PLATFORM = goog.userAgent.determinePlatform_();
+goog.define("goog.userAgent.ASSUME_MAC", false);
+goog.define("goog.userAgent.ASSUME_WINDOWS", false);
+goog.define("goog.userAgent.ASSUME_LINUX", false);
+goog.define("goog.userAgent.ASSUME_X11", false);
+goog.define("goog.userAgent.ASSUME_ANDROID", false);
+goog.define("goog.userAgent.ASSUME_IPHONE", false);
+goog.define("goog.userAgent.ASSUME_IPAD", false);
+goog.userAgent.PLATFORM_KNOWN_ = 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.MAC = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_MAC : goog.labs.userAgent.platform.isMacintosh();
+goog.userAgent.WINDOWS = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_WINDOWS : goog.labs.userAgent.platform.isWindows();
+goog.userAgent.isLegacyLinux_ = function() {
+  return goog.labs.userAgent.platform.isLinux() || goog.labs.userAgent.platform.isChromeOS();
+};
+goog.userAgent.LINUX = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_LINUX : goog.userAgent.isLegacyLinux_();
+goog.userAgent.isX11_ = function() {
+  var navigator = goog.userAgent.getNavigator();
+  return!!navigator && goog.string.contains(navigator["appVersion"] || "", "X11");
+};
+goog.userAgent.X11 = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_X11 : goog.userAgent.isX11_();
+goog.userAgent.ANDROID = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_ANDROID : goog.labs.userAgent.platform.isAndroid();
+goog.userAgent.IPHONE = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPHONE : goog.labs.userAgent.platform.isIphone();
+goog.userAgent.IPAD = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPAD : goog.labs.userAgent.platform.isIpad();
+goog.userAgent.determineVersion_ = function() {
+  var version = "", re;
+  if (goog.userAgent.OPERA && goog.global["opera"]) {
+    var operaVersion = goog.global["opera"].version;
+    return goog.isFunction(operaVersion) ? operaVersion() : operaVersion;
+  }
+  if (goog.userAgent.GECKO) {
+    re = /rv\:([^\);]+)(\)|;)/;
+  } else {
+    if (goog.userAgent.IE) {
+      re = /\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/;
+    } else {
+      if (goog.userAgent.WEBKIT) {
+        re = /WebKit\/(\S+)/;
+      }
+    }
+  }
+  if (re) {
+    var arr = re.exec(goog.userAgent.getUserAgentString());
+    version = arr ? arr[1] : "";
+  }
+  if (goog.userAgent.IE) {
+    var docMode = goog.userAgent.getDocumentMode_();
+    if (docMode > parseFloat(version)) {
+      return String(docMode);
+    }
+  }
+  return version;
+};
+goog.userAgent.getDocumentMode_ = function() {
+  var doc = goog.global["document"];
+  return doc ? doc["documentMode"] : undefined;
+};
+goog.userAgent.VERSION = goog.userAgent.determineVersion_();
+goog.userAgent.compare = function(v1, v2) {
+  return goog.string.compareVersions(v1, v2);
+};
+goog.userAgent.isVersionOrHigherCache_ = {};
+goog.userAgent.isVersionOrHigher = function(version) {
+  return goog.userAgent.ASSUME_ANY_VERSION || goog.userAgent.isVersionOrHigherCache_[version] || (goog.userAgent.isVersionOrHigherCache_[version] = goog.string.compareVersions(goog.userAgent.VERSION, version) >= 0);
+};
+goog.userAgent.isVersion = goog.userAgent.isVersionOrHigher;
+goog.userAgent.isDocumentModeOrHigher = function(documentMode) {
+  return goog.userAgent.IE && goog.userAgent.DOCUMENT_MODE >= documentMode;
+};
+goog.userAgent.isDocumentMode = goog.userAgent.isDocumentModeOrHigher;
+goog.userAgent.DOCUMENT_MODE = function() {
+  var doc = goog.global["document"];
+  if (!doc || !goog.userAgent.IE) {
+    return undefined;
+  }
+  var mode = goog.userAgent.getDocumentMode_();
+  return mode || (doc["compatMode"] == "CSS1Compat" ? parseInt(goog.userAgent.VERSION, 10) : 5);
+}();
+goog.provide("goog.crypt.base64");
+goog.require("goog.crypt");
+goog.require("goog.userAgent");
+goog.crypt.base64.byteToCharMap_ = null;
+goog.crypt.base64.charToByteMap_ = null;
+goog.crypt.base64.byteToCharMapWebSafe_ = null;
+goog.crypt.base64.charToByteMapWebSafe_ = null;
+goog.crypt.base64.ENCODED_VALS_BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789";
+goog.crypt.base64.ENCODED_VALS = goog.crypt.base64.ENCODED_VALS_BASE + "+/=";
+goog.crypt.base64.ENCODED_VALS_WEBSAFE = goog.crypt.base64.ENCODED_VALS_BASE + "-_.";
+goog.crypt.base64.HAS_NATIVE_SUPPORT = goog.userAgent.GECKO || goog.userAgent.WEBKIT || goog.userAgent.OPERA || typeof goog.global.atob == "function";
+goog.crypt.base64.encodeByteArray = function(input, opt_webSafe) {
+  if (!goog.isArrayLike(input)) {
+    throw Error("encodeByteArray takes an array as a parameter");
+  }
+  goog.crypt.base64.init_();
+  var byteToCharMap = opt_webSafe ? goog.crypt.base64.byteToCharMapWebSafe_ : goog.crypt.base64.byteToCharMap_;
+  var output = [];
+  for (var i = 0;i < input.length;i += 3) {
+    var byte1 = input[i];
+    var haveByte2 = i + 1 < input.length;
+    var byte2 = haveByte2 ? input[i + 1] : 0;
+    var haveByte3 = i + 2 < input.length;
+    var byte3 = haveByte3 ? input[i + 2] : 0;
+    var outByte1 = byte1 >> 2;
+    var outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
+    var outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
+    var outByte4 = byte3 & 63;
+    if (!haveByte3) {
+      outByte4 = 64;
+      if (!haveByte2) {
+        outByte3 = 64;
+      }
+    }
+    output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
+  }
+  return output.join("");
+};
+goog.crypt.base64.encodeString = function(input, opt_webSafe) {
+  if (goog.crypt.base64.HAS_NATIVE_SUPPORT && !opt_webSafe) {
+    return goog.global.btoa(input);
+  }
+  return goog.crypt.base64.encodeByteArray(goog.crypt.stringToByteArray(input), opt_webSafe);
+};
+goog.crypt.base64.decodeString = function(input, opt_webSafe) {
+  if (goog.crypt.base64.HAS_NATIVE_SUPPORT && !opt_webSafe) {
+    return goog.global.atob(input);
+  }
+  return goog.crypt.byteArrayToString(goog.crypt.base64.decodeStringToByteArray(input, opt_webSafe));
+};
+goog.crypt.base64.decodeStringToByteArray = function(input, opt_webSafe) {
+  goog.crypt.base64.init_();
+  var charToByteMap = opt_webSafe ? goog.crypt.base64.charToByteMapWebSafe_ : goog.crypt.base64.charToByteMap_;
+  var output = [];
+  for (var i = 0;i < input.length;) {
+    var byte1 = charToByteMap[input.charAt(i++)];
+    var haveByte2 = i < input.length;
+    var byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
+    ++i;
+    var haveByte3 = i < input.length;
+    var byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
+    ++i;
+    var haveByte4 = i < input.length;
+    var byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
+    ++i;
+    if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
+      throw Error();
+    }
+    var outByte1 = byte1 << 2 | byte2 >> 4;
+    output.push(outByte1);
+    if (byte3 != 64) {
+      var outByte2 = byte2 << 4 & 240 | byte3 >> 2;
+      output.push(outByte2);
+      if (byte4 != 64) {
+        var outByte3 = byte3 << 6 & 192 | byte4;
+        output.push(outByte3);
+      }
+    }
+  }
+  return output;
+};
+goog.crypt.base64.init_ = function() {
+  if (!goog.crypt.base64.byteToCharMap_) {
+    goog.crypt.base64.byteToCharMap_ = {};
+    goog.crypt.base64.charToByteMap_ = {};
+    goog.crypt.base64.byteToCharMapWebSafe_ = {};
+    goog.crypt.base64.charToByteMapWebSafe_ = {};
+    for (var i = 0;i < goog.crypt.base64.ENCODED_VALS.length;i++) {
+      goog.crypt.base64.byteToCharMap_[i] = goog.crypt.base64.ENCODED_VALS.charAt(i);
+      goog.crypt.base64.charToByteMap_[goog.crypt.base64.byteToCharMap_[i]] = i;
+      goog.crypt.base64.byteToCharMapWebSafe_[i] = goog.crypt.base64.ENCODED_VALS_WEBSAFE.charAt(i);
+      goog.crypt.base64.charToByteMapWebSafe_[goog.crypt.base64.byteToCharMapWebSafe_[i]] = i;
+      if (i >= goog.crypt.base64.ENCODED_VALS_BASE.length) {
+        goog.crypt.base64.charToByteMap_[goog.crypt.base64.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
+        goog.crypt.base64.charToByteMapWebSafe_[goog.crypt.base64.ENCODED_VALS.charAt(i)] = i;
+      }
+    }
+  }
+};
+goog.provide("fb.constants");
+var NODE_CLIENT = false;
+var CLIENT_VERSION = "0.0.0";
+goog.provide("fb.util.obj");
+fb.util.obj.contains = function(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+};
+fb.util.obj.get = function(obj, key) {
+  if (Object.prototype.hasOwnProperty.call(obj, key)) {
+    return obj[key];
+  }
+};
+fb.util.obj.foreach = function(obj, fn) {
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      fn(key, obj[key]);
+    }
+  }
+};
+fb.util.obj.clone = function(obj) {
+  var clone = {};
+  fb.util.obj.foreach(obj, function(key, value) {
+    clone[key] = value;
+  });
+  return clone;
+};
+goog.provide("fb.util");
+goog.require("fb.util.obj");
+fb.util.querystring = function(querystringParams) {
+  var params = [];
+  fb.util.obj.foreach(querystringParams, function(key, value) {
+    if (goog.isArray(value)) {
+      goog.array.forEach(value, function(arrayVal) {
+        params.push(encodeURIComponent(key) + "=" + encodeURIComponent(arrayVal));
+      });
+    } else {
+      params.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
+    }
+  });
+  return params.length ? "&" + params.join("&") : "";
+};
+fb.util.querystringDecode = function(querystring) {
+  var obj = {};
+  var tokens = querystring.replace(/^\?/, "").split("&");
+  goog.array.forEach(tokens, function(token) {
+    if (token) {
+      var key = token.split("=");
+      obj[key[0]] = key[1];
+    }
+  });
+  return obj;
+};
+goog.provide("fb.util.validation");
+fb.util.validation.validateArgCount = function(fnName, minCount, maxCount, argCount) {
+  var argError;
+  if (argCount < minCount) {
+    argError = "at least " + minCount;
+  } else {
+    if (argCount > maxCount) {
+      argError = maxCount === 0 ? "none" : "no more than " + maxCount;
+    }
+  }
+  if (argError) {
+    var error = fnName + " failed: Was called with " + argCount + (argCount === 1 ? " argument." : " arguments.") + " Expects " + argError + ".";
+    throw new Error(error);
+  }
+};
+fb.util.validation.errorPrefix = function(fnName, argumentNumber, optional) {
+  var argName = "";
+  switch(argumentNumber) {
+    case 1:
+      argName = optional ? "first" : "First";
+      break;
+    case 2:
+      argName = optional ? "second" : "Second";
+      break;
+    case 3:
+      argName = optional ? "third" : "Third";
+      break;
+    case 4:
+      argName = optional ? "fourth" : "Fourth";
+      break;
+    default:
+      throw new Error("errorPrefix called with argumentNumber > 4.  Need to update it?");;
+  }
+  var error = fnName + " failed: ";
+  error += argName + " argument ";
+  return error;
+};
+fb.util.validation.validateNamespace = function(fnName, argumentNumber, namespace, optional) {
+  if (optional && !goog.isDef(namespace)) {
+    return;
+  }
+  if (!goog.isString(namespace)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a valid firebase namespace.");
+  }
+};
+fb.util.validation.validateCallback = function(fnName, argumentNumber, callback, optional) {
+  if (optional && !goog.isDef(callback)) {
+    return;
+  }
+  if (!goog.isFunction(callback)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a valid function.");
+  }
+};
+fb.util.validation.validateContextObject = function(fnName, argumentNumber, context, optional) {
+  if (optional && !goog.isDef(context)) {
+    return;
+  }
+  if (!goog.isObject(context) || context === null) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a valid context object.");
+  }
+};
+goog.provide("fb.util.json");
+goog.require("goog.json");
+fb.util.json.eval = function(str) {
+  if (typeof JSON !== "undefined" && goog.isDef(JSON.parse)) {
+    return JSON.parse(str);
+  } else {
+    return goog.json.parse(str);
+  }
+};
+fb.util.json.stringify = function(data) {
+  if (typeof JSON !== "undefined" && goog.isDef(JSON.stringify)) {
+    return JSON.stringify(data);
+  } else {
+    return goog.json.serialize(data);
+  }
+};
+goog.provide("fb.core.SnapshotHolder");
+fb.core.SnapshotHolder = function() {
+  this.rootNode_ = fb.core.snap.EMPTY_NODE;
+};
+fb.core.SnapshotHolder.prototype.getNode = function(path) {
+  return this.rootNode_.getChild(path);
+};
+fb.core.SnapshotHolder.prototype.updateSnapshot = function(path, newSnapshotNode) {
+  this.rootNode_ = this.rootNode_.updateChild(path, newSnapshotNode);
+};
+if (goog.DEBUG) {
+  fb.core.SnapshotHolder.prototype.toString = function() {
+    return this.rootNode_.toString();
+  };
+}
+;goog.provide("fb.core.view.CompleteChildSource");
+fb.core.view.CompleteChildSource = function() {
+};
+fb.core.view.CompleteChildSource.prototype.getCompleteChild = function(childKey) {
+};
+fb.core.view.CompleteChildSource.prototype.getChildAfterChild = function(index, child, reverse) {
+};
+fb.core.view.NoCompleteChildSource_ = function() {
+};
+fb.core.view.NoCompleteChildSource_.prototype.getCompleteChild = function() {
+  return null;
+};
+fb.core.view.NoCompleteChildSource_.prototype.getChildAfterChild = function() {
+  return null;
+};
+fb.core.view.NO_COMPLETE_CHILD_SOURCE = new fb.core.view.NoCompleteChildSource_;
+fb.core.view.WriteTreeCompleteChildSource = function(writes, viewCache, optCompleteServerCache) {
+  this.writes_ = writes;
+  this.viewCache_ = viewCache;
+  this.optCompleteServerCache_ = optCompleteServerCache;
+};
+fb.core.view.WriteTreeCompleteChildSource.prototype.getCompleteChild = function(childKey) {
+  var node = this.viewCache_.getEventCache();
+  if (node.isCompleteForChild(childKey)) {
+    return node.getNode().getImmediateChild(childKey);
+  } else {
+    var serverNode = this.optCompleteServerCache_ != null ? new fb.core.view.CacheNode(this.optCompleteServerCache_, true, false) : this.viewCache_.getServerCache();
+    return this.writes_.calcCompleteChild(childKey, serverNode);
+  }
+};
+fb.core.view.WriteTreeCompleteChildSource.prototype.getChildAfterChild = function(index, child, reverse) {
+  var completeServerData = this.optCompleteServerCache_ != null ? this.optCompleteServerCache_ : this.viewCache_.getCompleteServerSnap();
+  var nodes = this.writes_.calcIndexedSlice(completeServerData, child, 1, reverse, index);
+  if (nodes.length === 0) {
+    return null;
+  } else {
+    return nodes[0];
+  }
+};
+goog.provide("fb.core.view.EventQueue");
+fb.core.view.EventQueue = function() {
+  this.eventLists_ = [];
+  this.recursionDepth_ = 0;
+};
+fb.core.view.EventQueue.prototype.queueEvents = function(eventDataList) {
+  var currList = null;
+  for (var i = 0;i < eventDataList.length;i++) {
+    var eventData = eventDataList[i];
+    var eventPath = eventData.getPath();
+    if (currList !== null && !eventPath.equals(currList.getPath())) {
+      this.eventLists_.push(currList);
+      currList = null;
+    }
+    if (currList === null) {
+      currList = new fb.core.view.EventList(eventPath);
+    }
+    currList.add(eventData);
+  }
+  if (currList) {
+    this.eventLists_.push(currList);
+  }
+};
+fb.core.view.EventQueue.prototype.raiseEventsAtPath = function(path, eventDataList) {
+  this.queueEvents(eventDataList);
+  this.raiseQueuedEventsMatchingPredicate_(function(eventPath) {
+    return eventPath.equals(path);
+  });
+};
+fb.core.view.EventQueue.prototype.raiseEventsForChangedPath = function(changedPath, eventDataList) {
+  this.queueEvents(eventDataList);
+  this.raiseQueuedEventsMatchingPredicate_(function(eventPath) {
+    return eventPath.contains(changedPath) || changedPath.contains(eventPath);
+  });
+};
+fb.core.view.EventQueue.prototype.raiseQueuedEventsMatchingPredicate_ = function(predicate) {
+  this.recursionDepth_++;
+  var sentAll = true;
+  for (var i = 0;i < this.eventLists_.length;i++) {
+    var eventList = this.eventLists_[i];
+    if (eventList) {
+      var eventPath = eventList.getPath();
+      if (predicate(eventPath)) {
+        this.eventLists_[i].raise();
+        this.eventLists_[i] = null;
+      } else {
+        sentAll = false;
+      }
+    }
+  }
+  if (sentAll) {
+    this.eventLists_ = [];
+  }
+  this.recursionDepth_--;
+};
+fb.core.view.EventList = function(path) {
+  this.path_ = path;
+  this.events_ = [];
+};
+fb.core.view.EventList.prototype.add = function(eventData) {
+  this.events_.push(eventData);
+};
+fb.core.view.EventList.prototype.raise = function() {
+  for (var i = 0;i < this.events_.length;i++) {
+    var eventData = this.events_[i];
+    if (eventData !== null) {
+      this.events_[i] = null;
+      var eventFn = eventData.getEventRunner();
+      if (fb.core.util.logger) {
+        fb.core.util.log("event: " + eventData.toString());
+      }
+      fb.core.util.exceptionGuard(eventFn);
+    }
+  }
+};
+fb.core.view.EventList.prototype.getPath = function() {
+  return this.path_;
+};
+goog.provide("fb.core.view.Change");
+fb.core.view.Change = function(type, snapshotNode, childName, oldSnap, prevName) {
+  this.type = type;
+  this.snapshotNode = snapshotNode;
+  this.childName = childName;
+  this.oldSnap = oldSnap;
+  this.prevName = prevName;
+};
+fb.core.view.Change.valueChange = function(snapshot) {
+  return new fb.core.view.Change(fb.core.view.Change.VALUE, snapshot);
+};
+fb.core.view.Change.childAddedChange = function(childKey, snapshot) {
+  return new fb.core.view.Change(fb.core.view.Change.CHILD_ADDED, snapshot, childKey);
+};
+fb.core.view.Change.childRemovedChange = function(childKey, snapshot) {
+  return new fb.core.view.Change(fb.core.view.Change.CHILD_REMOVED, snapshot, childKey);
+};
+fb.core.view.Change.childChangedChange = function(childKey, newSnapshot, oldSnapshot) {
+  return new fb.core.view.Change(fb.core.view.Change.CHILD_CHANGED, newSnapshot, childKey, oldSnapshot);
+};
+fb.core.view.Change.childMovedChange = function(childKey, snapshot) {
+  return new fb.core.view.Change(fb.core.view.Change.CHILD_MOVED, snapshot, childKey);
+};
+fb.core.view.Change.prototype.changeWithPrevName = function(prevName) {
+  return new fb.core.view.Change(this.type, this.snapshotNode, this.childName, this.oldSnap, prevName);
+};
+fb.core.view.Change.CHILD_ADDED = "child_added";
+fb.core.view.Change.CHILD_REMOVED = "child_removed";
+fb.core.view.Change.CHILD_CHANGED = "child_changed";
+fb.core.view.Change.CHILD_MOVED = "child_moved";
+fb.core.view.Change.VALUE = "value";
+goog.provide("fb.core.view.Event");
+fb.core.view.Event = function() {
+};
+fb.core.view.Event.prototype.getPath;
+fb.core.view.Event.prototype.getEventType;
+fb.core.view.Event.prototype.getEventRunner;
+fb.core.view.Event.prototype.toString;
+fb.core.view.DataEvent = function(eventType, eventRegistration, snapshot, prevName) {
+  this.eventRegistration = eventRegistration;
+  this.snapshot = snapshot;
+  this.prevName = prevName;
+  this.eventType = eventType;
+};
+fb.core.view.DataEvent.prototype.getPath = function() {
+  var ref = this.snapshot.ref();
+  if (this.eventType === "value") {
+    return ref.path;
+  } else {
+    return ref.parent().path;
+  }
+};
+fb.core.view.DataEvent.prototype.getEventType = function() {
+  return this.eventType;
+};
+fb.core.view.DataEvent.prototype.getEventRunner = function() {
+  return this.eventRegistration.getEventRunner(this);
+};
+fb.core.view.DataEvent.prototype.toString = function() {
+  return this.getPath().toString() + ":" + this.eventType + ":" + fb.util.json.stringify(this.snapshot.exportVal());
+};
+fb.core.view.CancelEvent = function(eventRegistration, error, path) {
+  this.eventRegistration = eventRegistration;
+  this.error = error;
+  this.path = path;
+};
+fb.core.view.CancelEvent.prototype.getPath = function() {
+  return this.path;
+};
+fb.core.view.CancelEvent.prototype.getEventType = function() {
+  return "cancel";
+};
+fb.core.view.CancelEvent.prototype.getEventRunner = function() {
+  return this.eventRegistration.getEventRunner(this);
+};
+fb.core.view.CancelEvent.prototype.toString = function() {
+  return this.path.toString() + ":cancel";
+};
+goog.provide("fb.core.view.CacheNode");
+fb.core.view.CacheNode = function(node, fullyInitialized, filtered) {
+  this.node_ = node;
+  this.fullyInitialized_ = fullyInitialized;
+  this.filtered_ = filtered;
+};
+fb.core.view.CacheNode.prototype.isFullyInitialized = function() {
+  return this.fullyInitialized_;
+};
+fb.core.view.CacheNode.prototype.isFiltered = function() {
+  return this.filtered_;
+};
+fb.core.view.CacheNode.prototype.isCompleteForPath = function(path) {
+  if (path.isEmpty()) {
+    return this.isFullyInitialized() && !this.filtered_;
+  } else {
+    var childKey = path.getFront();
+    return this.isCompleteForChild(childKey);
+  }
+};
+fb.core.view.CacheNode.prototype.isCompleteForChild = function(key) {
+  return this.isFullyInitialized() && !this.filtered_ || this.node_.hasChild(key);
+};
+fb.core.view.CacheNode.prototype.getNode = function() {
+  return this.node_;
+};
+goog.provide("fb.core.stats.StatsListener");
+fb.core.stats.StatsListener = function(collection) {
+  this.collection_ = collection;
+  this.last_ = null;
+};
+fb.core.stats.StatsListener.prototype.get = function() {
+  var newStats = this.collection_.get();
+  var delta = goog.object.clone(newStats);
+  if (this.last_) {
+    for (var stat in this.last_) {
+      delta[stat] = delta[stat] - this.last_[stat];
+    }
+  }
+  this.last_ = newStats;
+  return delta;
+};
+goog.provide("fb.core.stats.StatsReporter");
+var FIRST_STATS_MIN_TIME = 10 * 1E3;
+var FIRST_STATS_MAX_TIME = 30 * 1E3;
+var REPORT_STATS_INTERVAL = 5 * 60 * 1E3;
+fb.core.stats.StatsReporter = function(collection, connection) {
+  this.statsToReport_ = {};
+  this.statsListener_ = new fb.core.stats.StatsListener(collection);
+  this.server_ = connection;
+  var timeout = FIRST_STATS_MIN_TIME + (FIRST_STATS_MAX_TIME - FIRST_STATS_MIN_TIME) * Math.random();
+  setTimeout(goog.bind(this.reportStats_, this), Math.floor(timeout));
+};
+fb.core.stats.StatsReporter.prototype.includeStat = function(stat) {
+  this.statsToReport_[stat] = true;
+};
+fb.core.stats.StatsReporter.prototype.reportStats_ = function() {
+  var stats = this.statsListener_.get();
+  var reportedStats = {};
+  var haveStatsToReport = false;
+  for (var stat in stats) {
+    if (stats[stat] > 0 && fb.util.obj.contains(this.statsToReport_, stat)) {
+      reportedStats[stat] = stats[stat];
+      haveStatsToReport = true;
+    }
+  }
+  if (haveStatsToReport) {
+    this.server_.reportStats(reportedStats);
+  }
+  setTimeout(goog.bind(this.reportStats_, this), Math.floor(Math.random() * 2 * REPORT_STATS_INTERVAL));
+};
+goog.provide("fb.core.stats.StatsCollection");
+goog.require("fb.util.obj");
+goog.require("goog.array");
+goog.require("goog.object");
+fb.core.stats.StatsCollection = function() {
+  this.counters_ = {};
+};
+fb.core.stats.StatsCollection.prototype.incrementCounter = function(name, amount) {
+  if (!goog.isDef(amount)) {
+    amount = 1;
+  }
+  if (!fb.util.obj.contains(this.counters_, name)) {
+    this.counters_[name] = 0;
+  }
+  this.counters_[name] += amount;
+};
+fb.core.stats.StatsCollection.prototype.get = function() {
+  return goog.object.clone(this.counters_);
+};
+goog.provide("fb.core.stats.StatsManager");
+goog.require("fb.core.stats.StatsCollection");
+goog.require("fb.core.stats.StatsListener");
+goog.require("fb.core.stats.StatsReporter");
+fb.core.stats.StatsManager = {};
+fb.core.stats.StatsManager.collections_ = {};
+fb.core.stats.StatsManager.reporters_ = {};
+fb.core.stats.StatsManager.getCollection = function(repoInfo) {
+  var hashString = repoInfo.toString();
+  if (!fb.core.stats.StatsManager.collections_[hashString]) {
+    fb.core.stats.StatsManager.collections_[hashString] = new fb.core.stats.StatsCollection;
+  }
+  return fb.core.stats.StatsManager.collections_[hashString];
+};
+fb.core.stats.StatsManager.getOrCreateReporter = function(repoInfo, creatorFunction) {
+  var hashString = repoInfo.toString();
+  if (!fb.core.stats.StatsManager.reporters_[hashString]) {
+    fb.core.stats.StatsManager.reporters_[hashString] = creatorFunction();
+  }
+  return fb.core.stats.StatsManager.reporters_[hashString];
+};
+goog.provide("fb.core.ServerActions");
+fb.core.ServerActions = goog.defineClass(null, {listen:goog.abstractMethod, unlisten:goog.abstractMethod, put:goog.abstractMethod, merge:goog.abstractMethod, auth:goog.abstractMethod, unauth:goog.abstractMethod, onDisconnectPut:goog.abstractMethod, onDisconnectMerge:goog.abstractMethod, onDisconnectCancel:goog.abstractMethod, reportStats:goog.abstractMethod});
+goog.provide("fb.core.snap.Node");
+goog.provide("fb.core.snap.NamedNode");
+fb.core.snap.Node = function() {
+};
+fb.core.snap.Node.prototype.isLeafNode;
+fb.core.snap.Node.prototype.getPriority;
+fb.core.snap.Node.prototype.updatePriority;
+fb.core.snap.Node.prototype.getImmediateChild;
+fb.core.snap.Node.prototype.getChild;
+fb.core.snap.Node.prototype.getPredecessorChildName;
+fb.core.snap.Node.prototype.updateImmediateChild;
+fb.core.snap.Node.prototype.updateChild;
+fb.core.snap.Node.prototype.hasChild;
+fb.core.snap.Node.prototype.isEmpty;
+fb.core.snap.Node.prototype.numChildren;
+fb.core.snap.Node.prototype.val;
+fb.core.snap.Node.prototype.hash;
+fb.core.snap.Node.prototype.compareTo;
+fb.core.snap.Node.prototype.equals;
+fb.core.snap.Node.prototype.withIndex;
+fb.core.snap.Node.prototype.isIndexed;
+fb.core.snap.NamedNode = function(name, node) {
+  this.name = name;
+  this.node = node;
+};
+fb.core.snap.NamedNode.Wrap = function(name, node) {
+  return new fb.core.snap.NamedNode(name, node);
+};
+goog.provide("fb.core.snap.comparators");
+fb.core.snap.NAME_ONLY_COMPARATOR = function(left, right) {
+  return fb.core.util.nameCompare(left.name, right.name);
+};
+fb.core.snap.NAME_COMPARATOR = function(left, right) {
+  return fb.core.util.nameCompare(left, right);
+};
+goog.provide("fb.core.operation.Overwrite");
+fb.core.operation.Overwrite = function(source, path, snap) {
+  this.type = fb.core.OperationType.OVERWRITE;
+  this.source = source;
+  this.path = path;
+  this.snap = snap;
+};
+fb.core.operation.Overwrite.prototype.operationForChild = function(childName) {
+  if (this.path.isEmpty()) {
+    return new fb.core.operation.Overwrite(this.source, fb.core.util.Path.Empty, this.snap.getImmediateChild(childName));
+  } else {
+    return new fb.core.operation.Overwrite(this.source, this.path.popFront(), this.snap);
+  }
+};
+if (goog.DEBUG) {
+  fb.core.operation.Overwrite.prototype.toString = function() {
+    return "Operation(" + this.path + ": " + this.source.toString() + " overwrite: " + this.snap.toString() + ")";
+  };
+}
+;goog.provide("fb.core.operation.AckUserWrite");
+fb.core.operation.AckUserWrite = function(path, revert) {
+  this.type = fb.core.OperationType.ACK_USER_WRITE;
+  this.source = fb.core.OperationSource.User;
+  this.path = path;
+  this.revert = revert;
+};
+fb.core.operation.AckUserWrite.prototype.operationForChild = function(childName) {
+  if (!this.path.isEmpty()) {
+    return new fb.core.operation.AckUserWrite(this.path.popFront(), this.revert);
+  } else {
+    return this;
+  }
+};
+if (goog.DEBUG) {
+  fb.core.operation.AckUserWrite.prototype.toString = function() {
+    return "Operation(" + this.path + ": " + this.source.toString() + " ack write revert=" + this.revert + ")";
+  };
+}
+;goog.provide("fb.core.operation.ListenComplete");
+fb.core.operation.ListenComplete = function(source, path) {
+  this.type = fb.core.OperationType.LISTEN_COMPLETE;
+  this.source = source;
+  this.path = path;
+};
+fb.core.operation.ListenComplete.prototype.operationForChild = function(childName) {
+  if (this.path.isEmpty()) {
+    return new fb.core.operation.ListenComplete(this.source, fb.core.util.Path.Empty);
+  } else {
+    return new fb.core.operation.ListenComplete(this.source, this.path.popFront());
+  }
+};
+if (goog.DEBUG) {
+  fb.core.operation.ListenComplete.prototype.toString = function() {
+    return "Operation(" + this.path + ": " + this.source.toString() + " listen_complete)";
+  };
+}
+;goog.provide("fb.core.util.SortedMap");
+goog.require("goog.array");
+fb.Comparator;
+fb.core.util.SortedMap = goog.defineClass(null, {constructor:function(comparator, opt_root) {
+  this.comparator_ = comparator;
+  this.root_ = opt_root ? opt_root : fb.core.util.SortedMap.EMPTY_NODE_;
+}, insert:function(key, value) {
+  return new fb.core.util.SortedMap(this.comparator_, this.root_.insert(key, value, this.comparator_).copy(null, null, fb.LLRBNode.BLACK, null, null));
+}, remove:function(key) {
+  return new fb.core.util.SortedMap(this.comparator_, this.root_.remove(key, this.comparator_).copy(null, null, fb.LLRBNode.BLACK, null, null));
+}, get:function(key) {
+  var cmp;
+  var node = this.root_;
+  while (!node.isEmpty()) {
+    cmp = this.comparator_(key, node.key);
+    if (cmp === 0) {
+      return node.value;
+    } else {
+      if (cmp < 0) {
+        node = node.left;
+      } else {
+        if (cmp > 0) {
+          node = node.right;
+        }
+      }
+    }
+  }
+  return null;
+}, getPredecessorKey:function(key) {
+  var cmp, node = this.root_, rightParent = null;
+  while (!node.isEmpty()) {
+    cmp = this.comparator_(key, node.key);
+    if (cmp === 0) {
+      if (!node.left.isEmpty()) {
+        node = node.left;
+        while (!node.right.isEmpty()) {
+          node = node.right;
+        }
+        return node.key;
+      } else {
+        if (rightParent) {
+          return rightParent.key;
+        } else {
+          return null;
+        }
+      }
+    } else {
+      if (cmp < 0) {
+        node = node.left;
+      } else {
+        if (cmp > 0) {
+          rightParent = node;
+          node = node.right;
+        }
+      }
+    }
+  }
+  throw new Error("Attempted to find predecessor key for a nonexistent key.  What gives?");
+}, isEmpty:function() {
+  return this.root_.isEmpty();
+}, count:function() {
+  return this.root_.count();
+}, minKey:function() {
+  return this.root_.minKey();
+}, maxKey:function() {
+  return this.root_.maxKey();
+}, inorderTraversal:function(action) {
+  return this.root_.inorderTraversal(action);
+}, reverseTraversal:function(action) {
+  return this.root_.reverseTraversal(action);
+}, getIterator:function(opt_resultGenerator) {
+  return new fb.core.util.SortedMapIterator(this.root_, null, this.comparator_, false, opt_resultGenerator);
+}, getIteratorFrom:function(key, opt_resultGenerator) {
+  return new fb.core.util.SortedMapIterator(this.root_, key, this.comparator_, false, opt_resultGenerator);
+}, getReverseIteratorFrom:function(key, opt_resultGenerator) {
+  return new fb.core.util.SortedMapIterator(this.root_, key, this.comparator_, true, opt_resultGenerator);
+}, getReverseIterator:function(opt_resultGenerator) {
+  return new fb.core.util.SortedMapIterator(this.root_, null, this.comparator_, true, opt_resultGenerator);
+}});
+fb.core.util.SortedMapIterator = goog.defineClass(null, {constructor:function(node, startKey, comparator, isReverse, opt_resultGenerator) {
+  this.resultGenerator_ = opt_resultGenerator || null;
+  this.isReverse_ = isReverse;
+  this.nodeStack_ = [];
+  var cmp = 1;
+  while (!node.isEmpty()) {
+    cmp = startKey ? comparator(node.key, startKey) : 1;
+    if (isReverse) {
+      cmp *= -1;
+    }
+    if (cmp < 0) {
+      if (this.isReverse_) {
+        node = node.left;
+      } else {
+        node = node.right;
+      }
+    } else {
+      if (cmp === 0) {
+        this.nodeStack_.push(node);
+        break;
+      } else {
+        this.nodeStack_.push(node);
+        if (this.isReverse_) {
+          node = node.right;
+        } else {
+          node = node.left;
+        }
+      }
+    }
+  }
+}, getNext:function() {
+  if (this.nodeStack_.length === 0) {
+    return null;
+  }
+  var node = this.nodeStack_.pop(), result;
+  if (this.resultGenerator_) {
+    result = this.resultGenerator_(node.key, node.value);
+  } else {
+    result = {key:node.key, value:node.value};
+  }
+  if (this.isReverse_) {
+    node = node.left;
+    while (!node.isEmpty()) {
+      this.nodeStack_.push(node);
+      node = node.right;
+    }
+  } else {
+    node = node.right;
+    while (!node.isEmpty()) {
+      this.nodeStack_.push(node);
+      node = node.left;
+    }
+  }
+  return result;
+}, hasNext:function() {
+  return this.nodeStack_.length > 0;
+}, peek:function() {
+  if (this.nodeStack_.length === 0) {
+    return null;
+  }
+  var node = goog.array.peek(this.nodeStack_);
+  if (this.resultGenerator_) {
+    return this.resultGenerator_(node.key, node.value);
+  } else {
+    return{key:node.key, value:node.value};
+  }
+}});
+fb.LLRBNode = goog.defineClass(null, {constructor:function(key, value, color, opt_left, opt_right) {
+  this.key = key;
+  this.value = value;
+  this.color = color != null ? color : fb.LLRBNode.RED;
+  this.left = opt_left != null ? opt_left : fb.core.util.SortedMap.EMPTY_NODE_;
+  this.right = opt_right != null ? opt_right : fb.core.util.SortedMap.EMPTY_NODE_;
+}, statics:{RED:true, BLACK:false}, copy:function(key, value, color, left, right) {
+  return new fb.LLRBNode(key != null ? key : this.key, value != null ? value : this.value, color != null ? color : this.color, left != null ? left : this.left, right != null ? right : this.right);
+}, count:function() {
+  return this.left.count() + 1 + this.right.count();
+}, isEmpty:function() {
+  return false;
+}, inorderTraversal:function(action) {
+  return this.left.inorderTraversal(action) || action(this.key, this.value) || this.right.inorderTraversal(action);
+}, reverseTraversal:function(action) {
+  return this.right.reverseTraversal(action) || action(this.key, this.value) || this.left.reverseTraversal(action);
+}, min_:function() {
+  if (this.left.isEmpty()) {
+    return this;
+  } else {
+    return this.left.min_();
+  }
+}, minKey:function() {
+  return this.min_().key;
+}, maxKey:function() {
+  if (this.right.isEmpty()) {
+    return this.key;
+  } else {
+    return this.right.maxKey();
+  }
+}, insert:function(key, value, comparator) {
+  var cmp, n;
+  n = this;
+  cmp = comparator(key, n.key);
+  if (cmp < 0) {
+    n = n.copy(null, null, null, n.left.insert(key, value, comparator), null);
+  } else {
+    if (cmp === 0) {
+      n = n.copy(null, value, null, null, null);
+    } else {
+      n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));
+    }
+  }
+  return n.fixUp_();
+}, removeMin_:function() {
+  var n;
+  if (this.left.isEmpty()) {
+    return fb.core.util.SortedMap.EMPTY_NODE_;
+  }
+  n = this;
+  if (!n.left.isRed_() && !n.left.left.isRed_()) {
+    n = n.moveRedLeft_();
+  }
+  n = n.copy(null, null, null, n.left.removeMin_(), null);
+  return n.fixUp_();
+}, remove:function(key, comparator) {
+  var n, smallest;
+  n = this;
+  if (comparator(key, n.key) < 0) {
+    if (!n.left.isEmpty() && !n.left.isRed_() && !n.left.left.isRed_()) {
+      n = n.moveRedLeft_();
+    }
+    n = n.copy(null, null, null, n.left.remove(key, comparator), null);
+  } else {
+    if (n.left.isRed_()) {
+      n = n.rotateRight_();
+    }
+    if (!n.right.isEmpty() && !n.right.isRed_() && !n.right.left.isRed_()) {
+      n = n.moveRedRight_();
+    }
+    if (comparator(key, n.key) === 0) {
+      if (n.right.isEmpty()) {
+        return fb.core.util.SortedMap.EMPTY_NODE_;
+      } else {
+        smallest = n.right.min_();
+        n = n.copy(smallest.key, smallest.value, null, null, n.right.removeMin_());
+      }
+    }
+    n = n.copy(null, null, null, null, n.right.remove(key, comparator));
+  }
+  return n.fixUp_();
+}, isRed_:function() {
+  return this.color;
+}, fixUp_:function() {
+  var n = this;
+  if (n.right.isRed_() && !n.left.isRed_()) {
+    n = n.rotateLeft_();
+  }
+  if (n.left.isRed_() && n.left.left.isRed_()) {
+    n = n.rotateRight_();
+  }
+  if (n.left.isRed_() && n.right.isRed_()) {
+    n = n.colorFlip_();
+  }
+  return n;
+}, moveRedLeft_:function() {
+  var n = this.colorFlip_();
+  if (n.right.left.isRed_()) {
+    n = n.copy(null, null, null, null, n.right.rotateRight_());
+    n = n.rotateLeft_();
+    n = n.colorFlip_();
+  }
+  return n;
+}, moveRedRight_:function() {
+  var n = this.colorFlip_();
+  if (n.left.left.isRed_()) {
+    n = n.rotateRight_();
+    n = n.colorFlip_();
+  }
+  return n;
+}, rotateLeft_:function() {
+  var nl;
+  nl = this.copy(null, null, fb.LLRBNode.RED, null, this.right.left);
+  return this.right.copy(null, null, this.color, nl, null);
+}, rotateRight_:function() {
+  var nr;
+  nr = this.copy(null, null, fb.LLRBNode.RED, this.left.right, null);
+  return this.left.copy(null, null, this.color, null, nr);
+}, colorFlip_:function() {
+  var left, right;
+  left = this.left.copy(null, null, !this.left.color, null, null);
+  right = this.right.copy(null, null, !this.right.color, null, null);
+  return this.copy(null, null, !this.color, left, right);
+}, checkMaxDepth_:function() {
+  var blackDepth;
+  blackDepth = this.check_();
+  if (Math.pow(2, blackDepth) <= this.count() + 1) {
+    return true;
+  } else {
+    return false;
+  }
+}, check_:function() {
+  var blackDepth;
+  if (this.isRed_() && this.left.isRed_()) {
+    throw new Error("Red node has red child(" + this.key + "," + this.value + ")");
+  }
+  if (this.right.isRed_()) {
+    throw new Error("Right child of (" + this.key + "," + this.value + ") is red");
+  }
+  blackDepth = this.left.check_();
+  if (blackDepth !== this.right.check_()) {
+    throw new Error("Black depths differ");
+  } else {
+    return blackDepth + (this.isRed_() ? 0 : 1);
+  }
+}});
+fb.LLRBEmptyNode = goog.defineClass(null, {constructor:function() {
+}, copy:function() {
+  return this;
+}, insert:function(key, value, comparator) {
+  return new fb.LLRBNode(key, value, null);
+}, remove:function(key, comparator) {
+  return this;
+}, count:function() {
+  return 0;
+}, isEmpty:function() {
+  return true;
+}, inorderTraversal:function(action) {
+  return false;
+}, reverseTraversal:function(action) {
+  return false;
+}, minKey:function() {
+  return null;
+}, maxKey:function() {
+  return null;
+}, check_:function() {
+  return 0;
+}, isRed_:function() {
+  return false;
+}});
+fb.core.util.SortedMap.EMPTY_NODE_ = new fb.LLRBEmptyNode;
+goog.provide("fb.core.util.NodePatches");
+(function() {
+  if (NODE_CLIENT) {
+    var version = process["version"];
+    if (version === "v0.10.22" || version === "v0.10.23" || version === "v0.10.24") {
+      var Writable = require("_stream_writable");
+      Writable["prototype"]["write"] = function(chunk, encoding, cb) {
+        var state = this["_writableState"];
+        var ret = false;
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = null;
+        }
+        if (Buffer["isBuffer"](chunk)) {
+          encoding = "buffer";
+        } else {
+          if (!encoding) {
+            encoding = state["defaultEncoding"];
+          }
+        }
+        if (typeof cb !== "function") {
+          cb = function() {
+          };
+        }
+        if (state["ended"]) {
+          writeAfterEnd(this, state, cb);
+        } else {
+          if (validChunk(this, state, chunk, cb)) {
+            ret = writeOrBuffer(this, state, chunk, encoding, cb);
+          }
+        }
+        return ret;
+      };
+      function writeAfterEnd(stream, state, cb) {
+        var er = new Error("write after end");
+        stream["emit"]("error", er);
+        process["nextTick"](function() {
+          cb(er);
+        });
+      }
+      function validChunk(stream, state, chunk, cb) {
+        var valid = true;
+        if (!Buffer["isBuffer"](chunk) && "string" !== typeof chunk && chunk !== null && chunk !== undefined && !state["objectMode"]) {
+          var er = new TypeError("Invalid non-string/buffer chunk");
+          stream["emit"]("error", er);
+          process["nextTick"](function() {
+            cb(er);
+          });
+          valid = false;
+        }
+        return valid;
+      }
+      function writeOrBuffer(stream, state, chunk, encoding, cb) {
+        chunk = decodeChunk(state, chunk, encoding);
+        if (Buffer["isBuffer"](chunk)) {
+          encoding = "buffer";
+        }
+        var len = state["objectMode"] ? 1 : chunk["length"];
+        state["length"] += len;
+        var ret = state["length"] < state["highWaterMark"];
+        if (!ret) {
+          state["needDrain"] = true;
+        }
+        if (state["writing"]) {
+          state["buffer"]["push"](new WriteReq(chunk, encoding, cb));
+        } else {
+          doWrite(stream, state, len, chunk, encoding, cb);
+        }
+        return ret;
+      }
+      function decodeChunk(state, chunk, encoding) {
+        if (!state["objectMode"] && state["decodeStrings"] !== false && typeof chunk === "string") {
+          chunk = new Buffer(chunk, encoding);
+        }
+        return chunk;
+      }
+      function WriteReq(chunk, encoding, cb) {
+        this["chunk"] = chunk;
+        this["encoding"] = encoding;
+        this["callback"] = cb;
+      }
+      function doWrite(stream, state, len, chunk, encoding, cb) {
+        state["writelen"] = len;
+        state["writecb"] = cb;
+        state["writing"] = true;
+        state["sync"] = true;
+        stream["_write"](chunk, encoding, state["onwrite"]);
+        state["sync"] = false;
+      }
+      var Duplex = require("_stream_duplex");
+      Duplex["prototype"]["write"] = Writable["prototype"]["write"];
+    }
+  }
+})();
+goog.provide("fb.core.util.ServerValues");
+fb.core.util.ServerValues.generateWithValues = function(values) {
+  values = values || {};
+  values["timestamp"] = values["timestamp"] || (new Date).getTime();
+  return values;
+};
+fb.core.util.ServerValues.resolveDeferredValue = function(value, serverValues) {
+  if (!value || typeof value !== "object") {
+    return(value);
+  } else {
+    fb.core.util.assert(".sv" in value, "Unexpected leaf node or priority contents");
+    return serverValues[value[".sv"]];
+  }
+};
+fb.core.util.ServerValues.resolveDeferredValueTree = function(tree, serverValues) {
+  var resolvedTree = new fb.core.SparseSnapshotTree;
+  tree.forEachTree(new fb.core.util.Path(""), function(path, node) {
+    resolvedTree.remember(path, fb.core.util.ServerValues.resolveDeferredValueSnapshot(node, serverValues));
+  });
+  return resolvedTree;
+};
+fb.core.util.ServerValues.resolveDeferredValueSnapshot = function(node, serverValues) {
+  var rawPri = (node.getPriority().val()), priority = fb.core.util.ServerValues.resolveDeferredValue(rawPri, serverValues), newNode;
+  if (node.isLeafNode()) {
+    var leafNode = (node);
+    var value = fb.core.util.ServerValues.resolveDeferredValue(leafNode.getValue(), serverValues);
+    if (value !== leafNode.getValue() || priority !== leafNode.getPriority().val()) {
+      return new fb.core.snap.LeafNode(value, fb.core.snap.NodeFromJSON(priority));
+    } else {
+      return node;
+    }
+  } else {
+    var childrenNode = (node);
+    newNode = childrenNode;
+    if (priority !== childrenNode.getPriority().val()) {
+      newNode = newNode.updatePriority(new fb.core.snap.LeafNode(priority));
+    }
+    childrenNode.forEachChild(fb.core.snap.PriorityIndex, function(childName, childNode) {
+      var newChildNode = fb.core.util.ServerValues.resolveDeferredValueSnapshot(childNode, serverValues);
+      if (newChildNode !== childNode) {
+        newNode = newNode.updateImmediateChild(childName, newChildNode);
+      }
+    });
+    return newNode;
+  }
+};
+goog.provide("fb.core.util.Path");
+goog.provide("fb.core.util.ValidationPath");
+fb.core.util.Path = goog.defineClass(null, {constructor:function(pathOrString, opt_pieceNum) {
+  if (arguments.length == 1) {
+    this.pieces_ = pathOrString.split("/");
+    var copyTo = 0;
+    for (var i = 0;i < this.pieces_.length;i++) {
+      if (this.pieces_[i].length > 0) {
+        this.pieces_[copyTo] = this.pieces_[i];
+        copyTo++;
+      }
+    }
+    this.pieces_.length = copyTo;
+    this.pieceNum_ = 0;
+  } else {
+    this.pieces_ = pathOrString;
+    this.pieceNum_ = opt_pieceNum;
+  }
+}, getFront:function() {
+  if (this.pieceNum_ >= this.pieces_.length) {
+    return null;
+  }
+  return this.pieces_[this.pieceNum_];
+}, getLength:function() {
+  return this.pieces_.length - this.pieceNum_;
+}, popFront:function() {
+  var pieceNum = this.pieceNum_;
+  if (pieceNum < this.pieces_.length) {
+    pieceNum++;
+  }
+  return new fb.core.util.Path(this.pieces_, pieceNum);
+}, getBack:function() {
+  if (this.pieceNum_ < this.pieces_.length) {
+    return this.pieces_[this.pieces_.length - 1];
+  }
+  return null;
+}, toString:function() {
+  var pathString = "";
+  for (var i = this.pieceNum_;i < this.pieces_.length;i++) {
+    if (this.pieces_[i] !== "") {
+      pathString += "/" + this.pieces_[i];
+    }
+  }
+  return pathString || "/";
+}, toUrlEncodedString:function() {
+  var pathString = "";
+  for (var i = this.pieceNum_;i < this.pieces_.length;i++) {
+    if (this.pieces_[i] !== "") {
+      pathString += "/" + goog.string.urlEncode(this.pieces_[i]);
+    }
+  }
+  return pathString || "/";
+}, slice:function(opt_begin) {
+  var begin = opt_begin || 0;
+  return this.pieces_.slice(this.pieceNum_ + begin);
+}, parent:function() {
+  if (this.pieceNum_ >= this.pieces_.length) {
+    return null;
+  }
+  var pieces = [];
+  for (var i = this.pieceNum_;i < this.pieces_.length - 1;i++) {
+    pieces.push(this.pieces_[i]);
+  }
+  return new fb.core.util.Path(pieces, 0);
+}, child:function(childPathObj) {
+  var pieces = [];
+  for (var i = this.pieceNum_;i < this.pieces_.length;i++) {
+    pieces.push(this.pieces_[i]);
+  }
+  if (childPathObj instanceof fb.core.util.Path) {
+    for (i = childPathObj.pieceNum_;i < childPathObj.pieces_.length;i++) {
+      pieces.push(childPathObj.pieces_[i]);
+    }
+  } else {
+    var childPieces = childPathObj.split("/");
+    for (i = 0;i < childPieces.length;i++) {
+      if (childPieces[i].length > 0) {
+        pieces.push(childPieces[i]);
+      }
+    }
+  }
+  return new fb.core.util.Path(pieces, 0);
+}, isEmpty:function() {
+  return this.pieceNum_ >= this.pieces_.length;
+}, statics:{relativePath:function(outerPath, innerPath) {
+  var outer = outerPath.getFront(), inner = innerPath.getFront();
+  if (outer === null) {
+    return innerPath;
+  } else {
+    if (outer === inner) {
+      return fb.core.util.Path.relativePath(outerPath.popFront(), innerPath.popFront());
+    } else {
+      throw new Error("INTERNAL ERROR: innerPath (" + innerPath + ") is not within " + "outerPath (" + outerPath + ")");
+    }
+  }
+}}, equals:function(other) {
+  if (this.getLength() !== other.getLength()) {
+    return false;
+  }
+  for (var i = this.pieceNum_, j = other.pieceNum_;i <= this.pieces_.length;i++, j++) {
+    if (this.pieces_[i] !== other.pieces_[j]) {
+      return false;
+    }
+  }
+  return true;
+}, contains:function(other) {
+  var i = this.pieceNum_;
+  var j = other.pieceNum_;
+  if (this.getLength() > other.getLength()) {
+    return false;
+  }
+  while (i < this.pieces_.length) {
+    if (this.pieces_[i] !== other.pieces_[j]) {
+      return false;
+    }
+    ++i;
+    ++j;
+  }
+  return true;
+}});
+fb.core.util.Path.Empty = new fb.core.util.Path("");
+fb.core.util.ValidationPath = goog.defineClass(null, {constructor:function(path, errorPrefix) {
+  this.parts_ = path.slice();
+  this.byteLength_ = Math.max(1, this.parts_.length);
+  this.errorPrefix_ = errorPrefix;
+  for (var i = 0;i < this.parts_.length;i++) {
+    this.byteLength_ += fb.util.utf8.stringLength(this.parts_[i]);
+  }
+  this.checkValid_();
+}, statics:{MAX_PATH_DEPTH:32, MAX_PATH_LENGTH_BYTES:768}, push:function(child) {
+  if (this.parts_.length > 0) {
+    this.byteLength_ += 1;
+  }
+  this.parts_.push(child);
+  this.byteLength_ += fb.util.utf8.stringLength(child);
+  this.checkValid_();
+}, pop:function() {
+  var last = this.parts_.pop();
+  this.byteLength_ -= fb.util.utf8.stringLength(last);
+  if (this.parts_.length > 0) {
+    this.byteLength_ -= 1;
+  }
+}, checkValid_:function() {
+  if (this.byteLength_ > fb.core.util.ValidationPath.MAX_PATH_LENGTH_BYTES) {
+    throw new Error(this.errorPrefix_ + "has a key path longer than " + fb.core.util.ValidationPath.MAX_PATH_LENGTH_BYTES + " bytes (" + this.byteLength_ + ").");
+  }
+  if (this.parts_.length > fb.core.util.ValidationPath.MAX_PATH_DEPTH) {
+    throw new Error(this.errorPrefix_ + "path specified exceeds the maximum depth that can be written (" + fb.core.util.ValidationPath.MAX_PATH_DEPTH + ") or object contains a cycle " + this.toErrorString());
+  }
+}, toErrorString:function() {
+  if (this.parts_.length == 0) {
+    return "";
+  }
+  return "in property '" + this.parts_.join(".") + "'";
+}});
+goog.provide("fb.core.storage.MemoryStorage");
+goog.require("fb.util.obj");
+goog.scope(function() {
+  var obj = fb.util.obj;
+  fb.core.storage.MemoryStorage = function() {
+    this.cache_ = {};
+  };
+  var MemoryStorage = fb.core.storage.MemoryStorage;
+  MemoryStorage.prototype.set = function(key, value) {
+    if (value == null) {
+      delete this.cache_[key];
+    } else {
+      this.cache_[key] = value;
+    }
+  };
+  MemoryStorage.prototype.get = function(key) {
+    if (obj.contains(this.cache_, key)) {
+      return this.cache_[key];
+    }
+    return null;
+  };
+  MemoryStorage.prototype.remove = function(key) {
+    delete this.cache_[key];
+  };
+  MemoryStorage.prototype.isInMemoryStorage = true;
+});
+goog.provide("fb.core.storage.DOMStorageWrapper");
+goog.require("fb.util.obj");
+goog.scope(function() {
+  fb.core.storage.DOMStorageWrapper = function(domStorage) {
+    this.domStorage_ = domStorage;
+    this.prefix_ = "firebase:";
+  };
+  var DOMStorageWrapper = fb.core.storage.DOMStorageWrapper;
+  DOMStorageWrapper.prototype.set = function(key, value) {
+    if (value == null) {
+      this.domStorage_.removeItem(this.prefixedName_(key));
+    } else {
+      this.domStorage_.setItem(this.prefixedName_(key), fb.util.json.stringify(value));
+    }
+  };
+  DOMStorageWrapper.prototype.get = function(key) {
+    var storedVal = this.domStorage_.getItem(this.prefixedName_(key));
+    if (storedVal == null) {
+      return null;
+    } else {
+      return fb.util.json.eval(storedVal);
+    }
+  };
+  DOMStorageWrapper.prototype.remove = function(key) {
+    this.domStorage_.removeItem(this.prefixedName_(key));
+  };
+  DOMStorageWrapper.prototype.isInMemoryStorage = false;
+  DOMStorageWrapper.prototype.prefixedName_ = function(name) {
+    return this.prefix_ + name;
+  };
+  DOMStorageWrapper.prototype.toString = function() {
+    return this.domStorage_.toString();
+  };
+});
+goog.provide("fb.core.storage");
+goog.require("fb.core.storage.DOMStorageWrapper");
+goog.require("fb.core.storage.MemoryStorage");
+fb.core.storage.createStoragefor = function(domStorageName) {
+  try {
+    if (typeof window !== "undefined" && typeof window[domStorageName] !== "undefined") {
+      var domStorage = window[domStorageName];
+      domStorage.setItem("firebase:sentinel", "cache");
+      domStorage.removeItem("firebase:sentinel");
+      return new fb.core.storage.DOMStorageWrapper(domStorage);
+    }
+  } catch (e) {
+  }
+  return new fb.core.storage.MemoryStorage;
+};
+fb.core.storage.PersistentStorage = fb.core.storage.createStoragefor("localStorage");
+fb.core.storage.SessionStorage = fb.core.storage.createStoragefor("sessionStorage");
+goog.provide("fb.core.RepoInfo");
+goog.require("fb.core.storage");
+fb.core.RepoInfo = function(host, secure, namespace, webSocketOnly, persistenceKey) {
+  this.host = host.toLowerCase();
+  this.domain = this.host.substr(this.host.indexOf(".") + 1);
+  this.secure = secure;
+  this.namespace = namespace;
+  this.webSocketOnly = webSocketOnly;
+  this.persistenceKey = persistenceKey || "";
+  this.internalHost = fb.core.storage.PersistentStorage.get("host:" + host) || this.host;
+};
+fb.core.RepoInfo.prototype.needsQueryParam = function() {
+  return this.host !== this.internalHost;
+};
+fb.core.RepoInfo.prototype.isCacheableHost = function() {
+  return this.internalHost.substr(0, 2) === "s-";
+};
+fb.core.RepoInfo.prototype.isDemoHost = function() {
+  return this.domain === "firebaseio-demo.com";
+};
+fb.core.RepoInfo.prototype.isCustomHost = function() {
+  return this.domain !== "firebaseio.com" && this.domain !== "firebaseio-demo.com";
+};
+fb.core.RepoInfo.prototype.updateHost = function(newHost) {
+  if (newHost !== this.internalHost) {
+    this.internalHost = newHost;
+    if (this.isCacheableHost()) {
+      fb.core.storage.PersistentStorage.set("host:" + this.host, this.internalHost);
+    }
+  }
+};
+fb.core.RepoInfo.prototype.toString = function() {
+  var str = (this.secure ? "https://" : "http://") + this.host;
+  if (this.persistenceKey) {
+    str += "<" + this.persistenceKey + ">";
+  }
+  return str;
+};
+goog.provide("fb.core.util");
+goog.require("fb.constants");
+goog.require("fb.core.RepoInfo");
+goog.require("fb.core.storage");
+goog.require("fb.util.json");
+goog.require("goog.crypt.Sha1");
+goog.require("goog.crypt.base64");
+goog.require("goog.object");
+goog.require("goog.string");
+fb.core.util.LUIDGenerator = function() {
+  var id = 1;
+  return function() {
+    return id++;
+  };
+}();
+fb.core.util.assert = function(assertion, message) {
+  if (!assertion) {
+    throw fb.core.util.assertionError(message);
+  }
+};
+fb.core.util.assertionError = function(message) {
+  return new Error("Firebase (" + Firebase.SDK_VERSION + ") INTERNAL ASSERT FAILED: " + message);
+};
+fb.core.util.assertWeak = function(assertion, message) {
+  if (!assertion) {
+    fb.core.util.error(message);
+  }
+};
+fb.core.util.base64Encode = function(str) {
+  var utf8Bytes = fb.util.utf8.stringToByteArray(str);
+  return goog.crypt.base64.encodeByteArray(utf8Bytes, true);
+};
+fb.core.util.base64Decode = function(str) {
+  try {
+    if (NODE_CLIENT) {
+      return(new Buffer(str, "base64")).toString("utf8");
+    } else {
+      if (typeof atob !== "undefined") {
+        return atob(str);
+      } else {
+        return goog.crypt.base64.decodeString(str, true);
+      }
+    }
+  } catch (e) {
+    fb.core.util.log("base64Decode failed: ", e);
+  }
+  return null;
+};
+fb.core.util.sha1 = function(str) {
+  var utf8Bytes = fb.util.utf8.stringToByteArray(str);
+  var sha1 = new goog.crypt.Sha1;
+  sha1.update(utf8Bytes);
+  var sha1Bytes = sha1.digest();
+  return goog.crypt.base64.encodeByteArray(sha1Bytes);
+};
+fb.core.util.buildLogMessage_ = function(var_args) {
+  var message = "";
+  for (var i = 0;i < arguments.length;i++) {
+    if (goog.isArrayLike(arguments[i])) {
+      message += fb.core.util.buildLogMessage_.apply(null, arguments[i]);
+    } else {
+      if (typeof arguments[i] === "object") {
+        message += fb.util.json.stringify(arguments[i]);
+      } else {
+        message += arguments[i];
+      }
+    }
+    message += " ";
+  }
+  return message;
+};
+fb.core.util.logger = null;
+fb.core.util.firstLog_ = true;
+fb.core.util.log = function(var_args) {
+  if (fb.core.util.firstLog_ === true) {
+    fb.core.util.firstLog_ = false;
+    if (fb.core.util.logger === null && fb.core.storage.SessionStorage.get("logging_enabled") === true) {
+      Firebase.enableLogging(true);
+    }
+  }
+  if (fb.core.util.logger) {
+    var message = fb.core.util.buildLogMessage_.apply(null, arguments);
+    fb.core.util.logger(message);
+  }
+};
+fb.core.util.logWrapper = function(prefix) {
+  return function() {
+    fb.core.util.log(prefix, arguments);
+  };
+};
+fb.core.util.error = function(var_args) {
+  if (typeof console !== "undefined") {
+    var message = "FIREBASE INTERNAL ERROR: " + fb.core.util.buildLogMessage_.apply(null, arguments);
+    if (typeof console.error !== "undefined") {
+      console.error(message);
+    } else {
+      console.log(message);
+    }
+  }
+};
+fb.core.util.fatal = function(var_args) {
+  var message = fb.core.util.buildLogMessage_.apply(null, arguments);
+  throw new Error("FIREBASE FATAL ERROR: " + message);
+};
+fb.core.util.warn = function(var_args) {
+  if (typeof console !== "undefined") {
+    var message = "FIREBASE WARNING: " + fb.core.util.buildLogMessage_.apply(null, arguments);
+    if (typeof console.warn !== "undefined") {
+      console.warn(message);
+    } else {
+      console.log(message);
+    }
+  }
+};
+fb.core.util.warnIfPageIsSecure = function() {
+  if (typeof window !== "undefined" && window.location && window.location.protocol && window.location.protocol.indexOf("https:") !== -1) {
+    fb.core.util.warn("Insecure Firebase access from a secure page. " + "Please use https in calls to new Firebase().");
+  }
+};
+fb.core.util.warnAboutUnsupportedMethod = function(methodName) {
+  fb.core.util.warn(methodName + " is unsupported and will likely change soon.  " + "Please do not use.");
+};
+fb.core.util.parseRepoInfo = function(dataURL) {
+  var parsedUrl = fb.core.util.parseURL(dataURL), namespace = parsedUrl.subdomain;
+  if (parsedUrl.domain === "firebase") {
+    fb.core.util.fatal(parsedUrl.host + " is no longer supported. " + "Please use <YOUR FIREBASE>.firebaseio.com instead");
+  }
+  if (!namespace) {
+    fb.core.util.fatal("Cannot parse Firebase url. " + "Please use https://<YOUR FIREBASE>.firebaseio.com");
+  }
+  if (!parsedUrl.secure) {
+    fb.core.util.warnIfPageIsSecure();
+  }
+  var webSocketOnly = parsedUrl.scheme === "ws" || parsedUrl.scheme === "wss";
+  return{repoInfo:new fb.core.RepoInfo(parsedUrl.host, parsedUrl.secure, namespace, webSocketOnly), path:new fb.core.util.Path(parsedUrl.pathString)};
+};
+fb.core.util.parseURL = function(dataURL) {
+  var host = "", domain = "", subdomain = "", pathString = "";
+  var secure = true, scheme = "https", port = 443;
+  if (goog.isString(dataURL)) {
+    var colonInd = dataURL.indexOf("//");
+    if (colonInd >= 0) {
+      scheme = dataURL.substring(0, colonInd - 1);
+      dataURL = dataURL.substring(colonInd + 2);
+    }
+    var slashInd = dataURL.indexOf("/");
+    if (slashInd === -1) {
+      slashInd = dataURL.length;
+    }
+    host = dataURL.substring(0, slashInd);
+    pathString = fb.core.util.decodePath(dataURL.substring(slashInd));
+    var parts = host.split(".");
+    if (parts.length === 3) {
+      domain = parts[1];
+      subdomain = parts[0].toLowerCase();
+    } else {
+      if (parts.length === 2) {
+        domain = parts[0];
+      }
+    }
+    colonInd = host.indexOf(":");
+    if (colonInd >= 0) {
+      secure = scheme === "https" || scheme === "wss";
+      port = goog.string.parseInt(host.substring(colonInd + 1));
+    }
+  }
+  return{host:host, port:port, domain:domain, subdomain:subdomain, secure:secure, scheme:scheme, pathString:pathString};
+};
+fb.core.util.decodePath = function(pathString) {
+  var pathStringDecoded = "";
+  var pieces = pathString.split("/");
+  for (var i = 0;i < pieces.length;i++) {
+    if (pieces[i].length > 0) {
+      var piece = pieces[i];
+      try {
+        piece = goog.string.urlDecode(piece);
+      } catch (e) {
+      }
+      pathStringDecoded += "/" + piece;
+    }
+  }
+  return pathStringDecoded;
+};
+fb.core.util.isInvalidJSONNumber = function(data) {
+  return goog.isNumber(data) && (data != data || data == Number.POSITIVE_INFINITY || data == Number.NEGATIVE_INFINITY);
+};
+fb.core.util.executeWhenDOMReady = function(fn) {
+  if (NODE_CLIENT || document.readyState === "complete") {
+    fn();
+  } else {
+    var called = false;
+    var wrappedFn = function() {
+      if (!document.body) {
+        setTimeout(wrappedFn, Math.floor(10));
+        return;
+      }
+      if (!called) {
+        called = true;
+        fn();
+      }
+    };
+    if (document.addEventListener) {
+      document.addEventListener("DOMContentLoaded", wrappedFn, false);
+      window.addEventListener("load", wrappedFn, false);
+    } else {
+      if (document.attachEvent) {
+        document.attachEvent("onreadystatechange", function() {
+          if (document.readyState === "complete") {
+            wrappedFn();
+          }
+        });
+        window.attachEvent("onload", wrappedFn);
+      }
+    }
+  }
+};
+fb.core.util.MIN_NAME = "[MIN_NAME]";
+fb.core.util.MAX_NAME = "[MAX_NAME]";
+fb.core.util.nameCompare = function(a, b) {
+  if (a === b) {
+    return 0;
+  } else {
+    if (a === fb.core.util.MIN_NAME || b === fb.core.util.MAX_NAME) {
+      return-1;
+    } else {
+      if (b === fb.core.util.MIN_NAME || a === fb.core.util.MAX_NAME) {
+        return 1;
+      } else {
+        var aAsInt = fb.core.util.tryParseInt(a), bAsInt = fb.core.util.tryParseInt(b);
+        if (aAsInt !== null) {
+          if (bAsInt !== null) {
+            return aAsInt - bAsInt == 0 ? a.length - b.length : aAsInt - bAsInt;
+          } else {
+            return-1;
+          }
+        } else {
+          if (bAsInt !== null) {
+            return 1;
+          } else {
+            return a < b ? -1 : 1;
+          }
+        }
+      }
+    }
+  }
+};
+fb.core.util.stringCompare = function(a, b) {
+  if (a === b) {
+    return 0;
+  } else {
+    if (a < b) {
+      return-1;
+    } else {
+      return 1;
+    }
+  }
+};
+fb.core.util.requireKey = function(key, obj) {
+  if (obj && key in obj) {
+    return obj[key];
+  } else {
+    throw new Error("Missing required key (" + key + ") in object: " + fb.util.json.stringify(obj));
+  }
+};
+fb.core.util.ObjectToUniqueKey = function(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return fb.util.json.stringify(obj);
+  }
+  var keys = [];
+  for (var k in obj) {
+    keys.push(k);
+  }
+  keys.sort();
+  var key = "{";
+  for (var i = 0;i < keys.length;i++) {
+    if (i !== 0) {
+      key += ",";
+    }
+    key += fb.util.json.stringify(keys[i]);
+    key += ":";
+    key += fb.core.util.ObjectToUniqueKey(obj[keys[i]]);
+  }
+  key += "}";
+  return key;
+};
+fb.core.util.splitStringBySize = function(str, segsize) {
+  if (str.length <= segsize) {
+    return[str];
+  }
+  var dataSegs = [];
+  for (var c = 0;c < str.length;c += segsize) {
+    if (c + segsize > str) {
+      dataSegs.push(str.substring(c, str.length));
+    } else {
+      dataSegs.push(str.substring(c, c + segsize));
+    }
+  }
+  return dataSegs;
+};
+fb.core.util.each = function(obj, fn) {
+  if (goog.isArray(obj)) {
+    for (var i = 0;i < obj.length;++i) {
+      fn(i, obj[i]);
+    }
+  } else {
+    goog.object.forEach(obj, fn);
+  }
+};
+fb.core.util.bindCallback = function(callback, opt_context) {
+  return opt_context ? goog.bind(callback, opt_context) : callback;
+};
+fb.core.util.doubleToIEEE754String = function(v) {
+  fb.core.util.assert(!fb.core.util.isInvalidJSONNumber(v), "Invalid JSON number");
+  var ebits = 11, fbits = 52;
+  var bias = (1 << ebits - 1) - 1, s, e, f, ln, i, bits, str, bytes;
+  if (v === 0) {
+    e = 0;
+    f = 0;
+    s = 1 / v === -Infinity ? 1 : 0;
+  } else {
+    s = v < 0;
+    v = Math.abs(v);
+    if (v >= Math.pow(2, 1 - bias)) {
+      ln = Math.min(Math.floor(Math.log(v) / Math.LN2), bias);
+      e = ln + bias;
+      f = Math.round(v * Math.pow(2, fbits - ln) - Math.pow(2, fbits));
+    } else {
+      e = 0;
+      f = Math.round(v / Math.pow(2, 1 - bias - fbits));
+    }
+  }
+  bits = [];
+  for (i = fbits;i;i -= 1) {
+    bits.push(f % 2 ? 1 : 0);
+    f = Math.floor(f / 2);
+  }
+  for (i = ebits;i;i -= 1) {
+    bits.push(e % 2 ? 1 : 0);
+    e = Math.floor(e / 2);
+  }
+  bits.push(s ? 1 : 0);
+  bits.reverse();
+  str = bits.join("");
+  var hexByteString = "";
+  for (i = 0;i < 64;i += 8) {
+    var hexByte = parseInt(str.substr(i, 8), 2).toString(16);
+    if (hexByte.length === 1) {
+      hexByte = "0" + hexByte;
+    }
+    hexByteString = hexByteString + hexByte;
+  }
+  return hexByteString.toLowerCase();
+};
+fb.core.util.isChromeExtensionContentScript = function() {
+  return!!(typeof window === "object" && window["chrome"] && window["chrome"]["extension"] && !/^chrome/.test(window.location.href));
+};
+fb.core.util.isWindowsStoreApp = function() {
+  return typeof Windows === "object" && typeof Windows.UI === "object";
+};
+fb.core.util.errorForServerCode = function(code) {
+  var reason = "Unknown Error";
+  if (code === "too_big") {
+    reason = "The data requested exceeds the maximum size " + "that can be accessed with a single request.";
+  } else {
+    if (code == "permission_denied") {
+      reason = "Client doesn't have permission to access the desired data.";
+    } else {
+      if (code == "unavailable") {
+        reason = "The service is unavailable";
+      }
+    }
+  }
+  var error = new Error(code + ": " + reason);
+  error.code = code.toUpperCase();
+  return error;
+};
+fb.core.util.INTEGER_REGEXP_ = new RegExp("^-?\\d{1,10}$");
+fb.core.util.tryParseInt = function(str) {
+  if (fb.core.util.INTEGER_REGEXP_.test(str)) {
+    var intVal = Number(str);
+    if (intVal >= -2147483648 && intVal <= 2147483647) {
+      return intVal;
+    }
+  }
+  return null;
+};
+fb.core.util.exceptionGuard = function(fn) {
+  try {
+    fn();
+  } catch (e) {
+    setTimeout(function() {
+      var stack = e.stack || "";
+      fb.core.util.warn("Exception was thrown by user callback.", stack);
+      throw e;
+    }, Math.floor(0));
+  }
+};
+fb.core.util.callUserCallback = function(opt_callback, var_args) {
+  if (goog.isFunction(opt_callback)) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    var newArgs = args.slice();
+    fb.core.util.exceptionGuard(function() {
+      opt_callback.apply(null, newArgs);
+    });
+  }
+};
+fb.core.util.beingCrawled = function() {
+  var userAgent = typeof window === "object" && window["navigator"] && window["navigator"]["userAgent"] || "";
+  return userAgent.search(/googlebot|google webmaster tools|bingbot|yahoo! slurp|baiduspider|yandexbot|duckduckbot/i) >= 0;
+};
+goog.provide("fb.util.utf8");
+goog.require("fb.core.util");
+fb.util.utf8.stringToByteArray = function(str) {
+  var out = [], p = 0;
+  for (var i = 0;i < str.length;i++) {
+    var c = str.charCodeAt(i);
+    if (c >= 55296 && c <= 56319) {
+      var high = c - 55296;
+      i++;
+      fb.core.util.assert(i < str.length, "Surrogate pair missing trail surrogate.");
+      var low = str.charCodeAt(i) - 56320;
+      c = 65536 + (high << 10) + low;
+    }
+    if (c < 128) {
+      out[p++] = c;
+    } else {
+      if (c < 2048) {
+        out[p++] = c >> 6 | 192;
+        out[p++] = c & 63 | 128;
+      } else {
+        if (c < 65536) {
+          out[p++] = c >> 12 | 224;
+          out[p++] = c >> 6 & 63 | 128;
+          out[p++] = c & 63 | 128;
+        } else {
+          out[p++] = c >> 18 | 240;
+          out[p++] = c >> 12 & 63 | 128;
+          out[p++] = c >> 6 & 63 | 128;
+          out[p++] = c & 63 | 128;
+        }
+      }
+    }
+  }
+  return out;
+};
+fb.util.utf8.stringLength = function(str) {
+  var p = 0;
+  for (var i = 0;i < str.length;i++) {
+    var c = str.charCodeAt(i);
+    if (c < 128) {
+      p++;
+    } else {
+      if (c < 2048) {
+        p += 2;
+      } else {
+        if (c >= 55296 && c <= 56319) {
+          p += 4;
+          i++;
+        } else {
+          p += 3;
+        }
+      }
+    }
+  }
+  return p;
+};
+goog.provide("fb.util.jwt");
+goog.require("fb.core.util");
+goog.require("fb.util.json");
+goog.require("fb.util.obj");
+goog.require("goog.crypt.base64");
+goog.require("goog.json");
+fb.util.jwt.decode = function(token) {
+  var header = {}, claims = {}, data = {}, signature = "";
+  try {
+    var parts = token.split(".");
+    header = fb.util.json.eval(fb.core.util.base64Decode(parts[0]) || "");
+    claims = fb.util.json.eval(fb.core.util.base64Decode(parts[1]) || "");
+    signature = parts[2];
+    data = claims["d"] || {};
+    delete claims["d"];
+  } catch (e) {
+  }
+  return{header:header, claims:claims, data:data, signature:signature};
+};
+fb.util.jwt.isValidTimestamp = function(token) {
+  var claims = fb.util.jwt.decode(token).claims, now = Math.floor((new Date).getTime() / 1E3), validSince, validUntil;
+  if (typeof claims === "object") {
+    if (claims.hasOwnProperty("nbf")) {
+      validSince = fb.util.obj.get(claims, "nbf");
+    } else {
+      if (claims.hasOwnProperty("iat")) {
+        validSince = fb.util.obj.get(claims, "iat");
+      }
+    }
+    if (claims.hasOwnProperty("exp")) {
+      validUntil = fb.util.obj.get(claims, "exp");
+    } else {
+      validUntil = validSince + 86400;
+    }
+  }
+  return now && validSince && validUntil && now >= validSince && now <= validUntil;
+};
+fb.util.jwt.issuedAtTime = function(token) {
+  var claims = fb.util.jwt.decode(token).claims;
+  if (typeof claims === "object" && claims.hasOwnProperty("iat")) {
+    return fb.util.obj.get(claims, "iat");
+  }
+  return null;
+};
+fb.util.jwt.isValidFormat = function(token) {
+  var decoded = fb.util.jwt.decode(token), claims = decoded.claims;
+  return!!decoded.signature && !!claims && typeof claims === "object" && claims.hasOwnProperty("iat");
+};
+fb.util.jwt.isAdmin = function(token) {
+  var claims = fb.util.jwt.decode(token).claims;
+  return typeof claims === "object" && fb.util.obj.get(claims, "admin") === true;
+};
+goog.provide("fb.core.view.EventGenerator");
+goog.require("fb.core.snap.NamedNode");
+goog.require("fb.core.util");
+fb.core.view.EventGenerator = function(query) {
+  this.query_ = query;
+  this.index_ = query.getQueryParams().getIndex();
+};
+fb.core.view.EventGenerator.prototype.generateEventsForChanges = function(changes, eventCache, eventRegistrations) {
+  var events = [], self = this;
+  var moves = [];
+  goog.array.forEach(changes, function(change) {
+    if (change.type === fb.core.view.Change.CHILD_CHANGED && self.index_.indexedValueChanged((change.oldSnap), change.snapshotNode)) {
+      moves.push(fb.core.view.Change.childMovedChange((change.childName), change.snapshotNode));
+    }
+  });
+  this.generateEventsForType_(events, fb.core.view.Change.CHILD_REMOVED, changes, eventRegistrations, eventCache);
+  this.generateEventsForType_(events, fb.core.view.Change.CHILD_ADDED, changes, eventRegistrations, eventCache);
+  this.generateEventsForType_(events, fb.core.view.Change.CHILD_MOVED, moves, eventRegistrations, eventCache);
+  this.generateEventsForType_(events, fb.core.view.Change.CHILD_CHANGED, changes, eventRegistrations, eventCache);
+  this.generateEventsForType_(events, fb.core.view.Change.VALUE, changes, eventRegistrations, eventCache);
+  return events;
+};
+fb.core.view.EventGenerator.prototype.generateEventsForType_ = function(events, eventType, changes, registrations, eventCache) {
+  var filteredChanges = goog.array.filter(changes, function(change) {
+    return change.type === eventType;
+  });
+  var self = this;
+  goog.array.sort(filteredChanges, goog.bind(this.compareChanges_, this));
+  goog.array.forEach(filteredChanges, function(change) {
+    var materializedChange = self.materializeSingleChange_(change, eventCache);
+    goog.array.forEach(registrations, function(registration) {
+      if (registration.respondsTo(change.type)) {
+        events.push(registration.createEvent(materializedChange, self.query_));
+      }
+    });
+  });
+};
+fb.core.view.EventGenerator.prototype.materializeSingleChange_ = function(change, eventCache) {
+  if (change.type === "value" || change.type === "child_removed") {
+    return change;
+  } else {
+    change.prevName = eventCache.getPredecessorChildName((change.childName), change.snapshotNode, this.index_);
+    return change;
+  }
+};
+fb.core.view.EventGenerator.prototype.compareChanges_ = function(a, b) {
+  if (a.childName == null || b.childName == null) {
+    throw fb.core.util.assertionError("Should only compare child_ events.");
+  }
+  var aWrapped = new fb.core.snap.NamedNode(a.childName, a.snapshotNode);
+  var bWrapped = new fb.core.snap.NamedNode(b.childName, b.snapshotNode);
+  return this.index_.compare(aWrapped, bWrapped);
+};
+goog.provide("fb.core.view.ChildChangeAccumulator");
+goog.require("fb.core.util");
+fb.core.view.ChildChangeAccumulator = function() {
+  this.changeMap_ = {};
+};
+fb.core.view.ChildChangeAccumulator.prototype.trackChildChange = function(change) {
+  var Change = fb.core.view.Change;
+  var type = change.type;
+  var childKey = (change.childName);
+  fb.core.util.assert(type == fb.core.view.Change.CHILD_ADDED || type == fb.core.view.Change.CHILD_CHANGED || type == fb.core.view.Change.CHILD_REMOVED, "Only child changes supported for tracking");
+  fb.core.util.assert(childKey !== ".priority", "Only non-priority child changes can be tracked.");
+  var oldChange = fb.util.obj.get(this.changeMap_, childKey);
+  if (oldChange) {
+    var oldType = oldChange.type;
+    if (type == Change.CHILD_ADDED && oldType == Change.CHILD_REMOVED) {
+      this.changeMap_[childKey] = Change.childChangedChange(childKey, change.snapshotNode, oldChange.snapshotNode);
+    } else {
+      if (type == Change.CHILD_REMOVED && oldType == Change.CHILD_ADDED) {
+        delete this.changeMap_[childKey];
+      } else {
+        if (type == Change.CHILD_REMOVED && oldType == Change.CHILD_CHANGED) {
+          this.changeMap_[childKey] = Change.childRemovedChange(childKey, (oldChange.oldSnap));
+        } else {
+          if (type == Change.CHILD_CHANGED && oldType == Change.CHILD_ADDED) {
+            this.changeMap_[childKey] = Change.childAddedChange(childKey, change.snapshotNode);
+          } else {
+            if (type == Change.CHILD_CHANGED && oldType == Change.CHILD_CHANGED) {
+              this.changeMap_[childKey] = Change.childChangedChange(childKey, change.snapshotNode, (oldChange.oldSnap));
+            } else {
+              throw fb.core.util.assertionError("Illegal combination of changes: " + change + " occurred after " + oldChange);
+            }
+          }
+        }
+      }
+    }
+  } else {
+    this.changeMap_[childKey] = change;
+  }
+};
+fb.core.view.ChildChangeAccumulator.prototype.getChanges = function() {
+  return goog.object.getValues(this.changeMap_);
+};
+goog.provide("fb.core.view.EventRegistration");
+goog.require("fb.core.view.Change");
+goog.require("fb.core.view.Event");
+goog.require("fb.core.util");
+fb.core.view.EventRegistration = function() {
+};
+fb.core.view.EventRegistration.prototype.respondsTo;
+fb.core.view.EventRegistration.prototype.createEvent;
+fb.core.view.EventRegistration.prototype.getEventRunner;
+fb.core.view.EventRegistration.prototype.createCancelEvent;
+fb.core.view.EventRegistration.prototype.matches;
+fb.core.view.EventRegistration.prototype.hasAnyCallback;
+fb.core.view.ValueEventRegistration = function(callback, cancelCallback, context) {
+  this.callback_ = callback;
+  this.cancelCallback_ = cancelCallback;
+  this.context_ = context || null;
+};
+fb.core.view.ValueEventRegistration.prototype.respondsTo = function(eventType) {
+  return eventType === "value";
+};
+fb.core.view.ValueEventRegistration.prototype.createEvent = function(change, query) {
+  var index = query.getQueryParams().getIndex();
+  return new fb.core.view.DataEvent("value", this, new fb.api.DataSnapshot(change.snapshotNode, query.ref(), index));
+};
+fb.core.view.ValueEventRegistration.prototype.getEventRunner = function(eventData) {
+  var ctx = this.context_;
+  if (eventData.getEventType() === "cancel") {
+    fb.core.util.assert(this.cancelCallback_, "Raising a cancel event on a listener with no cancel callback");
+    var cancelCB = this.cancelCallback_;
+    return function() {
+      cancelCB.call(ctx, eventData.error);
+    };
+  } else {
+    var cb = this.callback_;
+    return function() {
+      cb.call(ctx, eventData.snapshot);
+    };
+  }
+};
+fb.core.view.ValueEventRegistration.prototype.createCancelEvent = function(error, path) {
+  if (this.cancelCallback_) {
+    return new fb.core.view.CancelEvent(this, error, path);
+  } else {
+    return null;
+  }
+};
+fb.core.view.ValueEventRegistration.prototype.matches = function(other) {
+  if (!(other instanceof fb.core.view.ValueEventRegistration)) {
+    return false;
+  } else {
+    if (!other.callback_ || !this.callback_) {
+      return true;
+    } else {
+      return other.callback_ === this.callback_ && other.context_ === this.context_;
+    }
+  }
+};
+fb.core.view.ValueEventRegistration.prototype.hasAnyCallback = function() {
+  return this.callback_ !== null;
+};
+fb.core.view.ChildEventRegistration = function(callbacks, cancelCallback, context) {
+  this.callbacks_ = callbacks;
+  this.cancelCallback_ = cancelCallback;
+  this.context_ = context;
+};
+fb.core.view.ChildEventRegistration.prototype.respondsTo = function(eventType) {
+  var eventToCheck = eventType === "children_added" ? "child_added" : eventType;
+  eventToCheck = eventToCheck === "children_removed" ? "child_removed" : eventToCheck;
+  return goog.object.containsKey(this.callbacks_, eventToCheck);
+};
+fb.core.view.ChildEventRegistration.prototype.createCancelEvent = function(error, path) {
+  if (this.cancelCallback_) {
+    return new fb.core.view.CancelEvent(this, error, path);
+  } else {
+    return null;
+  }
+};
+fb.core.view.ChildEventRegistration.prototype.createEvent = function(change, query) {
+  fb.core.util.assert(change.childName != null, "Child events should have a childName.");
+  var ref = query.ref().child((change.childName));
+  var index = query.getQueryParams().getIndex();
+  return new fb.core.view.DataEvent(change.type, this, new fb.api.DataSnapshot(change.snapshotNode, ref, index), change.prevName);
+};
+fb.core.view.ChildEventRegistration.prototype.getEventRunner = function(eventData) {
+  var ctx = this.context_;
+  if (eventData.getEventType() === "cancel") {
+    fb.core.util.assert(this.cancelCallback_, "Raising a cancel event on a listener with no cancel callback");
+    var cancelCB = this.cancelCallback_;
+    return function() {
+      cancelCB.call(ctx, eventData.error);
+    };
+  } else {
+    var cb = this.callbacks_[eventData.eventType];
+    return function() {
+      cb.call(ctx, eventData.snapshot, eventData.prevName);
+    };
+  }
+};
+fb.core.view.ChildEventRegistration.prototype.matches = function(other) {
+  if (other instanceof fb.core.view.ChildEventRegistration) {
+    if (!this.callbacks_ || !other.callbacks_) {
+      return true;
+    } else {
+      if (this.context_ === other.context_) {
+        var otherCount = goog.object.getCount(other.callbacks_);
+        var thisCount = goog.object.getCount(this.callbacks_);
+        if (otherCount === thisCount) {
+          if (otherCount === 1) {
+            var otherKey = (goog.object.getAnyKey(other.callbacks_));
+            var thisKey = (goog.object.getAnyKey(this.callbacks_));
+            return thisKey === otherKey && (!other.callbacks_[otherKey] || !this.callbacks_[thisKey] || other.callbacks_[otherKey] === this.callbacks_[thisKey]);
+          } else {
+            return goog.object.every(this.callbacks_, function(cb, eventType) {
+              return other.callbacks_[eventType] === cb;
+            });
+          }
+        }
+      }
+    }
+  }
+  return false;
+};
+fb.core.view.ChildEventRegistration.prototype.hasAnyCallback = function() {
+  return this.callbacks_ !== null;
+};
+goog.provide("fb.core.view.filter.IndexedFilter");
+goog.require("fb.core.util");
+fb.core.view.filter.IndexedFilter = function(index) {
+  this.index_ = index;
+};
+fb.core.view.filter.IndexedFilter.prototype.updateChild = function(snap, key, newChild, source, optChangeAccumulator) {
+  var Change = fb.core.view.Change;
+  fb.core.util.assert(snap.isIndexed(this.index_), "A node must be indexed if only a child is updated");
+  var oldChild = snap.getImmediateChild(key);
+  if (oldChild.equals(newChild)) {
+    return snap;
+  }
+  if (optChangeAccumulator != null) {
+    if (newChild.isEmpty()) {
+      if (snap.hasChild(key)) {
+        optChangeAccumulator.trackChildChange(Change.childRemovedChange(key, oldChild));
+      } else {
+        fb.core.util.assert(snap.isLeafNode(), "A child remove without an old child only makes sense on a leaf node");
+      }
+    } else {
+      if (oldChild.isEmpty()) {
+        optChangeAccumulator.trackChildChange(Change.childAddedChange(key, newChild));
+      } else {
+        optChangeAccumulator.trackChildChange(Change.childChangedChange(key, newChild, oldChild));
+      }
+    }
+  }
+  if (snap.isLeafNode() && newChild.isEmpty()) {
+    return snap;
+  } else {
+    return snap.updateImmediateChild(key, newChild).withIndex(this.index_);
+  }
+};
+fb.core.view.filter.IndexedFilter.prototype.updateFullNode = function(oldSnap, newSnap, optChangeAccumulator) {
+  var Change = fb.core.view.Change;
+  if (optChangeAccumulator != null) {
+    if (!oldSnap.isLeafNode()) {
+      oldSnap.forEachChild(fb.core.snap.PriorityIndex, function(key, childNode) {
+        if (!newSnap.hasChild(key)) {
+          optChangeAccumulator.trackChildChange(Change.childRemovedChange(key, childNode));
+        }
+      });
+    }
+    if (!newSnap.isLeafNode()) {
+      newSnap.forEachChild(fb.core.snap.PriorityIndex, function(key, childNode) {
+        if (oldSnap.hasChild(key)) {
+          var oldChild = oldSnap.getImmediateChild(key);
+          if (!oldChild.equals(childNode)) {
+            optChangeAccumulator.trackChildChange(Change.childChangedChange(key, childNode, oldChild));
+          }
+        } else {
+          optChangeAccumulator.trackChildChange(Change.childAddedChange(key, childNode));
+        }
+      });
+    }
+  }
+  return newSnap.withIndex(this.index_);
+};
+fb.core.view.filter.IndexedFilter.prototype.updatePriority = function(oldSnap, newPriority) {
+  if (oldSnap.isEmpty()) {
+    return fb.core.snap.EMPTY_NODE;
+  } else {
+    return oldSnap.updatePriority(newPriority);
+  }
+};
+fb.core.view.filter.IndexedFilter.prototype.filtersNodes = function() {
+  return false;
+};
+fb.core.view.filter.IndexedFilter.prototype.getIndexedFilter = function() {
+  return this;
+};
+fb.core.view.filter.IndexedFilter.prototype.getIndex = function() {
+  return this.index_;
+};
+goog.provide("fb.core.view.filter.RangedFilter");
+goog.require("fb.core.view.filter.IndexedFilter");
+fb.core.view.filter.RangedFilter = function(params) {
+  this.indexedFilter_ = new fb.core.view.filter.IndexedFilter(params.getIndex());
+  this.index_ = params.getIndex();
+  this.startPost_ = this.getStartPost_(params);
+  this.endPost_ = this.getEndPost_(params);
+};
+fb.core.view.filter.RangedFilter.prototype.getStartPost = function() {
+  return this.startPost_;
+};
+fb.core.view.filter.RangedFilter.prototype.getEndPost = function() {
+  return this.endPost_;
+};
+fb.core.view.filter.RangedFilter.prototype.matches = function(node) {
+  return this.index_.compare(this.getStartPost(), node) <= 0 && this.index_.compare(node, this.getEndPost()) <= 0;
+};
+fb.core.view.filter.RangedFilter.prototype.updateChild = function(snap, key, newChild, source, optChangeAccumulator) {
+  if (!this.matches(new fb.core.snap.NamedNode(key, newChild))) {
+    newChild = fb.core.snap.EMPTY_NODE;
+  }
+  return this.indexedFilter_.updateChild(snap, key, newChild, source, optChangeAccumulator);
+};
+fb.core.view.filter.RangedFilter.prototype.updateFullNode = function(oldSnap, newSnap, optChangeAccumulator) {
+  if (newSnap.isLeafNode()) {
+    newSnap = fb.core.snap.EMPTY_NODE;
+  }
+  var filtered = newSnap.withIndex(this.index_);
+  filtered = filtered.updatePriority(fb.core.snap.EMPTY_NODE);
+  var self = this;
+  newSnap.forEachChild(fb.core.snap.PriorityIndex, function(key, childNode) {
+    if (!self.matches(new fb.core.snap.NamedNode(key, childNode))) {
+      filtered = filtered.updateImmediateChild(key, fb.core.snap.EMPTY_NODE);
+    }
+  });
+  return this.indexedFilter_.updateFullNode(oldSnap, filtered, optChangeAccumulator);
+};
+fb.core.view.filter.RangedFilter.prototype.updatePriority = function(oldSnap, newPriority) {
+  return oldSnap;
+};
+fb.core.view.filter.RangedFilter.prototype.filtersNodes = function() {
+  return true;
+};
+fb.core.view.filter.RangedFilter.prototype.getIndexedFilter = function() {
+  return this.indexedFilter_;
+};
+fb.core.view.filter.RangedFilter.prototype.getIndex = function() {
+  return this.index_;
+};
+fb.core.view.filter.RangedFilter.prototype.getStartPost_ = function(params) {
+  if (params.hasStart()) {
+    var startName = params.getIndexStartName();
+    return params.getIndex().makePost(params.getIndexStartValue(), startName);
+  } else {
+    return params.getIndex().minPost();
+  }
+};
+fb.core.view.filter.RangedFilter.prototype.getEndPost_ = function(params) {
+  if (params.hasEnd()) {
+    var endName = params.getIndexEndName();
+    return params.getIndex().makePost(params.getIndexEndValue(), endName);
+  } else {
+    return params.getIndex().maxPost();
+  }
+};
+goog.provide("fb.core.view.filter.NodeFilter");
+goog.require("fb.core.view.ChildChangeAccumulator");
+goog.require("fb.core.view.CompleteChildSource");
+fb.core.view.filter.NodeFilter = function() {
+};
+fb.core.view.filter.NodeFilter.prototype.updateChild = function(snap, key, newChild, source, optChangeAccumulator) {
+};
+fb.core.view.filter.NodeFilter.prototype.updateFullNode = function(oldSnap, newSnap, optChangeAccumulator) {
+};
+fb.core.view.filter.NodeFilter.prototype.updatePriority = function(oldSnap, newPriority) {
+};
+fb.core.view.filter.NodeFilter.prototype.filtersNodes = function() {
+};
+fb.core.view.filter.NodeFilter.prototype.getIndexedFilter = function() {
+};
+fb.core.view.filter.NodeFilter.prototype.getIndex = function() {
+};
+goog.provide("fb.core.view.filter.LimitedFilter");
+goog.require("fb.core.snap.NamedNode");
+goog.require("fb.core.view.filter.RangedFilter");
+goog.require("fb.core.util");
+fb.core.view.filter.LimitedFilter = function(params) {
+  this.rangedFilter_ = new fb.core.view.filter.RangedFilter(params);
+  this.index_ = params.getIndex();
+  this.limit_ = params.getLimit();
+  this.reverse_ = !params.isViewFromLeft();
+};
+fb.core.view.filter.LimitedFilter.prototype.updateChild = function(snap, key, newChild, source, optChangeAccumulator) {
+  if (!this.rangedFilter_.matches(new fb.core.snap.NamedNode(key, newChild))) {
+    newChild = fb.core.snap.EMPTY_NODE;
+  }
+  if (snap.getImmediateChild(key).equals(newChild)) {
+    return snap;
+  } else {
+    if (snap.numChildren() < this.limit_) {
+      return this.rangedFilter_.getIndexedFilter().updateChild(snap, key, newChild, source, optChangeAccumulator);
+    } else {
+      return this.fullLimitUpdateChild_(snap, key, newChild, source, optChangeAccumulator);
+    }
+  }
+};
+fb.core.view.filter.LimitedFilter.prototype.updateFullNode = function(oldSnap, newSnap, optChangeAccumulator) {
+  var filtered;
+  if (newSnap.isLeafNode() || newSnap.isEmpty()) {
+    filtered = fb.core.snap.EMPTY_NODE.withIndex(this.index_);
+  } else {
+    if (this.limit_ * 2 < newSnap.numChildren() && newSnap.isIndexed(this.index_)) {
+      filtered = fb.core.snap.EMPTY_NODE.withIndex(this.index_);
+      var iterator;
+      newSnap = (newSnap);
+      if (this.reverse_) {
+        iterator = newSnap.getReverseIteratorFrom(this.rangedFilter_.getEndPost(), this.index_);
+      } else {
+        iterator = newSnap.getIteratorFrom(this.rangedFilter_.getStartPost(), this.index_);
+      }
+      var count = 0;
+      while (iterator.hasNext() && count < this.limit_) {
+        var next = iterator.getNext();
+        var inRange;
+        if (this.reverse_) {
+          inRange = this.index_.compare(this.rangedFilter_.getStartPost(), next) <= 0;
+        } else {
+          inRange = this.index_.compare(next, this.rangedFilter_.getEndPost()) <= 0;
+        }
+        if (inRange) {
+          filtered = filtered.updateImmediateChild(next.name, next.node);
+          count++;
+        } else {
+          break;
+        }
+      }
+    } else {
+      filtered = newSnap.withIndex(this.index_);
+      filtered = (filtered.updatePriority(fb.core.snap.EMPTY_NODE));
+      var startPost;
+      var endPost;
+      var cmp;
+      if (this.reverse_) {
+        iterator = filtered.getReverseIterator(this.index_);
+        startPost = this.rangedFilter_.getEndPost();
+        endPost = this.rangedFilter_.getStartPost();
+        var indexCompare = this.index_.getCompare();
+        cmp = function(a, b) {
+          return indexCompare(b, a);
+        };
+      } else {
+        iterator = filtered.getIterator(this.index_);
+        startPost = this.rangedFilter_.getStartPost();
+        endPost = this.rangedFilter_.getEndPost();
+        cmp = this.index_.getCompare();
+      }
+      count = 0;
+      var foundStartPost = false;
+      while (iterator.hasNext()) {
+        next = iterator.getNext();
+        if (!foundStartPost && cmp(startPost, next) <= 0) {
+          foundStartPost = true;
+        }
+        inRange = foundStartPost && count < this.limit_ && cmp(next, endPost) <= 0;
+        if (inRange) {
+          count++;
+        } else {
+          filtered = filtered.updateImmediateChild(next.name, fb.core.snap.EMPTY_NODE);
+        }
+      }
+    }
+  }
+  return this.rangedFilter_.getIndexedFilter().updateFullNode(oldSnap, filtered, optChangeAccumulator);
+};
+fb.core.view.filter.LimitedFilter.prototype.updatePriority = function(oldSnap, newPriority) {
+  return oldSnap;
+};
+fb.core.view.filter.LimitedFilter.prototype.filtersNodes = function() {
+  return true;
+};
+fb.core.view.filter.LimitedFilter.prototype.getIndexedFilter = function() {
+  return this.rangedFilter_.getIndexedFilter();
+};
+fb.core.view.filter.LimitedFilter.prototype.getIndex = function() {
+  return this.index_;
+};
+fb.core.view.filter.LimitedFilter.prototype.fullLimitUpdateChild_ = function(snap, childKey, childSnap, source, optChangeAccumulator) {
+  var Change = fb.core.view.Change;
+  var cmp;
+  if (this.reverse_) {
+    var indexCmp = this.index_.getCompare();
+    cmp = function(a, b) {
+      return indexCmp(b, a);
+    };
+  } else {
+    cmp = this.index_.getCompare();
+  }
+  var oldEventCache = (snap);
+  fb.core.util.assert(oldEventCache.numChildren() == this.limit_, "");
+  var newChildNamedNode = new fb.core.snap.NamedNode(childKey, childSnap);
+  var windowBoundary = (this.reverse_ ? oldEventCache.getFirstChild(this.index_) : oldEventCache.getLastChild(this.index_));
+  var inRange = this.rangedFilter_.matches(newChildNamedNode);
+  if (oldEventCache.hasChild(childKey)) {
+    var oldChildSnap = oldEventCache.getImmediateChild(childKey);
+    var nextChild = source.getChildAfterChild(this.index_, windowBoundary, this.reverse_);
+    if (nextChild != null && nextChild.name == childKey) {
+      nextChild = source.getChildAfterChild(this.index_, nextChild, this.reverse_);
+    }
+    var compareNext = nextChild == null ? 1 : cmp(nextChild, newChildNamedNode);
+    var remainsInWindow = inRange && !childSnap.isEmpty() && compareNext >= 0;
+    if (remainsInWindow) {
+      if (optChangeAccumulator != null) {
+        optChangeAccumulator.trackChildChange(Change.childChangedChange(childKey, childSnap, oldChildSnap));
+      }
+      return oldEventCache.updateImmediateChild(childKey, childSnap);
+    } else {
+      if (optChangeAccumulator != null) {
+        optChangeAccumulator.trackChildChange(Change.childRemovedChange(childKey, oldChildSnap));
+      }
+      var newEventCache = oldEventCache.updateImmediateChild(childKey, fb.core.snap.EMPTY_NODE);
+      var nextChildInRange = nextChild != null && this.rangedFilter_.matches(nextChild);
+      if (nextChildInRange) {
+        if (optChangeAccumulator != null) {
+          optChangeAccumulator.trackChildChange(Change.childAddedChange(nextChild.name, nextChild.node));
+        }
+        return newEventCache.updateImmediateChild(nextChild.name, nextChild.node);
+      } else {
+        return newEventCache;
+      }
+    }
+  } else {
+    if (childSnap.isEmpty()) {
+      return snap;
+    } else {
+      if (inRange) {
+        if (cmp(windowBoundary, newChildNamedNode) >= 0) {
+          if (optChangeAccumulator != null) {
+            optChangeAccumulator.trackChildChange(Change.childRemovedChange(windowBoundary.name, windowBoundary.node));
+            optChangeAccumulator.trackChildChange(Change.childAddedChange(childKey, childSnap));
+          }
+          return oldEventCache.updateImmediateChild(childKey, childSnap).updateImmediateChild(windowBoundary.name, fb.core.snap.EMPTY_NODE);
+        } else {
+          return snap;
+        }
+      } else {
+        return snap;
+      }
+    }
+  }
+};
+goog.provide("fb.core.view.ViewProcessor");
+goog.require("fb.core.view.CompleteChildSource");
+goog.require("fb.core.util");
+fb.core.view.ProcessorResult = function(viewCache, changes) {
+  this.viewCache = viewCache;
+  this.changes = changes;
+};
+fb.core.view.ViewProcessor = function(filter) {
+  this.filter_ = filter;
+};
+fb.core.view.ViewProcessor.prototype.assertIndexed = function(viewCache) {
+  fb.core.util.assert(viewCache.getEventCache().getNode().isIndexed(this.filter_.getIndex()), "Event snap not indexed");
+  fb.core.util.assert(viewCache.getServerCache().getNode().isIndexed(this.filter_.getIndex()), "Server snap not indexed");
+};
+fb.core.view.ViewProcessor.prototype.applyOperation = function(oldViewCache, operation, writesCache, optCompleteCache) {
+  var accumulator = new fb.core.view.ChildChangeAccumulator;
+  var newViewCache, constrainNode;
+  if (operation.type === fb.core.OperationType.OVERWRITE) {
+    var overwrite = (operation);
+    if (overwrite.source.fromUser) {
+      newViewCache = this.applyUserOverwrite_(oldViewCache, overwrite.path, overwrite.snap, writesCache, optCompleteCache, accumulator);
+    } else {
+      fb.core.util.assert(overwrite.source.fromServer, "Unknown source.");
+      constrainNode = overwrite.source.tagged;
+      newViewCache = this.applyServerOverwrite_(oldViewCache, overwrite.path, overwrite.snap, writesCache, optCompleteCache, constrainNode, accumulator);
+    }
+  } else {
+    if (operation.type === fb.core.OperationType.MERGE) {
+      var merge = (operation);
+      if (merge.source.fromUser) {
+        newViewCache = this.applyUserMerge_(oldViewCache, merge.path, merge.children, writesCache, optCompleteCache, accumulator);
+      } else {
+        fb.core.util.assert(merge.source.fromServer, "Unknown source.");
+        constrainNode = merge.source.tagged;
+        newViewCache = this.applyServerMerge_(oldViewCache, merge.path, merge.children, writesCache, optCompleteCache, constrainNode, accumulator);
+      }
+    } else {
+      if (operation.type === fb.core.OperationType.ACK_USER_WRITE) {
+        var ackUserWrite = (operation);
+        if (!ackUserWrite.revert) {
+          newViewCache = this.ackUserWrite_(oldViewCache, ackUserWrite.path, writesCache, optCompleteCache, accumulator);
+        } else {
+          newViewCache = this.revertUserWrite_(oldViewCache, ackUserWrite.path, writesCache, optCompleteCache, accumulator);
+        }
+      } else {
+        if (operation.type === fb.core.OperationType.LISTEN_COMPLETE) {
+          newViewCache = this.listenComplete_(oldViewCache, operation.path, writesCache, optCompleteCache, accumulator);
+        } else {
+          throw fb.core.util.assertionError("Unknown operation type: " + operation.type);
+        }
+      }
+    }
+  }
+  var changes = accumulator.getChanges();
+  this.maybeAddValueEvent_(oldViewCache, newViewCache, changes);
+  return new fb.core.view.ProcessorResult(newViewCache, changes);
+};
+fb.core.view.ViewProcessor.prototype.maybeAddValueEvent_ = function(oldViewCache, newViewCache, accumulator) {
+  var eventSnap = newViewCache.getEventCache();
+  if (eventSnap.isFullyInitialized()) {
+    var isLeafOrEmpty = eventSnap.getNode().isLeafNode() || eventSnap.getNode().isEmpty();
+    var oldCompleteSnap = oldViewCache.getCompleteEventSnap();
+    if (accumulator.length > 0 || !oldViewCache.getEventCache().isFullyInitialized() || isLeafOrEmpty && !eventSnap.getNode().equals((oldCompleteSnap)) || !eventSnap.getNode().getPriority().equals(oldCompleteSnap.getPriority())) {
+      accumulator.push(fb.core.view.Change.valueChange((newViewCache.getCompleteEventSnap())));
+    }
+  }
+};
+fb.core.view.ViewProcessor.prototype.generateEventCacheAfterServerEvent_ = function(viewCache, changePath, writesCache, source, accumulator) {
+  var oldEventSnap = viewCache.getEventCache();
+  if (writesCache.shadowingWrite(changePath) != null) {
+    return viewCache;
+  } else {
+    var newEventCache, serverNode;
+    if (changePath.isEmpty()) {
+      fb.core.util.assert(viewCache.getServerCache().isFullyInitialized(), "If change path is empty, we must have complete server data");
+      if (viewCache.getServerCache().isFiltered()) {
+        var serverCache = viewCache.getCompleteServerSnap();
+        var completeChildren = serverCache instanceof fb.core.snap.ChildrenNode ? serverCache : fb.core.snap.EMPTY_NODE;
+        var completeEventChildren = writesCache.calcCompleteEventChildren(completeChildren);
+        newEventCache = this.filter_.updateFullNode(viewCache.getEventCache().getNode(), completeEventChildren, accumulator);
+      } else {
+        var completeNode = (writesCache.calcCompleteEventCache(viewCache.getCompleteServerSnap()));
+        newEventCache = this.filter_.updateFullNode(viewCache.getEventCache().getNode(), completeNode, accumulator);
+      }
+    } else {
+      var childKey = changePath.getFront();
+      if (childKey == ".priority") {
+        fb.core.util.assert(changePath.getLength() == 1, "Can't have a priority with additional path components");
+        var oldEventNode = oldEventSnap.getNode();
+        serverNode = viewCache.getServerCache().getNode();
+        var updatedPriority = writesCache.calcEventCacheAfterServerOverwrite(changePath, oldEventNode, serverNode);
+        if (updatedPriority != null) {
+          newEventCache = this.filter_.updatePriority(oldEventNode, updatedPriority);
+        } else {
+          newEventCache = oldEventSnap.getNode();
+        }
+      } else {
+        var childChangePath = changePath.popFront();
+        var newEventChild;
+        if (oldEventSnap.isCompleteForChild(childKey)) {
+          serverNode = viewCache.getServerCache().getNode();
+          var eventChildUpdate = writesCache.calcEventCacheAfterServerOverwrite(changePath, oldEventSnap.getNode(), serverNode);
+          if (eventChildUpdate != null) {
+            newEventChild = oldEventSnap.getNode().getImmediateChild(childKey).updateChild(childChangePath, eventChildUpdate);
+          } else {
+            newEventChild = oldEventSnap.getNode().getImmediateChild(childKey);
+          }
+        } else {
+          newEventChild = writesCache.calcCompleteChild(childKey, viewCache.getServerCache());
+        }
+        if (newEventChild != null) {
+          newEventCache = this.filter_.updateChild(oldEventSnap.getNode(), childKey, newEventChild, source, accumulator);
+        } else {
+          newEventCache = oldEventSnap.getNode();
+        }
+      }
+    }
+    return viewCache.updateEventSnap(newEventCache, oldEventSnap.isFullyInitialized() || changePath.isEmpty(), this.filter_.filtersNodes());
+  }
+};
+fb.core.view.ViewProcessor.prototype.applyServerOverwrite_ = function(oldViewCache, changePath, changedSnap, writesCache, optCompleteCache, constrainServerNode, accumulator) {
+  var oldServerSnap = oldViewCache.getServerCache();
+  var newServerCache;
+  var serverFilter = constrainServerNode ? this.filter_ : this.filter_.getIndexedFilter();
+  if (changePath.isEmpty()) {
+    newServerCache = serverFilter.updateFullNode(oldServerSnap.getNode(), changedSnap, null);
+  } else {
+    if (serverFilter.filtersNodes() && !oldServerSnap.isFiltered()) {
+      var newServerNode = oldServerSnap.getNode().updateChild(changePath, changedSnap);
+      newServerCache = serverFilter.updateFullNode(oldServerSnap.getNode(), newServerNode, null);
+    } else {
+      var childKey = changePath.getFront();
+      if (!oldServerSnap.isCompleteForPath(changePath) && changePath.getLength() > 1) {
+        return oldViewCache;
+      }
+      var childNode = oldServerSnap.getNode().getImmediateChild(childKey);
+      var newChildNode = childNode.updateChild(changePath.popFront(), changedSnap);
+      if (childKey == ".priority") {
+        newServerCache = serverFilter.updatePriority(oldServerSnap.getNode(), newChildNode);
+      } else {
+        newServerCache = serverFilter.updateChild(oldServerSnap.getNode(), childKey, newChildNode, fb.core.view.NO_COMPLETE_CHILD_SOURCE, null);
+      }
+    }
+  }
+  var newViewCache = oldViewCache.updateServerSnap(newServerCache, oldServerSnap.isFullyInitialized() || changePath.isEmpty(), serverFilter.filtersNodes());
+  var source = new fb.core.view.WriteTreeCompleteChildSource(writesCache, newViewCache, optCompleteCache);
+  return this.generateEventCacheAfterServerEvent_(newViewCache, changePath, writesCache, source, accumulator);
+};
+fb.core.view.ViewProcessor.prototype.applyUserOverwrite_ = function(oldViewCache, changePath, changedSnap, writesCache, optCompleteCache, accumulator) {
+  var oldEventSnap = oldViewCache.getEventCache();
+  var newViewCache, newEventCache;
+  var source = new fb.core.view.WriteTreeCompleteChildSource(writesCache, oldViewCache, optCompleteCache);
+  if (changePath.isEmpty()) {
+    newEventCache = this.filter_.updateFullNode(oldViewCache.getEventCache().getNode(), changedSnap, accumulator);
+    newViewCache = oldViewCache.updateEventSnap(newEventCache, true, this.filter_.filtersNodes());
+  } else {
+    var childKey = changePath.getFront();
+    if (childKey === ".priority") {
+      newEventCache = this.filter_.updatePriority(oldViewCache.getEventCache().getNode(), changedSnap);
+      newViewCache = oldViewCache.updateEventSnap(newEventCache, oldEventSnap.isFullyInitialized(), oldEventSnap.isFiltered());
+    } else {
+      var childChangePath = changePath.popFront();
+      var oldChild = oldEventSnap.getNode().getImmediateChild(childKey);
+      var newChild;
+      if (childChangePath.isEmpty()) {
+        newChild = changedSnap;
+      } else {
+        var childNode = source.getCompleteChild(childKey);
+        if (childNode != null) {
+          if (childChangePath.getBack() === ".priority" && childNode.getChild((childChangePath.parent())).isEmpty()) {
+            newChild = childNode;
+          } else {
+            newChild = childNode.updateChild(childChangePath, changedSnap);
+          }
+        } else {
+          newChild = fb.core.snap.EMPTY_NODE;
+        }
+      }
+      if (!oldChild.equals(newChild)) {
+        var newEventSnap = this.filter_.updateChild(oldEventSnap.getNode(), childKey, newChild, source, accumulator);
+        newViewCache = oldViewCache.updateEventSnap(newEventSnap, oldEventSnap.isFullyInitialized(), this.filter_.filtersNodes());
+      } else {
+        newViewCache = oldViewCache;
+      }
+    }
+  }
+  return newViewCache;
+};
+fb.core.view.ViewProcessor.cacheHasChild_ = function(viewCache, childKey) {
+  return viewCache.getEventCache().isCompleteForChild(childKey);
+};
+fb.core.view.ViewProcessor.prototype.applyUserMerge_ = function(viewCache, path, changedChildren, writesCache, serverCache, accumulator) {
+  var self = this;
+  var curViewCache = viewCache;
+  changedChildren.foreach(function(relativePath, childNode) {
+    var writePath = path.child(relativePath);
+    if (fb.core.view.ViewProcessor.cacheHasChild_(viewCache, writePath.getFront())) {
+      curViewCache = self.applyUserOverwrite_(curViewCache, writePath, childNode, writesCache, serverCache, accumulator);
+    }
+  });
+  changedChildren.foreach(function(relativePath, childNode) {
+    var writePath = path.child(relativePath);
+    if (!fb.core.view.ViewProcessor.cacheHasChild_(viewCache, writePath.getFront())) {
+      curViewCache = self.applyUserOverwrite_(curViewCache, writePath, childNode, writesCache, serverCache, accumulator);
+    }
+  });
+  return curViewCache;
+};
+fb.core.view.ViewProcessor.prototype.applyMerge_ = function(node, merge) {
+  merge.foreach(function(relativePath, childNode) {
+    node = node.updateChild(relativePath, childNode);
+  });
+  return node;
+};
+fb.core.view.ViewProcessor.prototype.applyServerMerge_ = function(viewCache, path, changedChildren, writesCache, serverCache, constrainServerNode, accumulator) {
+  if (viewCache.getServerCache().getNode().isEmpty() && !viewCache.getServerCache().isFullyInitialized()) {
+    return viewCache;
+  }
+  var curViewCache = viewCache;
+  var viewMergeTree;
+  if (path.isEmpty()) {
+    viewMergeTree = changedChildren;
+  } else {
+    viewMergeTree = fb.core.util.ImmutableTree.Empty.setTree(path, changedChildren);
+  }
+  var serverNode = viewCache.getServerCache().getNode();
+  var self = this;
+  viewMergeTree.children.inorderTraversal(function(childKey, childTree) {
+    if (serverNode.hasChild(childKey)) {
+      var serverChild = viewCache.getServerCache().getNode().getImmediateChild(childKey);
+      var newChild = self.applyMerge_(serverChild, childTree);
+      curViewCache = self.applyServerOverwrite_(curViewCache, new fb.core.util.Path(childKey), newChild, writesCache, serverCache, constrainServerNode, accumulator);
+    }
+  });
+  viewMergeTree.children.inorderTraversal(function(childKey, childMergeTree) {
+    var isUnknownDeepMerge = !viewCache.getServerCache().isFullyInitialized() && childMergeTree.value == null;
+    if (!serverNode.hasChild(childKey) && !isUnknownDeepMerge) {
+      var serverChild = viewCache.getServerCache().getNode().getImmediateChild(childKey);
+      var newChild = self.applyMerge_(serverChild, childMergeTree);
+      curViewCache = self.applyServerOverwrite_(curViewCache, new fb.core.util.Path(childKey), newChild, writesCache, serverCache, constrainServerNode, accumulator);
+    }
+  });
+  return curViewCache;
+};
+fb.core.view.ViewProcessor.prototype.ackUserWrite_ = function(viewCache, ackPath, writesCache, optCompleteCache, accumulator) {
+  if (writesCache.shadowingWrite(ackPath) != null) {
+    return viewCache;
+  } else {
+    var source = new fb.core.view.WriteTreeCompleteChildSource(writesCache, viewCache, optCompleteCache);
+    var oldEventCache = viewCache.getEventCache().getNode();
+    var newEventCache = oldEventCache;
+    var eventCacheComplete;
+    if (viewCache.getServerCache().isFullyInitialized()) {
+      if (ackPath.isEmpty()) {
+        var update = (writesCache.calcCompleteEventCache(viewCache.getCompleteServerSnap()));
+        newEventCache = this.filter_.updateFullNode(viewCache.getEventCache().getNode(), update, accumulator);
+      } else {
+        if (ackPath.getFront() === ".priority") {
+          var updatedPriority = writesCache.calcCompleteChild(ackPath.getFront(), viewCache.getServerCache());
+          if (updatedPriority != null && !oldEventCache.isEmpty() && !oldEventCache.getPriority().equals(updatedPriority)) {
+            newEventCache = this.filter_.updatePriority(oldEventCache, updatedPriority);
+          }
+        } else {
+          var childKey = ackPath.getFront();
+          var updatedChild = writesCache.calcCompleteChild(childKey, viewCache.getServerCache());
+          if (updatedChild != null) {
+            newEventCache = this.filter_.updateChild(viewCache.getEventCache().getNode(), childKey, updatedChild, source, accumulator);
+          }
+        }
+      }
+      eventCacheComplete = true;
+    } else {
+      if (viewCache.getEventCache().isFullyInitialized() || ackPath.isEmpty()) {
+        newEventCache = oldEventCache;
+        var completeEventSnap = viewCache.getEventCache().getNode();
+        if (!completeEventSnap.isLeafNode()) {
+          var self = this;
+          completeEventSnap = (completeEventSnap);
+          completeEventSnap.forEachChild(fb.core.snap.PriorityIndex, function(key, childNode) {
+            var completeChild = writesCache.calcCompleteChild(key, viewCache.getServerCache());
+            if (completeChild != null) {
+              newEventCache = self.filter_.updateChild(newEventCache, key, completeChild, source, accumulator);
+            }
+          });
+        }
+        eventCacheComplete = viewCache.getEventCache().isFullyInitialized();
+      } else {
+        var childKey = ackPath.getFront();
+        if (ackPath.getLength() == 1 || viewCache.getEventCache().isCompleteForChild(childKey)) {
+          var completeChild = writesCache.calcCompleteChild(childKey, viewCache.getServerCache());
+          if (completeChild != null) {
+            newEventCache = this.filter_.updateChild(oldEventCache, childKey, completeChild, source, accumulator);
+          }
+        }
+        eventCacheComplete = false;
+      }
+    }
+    return viewCache.updateEventSnap(newEventCache, eventCacheComplete, this.filter_.filtersNodes());
+  }
+};
+fb.core.view.ViewProcessor.prototype.revertUserWrite_ = function(viewCache, path, writesCache, optCompleteServerCache, accumulator) {
+  var complete;
+  if (writesCache.shadowingWrite(path) != null) {
+    return viewCache;
+  } else {
+    var source = new fb.core.view.WriteTreeCompleteChildSource(writesCache, viewCache, optCompleteServerCache);
+    var oldEventCache = viewCache.getEventCache().getNode();
+    var newEventCache;
+    if (path.isEmpty() || path.getFront() === ".priority") {
+      var newNode;
+      if (viewCache.getServerCache().isFullyInitialized()) {
+        newNode = writesCache.calcCompleteEventCache(viewCache.getCompleteServerSnap());
+      } else {
+        var serverChildren = viewCache.getServerCache().getNode();
+        fb.core.util.assert(serverChildren instanceof fb.core.snap.ChildrenNode, "serverChildren would be complete if leaf node");
+        newNode = writesCache.calcCompleteEventChildren((serverChildren));
+      }
+      newNode = (newNode);
+      newEventCache = this.filter_.updateFullNode(oldEventCache, newNode, accumulator);
+    } else {
+      var childKey = path.getFront();
+      var newChild = writesCache.calcCompleteChild(childKey, viewCache.getServerCache());
+      if (newChild == null && viewCache.getServerCache().isCompleteForChild(childKey)) {
+        newChild = oldEventCache.getImmediateChild(childKey);
+      }
+      if (newChild != null) {
+        newEventCache = this.filter_.updateChild(oldEventCache, childKey, newChild, source, accumulator);
+      } else {
+        if (viewCache.getEventCache().getNode().hasChild(childKey)) {
+          newEventCache = this.filter_.updateChild(oldEventCache, childKey, fb.core.snap.EMPTY_NODE, source, accumulator);
+        } else {
+          newEventCache = oldEventCache;
+        }
+      }
+      if (newEventCache.isEmpty() && viewCache.getServerCache().isFullyInitialized()) {
+        complete = writesCache.calcCompleteEventCache(viewCache.getCompleteServerSnap());
+        if (complete.isLeafNode()) {
+          newEventCache = this.filter_.updateFullNode(newEventCache, complete, accumulator);
+        }
+      }
+    }
+    complete = viewCache.getServerCache().isFullyInitialized() || writesCache.shadowingWrite(fb.core.util.Path.Empty) != null;
+    return viewCache.updateEventSnap(newEventCache, complete, this.filter_.filtersNodes());
+  }
+};
+fb.core.view.ViewProcessor.prototype.listenComplete_ = function(viewCache, path, writesCache, serverCache, accumulator) {
+  var oldServerNode = viewCache.getServerCache();
+  var newViewCache = viewCache.updateServerSnap(oldServerNode.getNode(), oldServerNode.isFullyInitialized() || path.isEmpty(), oldServerNode.isFiltered());
+  return this.generateEventCacheAfterServerEvent_(newViewCache, path, writesCache, fb.core.view.NO_COMPLETE_CHILD_SOURCE, accumulator);
+};
+goog.provide("fb.core.snap.Index");
+goog.provide("fb.core.snap.PriorityIndex");
+goog.provide("fb.core.snap.SubKeyIndex");
+goog.require("fb.core.snap.comparators");
+goog.require("fb.core.util");
+fb.core.snap.Index = function() {
+};
+fb.core.snap.Index.FallbackType;
+fb.core.snap.Index.Fallback = {};
+fb.core.snap.Index.prototype.compare = goog.abstractMethod;
+fb.core.snap.Index.prototype.isDefinedOn = goog.abstractMethod;
+fb.core.snap.Index.prototype.getCompare = function() {
+  return goog.bind(this.compare, this);
+};
+fb.core.snap.Index.prototype.indexedValueChanged = function(oldNode, newNode) {
+  var oldWrapped = new fb.core.snap.NamedNode(fb.core.util.MIN_NAME, oldNode);
+  var newWrapped = new fb.core.snap.NamedNode(fb.core.util.MIN_NAME, newNode);
+  return this.compare(oldWrapped, newWrapped) !== 0;
+};
+fb.core.snap.Index.prototype.minPost = function() {
+  return fb.core.snap.NamedNode.MIN;
+};
+fb.core.snap.Index.prototype.maxPost = goog.abstractMethod;
+fb.core.snap.Index.prototype.makePost = goog.abstractMethod;
+fb.core.snap.Index.prototype.toString = goog.abstractMethod;
+fb.core.snap.SubKeyIndex = function(indexKey) {
+  fb.core.snap.Index.call(this);
+  this.indexKey_ = indexKey;
+};
+goog.inherits(fb.core.snap.SubKeyIndex, fb.core.snap.Index);
+fb.core.snap.SubKeyIndex.prototype.extractChild = function(snap) {
+  return snap.getImmediateChild(this.indexKey_);
+};
+fb.core.snap.SubKeyIndex.prototype.isDefinedOn = function(node) {
+  return!node.getImmediateChild(this.indexKey_).isEmpty();
+};
+fb.core.snap.SubKeyIndex.prototype.compare = function(a, b) {
+  var aChild = this.extractChild(a.node);
+  var bChild = this.extractChild(b.node);
+  var indexCmp = aChild.compareTo(bChild);
+  if (indexCmp === 0) {
+    return fb.core.util.nameCompare(a.name, b.name);
+  } else {
+    return indexCmp;
+  }
+};
+fb.core.snap.SubKeyIndex.prototype.makePost = function(indexValue, name) {
+  var valueNode = fb.core.snap.NodeFromJSON(indexValue);
+  var node = fb.core.snap.EMPTY_NODE.updateImmediateChild(this.indexKey_, valueNode);
+  return new fb.core.snap.NamedNode(name, node);
+};
+fb.core.snap.SubKeyIndex.prototype.maxPost = function() {
+  var node = fb.core.snap.EMPTY_NODE.updateImmediateChild(this.indexKey_, fb.core.snap.MAX_NODE);
+  return new fb.core.snap.NamedNode(fb.core.util.MAX_NAME, node);
+};
+fb.core.snap.SubKeyIndex.prototype.toString = function() {
+  return this.indexKey_;
+};
+fb.core.snap.PriorityIndex_ = function() {
+  fb.core.snap.Index.call(this);
+};
+goog.inherits(fb.core.snap.PriorityIndex_, fb.core.snap.Index);
+fb.core.snap.PriorityIndex_.prototype.compare = function(a, b) {
+  var aPriority = a.node.getPriority();
+  var bPriority = b.node.getPriority();
+  var indexCmp = aPriority.compareTo(bPriority);
+  if (indexCmp === 0) {
+    return fb.core.util.nameCompare(a.name, b.name);
+  } else {
+    return indexCmp;
+  }
+};
+fb.core.snap.PriorityIndex_.prototype.isDefinedOn = function(node) {
+  return!node.getPriority().isEmpty();
+};
+fb.core.snap.PriorityIndex_.prototype.indexedValueChanged = function(oldNode, newNode) {
+  return!oldNode.getPriority().equals(newNode.getPriority());
+};
+fb.core.snap.PriorityIndex_.prototype.minPost = function() {
+  return fb.core.snap.NamedNode.MIN;
+};
+fb.core.snap.PriorityIndex_.prototype.maxPost = function() {
+  return new fb.core.snap.NamedNode(fb.core.util.MAX_NAME, new fb.core.snap.LeafNode("[PRIORITY-POST]", fb.core.snap.MAX_NODE));
+};
+fb.core.snap.PriorityIndex_.prototype.makePost = function(indexValue, name) {
+  var priorityNode = fb.core.snap.NodeFromJSON(indexValue);
+  return new fb.core.snap.NamedNode(name, new fb.core.snap.LeafNode("[PRIORITY-POST]", priorityNode));
+};
+fb.core.snap.PriorityIndex_.prototype.toString = function() {
+  return ".priority";
+};
+fb.core.snap.PriorityIndex = new fb.core.snap.PriorityIndex_;
+fb.core.snap.KeyIndex_ = function() {
+  fb.core.snap.Index.call(this);
+};
+goog.inherits(fb.core.snap.KeyIndex_, fb.core.snap.Index);
+fb.core.snap.KeyIndex_.prototype.compare = function(a, b) {
+  return fb.core.util.nameCompare(a.name, b.name);
+};
+fb.core.snap.KeyIndex_.prototype.isDefinedOn = function(node) {
+  throw fb.core.util.assertionError("KeyIndex.isDefinedOn not expected to be called.");
+};
+fb.core.snap.KeyIndex_.prototype.indexedValueChanged = function(oldNode, newNode) {
+  return false;
+};
+fb.core.snap.KeyIndex_.prototype.minPost = function() {
+  return fb.core.snap.NamedNode.MIN;
+};
+fb.core.snap.KeyIndex_.prototype.maxPost = function() {
+  return new fb.core.snap.NamedNode(fb.core.util.MAX_NAME, fb.core.snap.EMPTY_NODE);
+};
+fb.core.snap.KeyIndex_.prototype.makePost = function(indexValue, name) {
+  fb.core.util.assert(goog.isString(indexValue), "KeyIndex indexValue must always be a string.");
+  return new fb.core.snap.NamedNode((indexValue), fb.core.snap.EMPTY_NODE);
+};
+fb.core.snap.KeyIndex_.prototype.toString = function() {
+  return ".key";
+};
+fb.core.snap.KeyIndex = new fb.core.snap.KeyIndex_;
+fb.core.snap.ValueIndex_ = function() {
+  fb.core.snap.Index.call(this);
+};
+goog.inherits(fb.core.snap.ValueIndex_, fb.core.snap.Index);
+fb.core.snap.ValueIndex_.prototype.compare = function(a, b) {
+  var indexCmp = a.node.compareTo(b.node);
+  if (indexCmp === 0) {
+    return fb.core.util.nameCompare(a.name, b.name);
+  } else {
+    return indexCmp;
+  }
+};
+fb.core.snap.ValueIndex_.prototype.isDefinedOn = function(node) {
+  return true;
+};
+fb.core.snap.ValueIndex_.prototype.indexedValueChanged = function(oldNode, newNode) {
+  return!oldNode.equals(newNode);
+};
+fb.core.snap.ValueIndex_.prototype.minPost = function() {
+  return fb.core.snap.NamedNode.MIN;
+};
+fb.core.snap.ValueIndex_.prototype.maxPost = function() {
+  return fb.core.snap.NamedNode.MAX;
+};
+fb.core.snap.ValueIndex_.prototype.makePost = function(indexValue, name) {
+  var valueNode = fb.core.snap.NodeFromJSON(indexValue);
+  return new fb.core.snap.NamedNode(name, valueNode);
+};
+fb.core.snap.ValueIndex_.prototype.toString = function() {
+  return ".value";
+};
+fb.core.snap.ValueIndex = new fb.core.snap.ValueIndex_;
+goog.provide("fb.core.view.QueryParams");
+goog.require("fb.core.snap.Index");
+goog.require("fb.core.snap.PriorityIndex");
+goog.require("fb.core.util");
+goog.require("fb.core.view.filter.IndexedFilter");
+goog.require("fb.core.view.filter.LimitedFilter");
+goog.require("fb.core.view.filter.NodeFilter");
+goog.require("fb.core.view.filter.RangedFilter");
+fb.core.view.QueryParams = function() {
+  this.limitSet_ = false;
+  this.startSet_ = false;
+  this.startNameSet_ = false;
+  this.endSet_ = false;
+  this.endNameSet_ = false;
+  this.limit_ = 0;
+  this.viewFrom_ = "";
+  this.indexStartValue_ = null;
+  this.indexStartName_ = "";
+  this.indexEndValue_ = null;
+  this.indexEndName_ = "";
+  this.index_ = fb.core.snap.PriorityIndex;
+};
+fb.core.view.QueryParams.WIRE_PROTOCOL_CONSTANTS_ = {INDEX_START_VALUE:"sp", INDEX_START_NAME:"sn", INDEX_END_VALUE:"ep", INDEX_END_NAME:"en", LIMIT:"l", VIEW_FROM:"vf", VIEW_FROM_LEFT:"l", VIEW_FROM_RIGHT:"r", INDEX:"i"};
+fb.core.view.QueryParams.REST_QUERY_CONSTANTS_ = {ORDER_BY:"orderBy", PRIORITY_INDEX:"$priority", VALUE_INDEX:"$value", START_AT:"startAt", END_AT:"endAt", LIMIT_TO_FIRST:"limitToFirst", LIMIT_TO_LAST:"limitToLast"};
+fb.core.view.QueryParams.DEFAULT = new fb.core.view.QueryParams;
+fb.core.view.QueryParams.prototype.hasStart = function() {
+  return this.startSet_;
+};
+fb.core.view.QueryParams.prototype.isViewFromLeft = function() {
+  if (this.viewFrom_ === "") {
+    return this.startSet_;
+  } else {
+    return this.viewFrom_ === fb.core.view.QueryParams.WIRE_PROTOCOL_CONSTANTS_.VIEW_FROM_LEFT;
+  }
+};
+fb.core.view.QueryParams.prototype.getIndexStartValue = function() {
+  fb.core.util.assert(this.startSet_, "Only valid if start has been set");
+  return this.indexStartValue_;
+};
+fb.core.view.QueryParams.prototype.getIndexStartName = function() {
+  fb.core.util.assert(this.startSet_, "Only valid if start has been set");
+  if (this.startNameSet_) {
+    return this.indexStartName_;
+  } else {
+    return fb.core.util.MIN_NAME;
+  }
+};
+fb.core.view.QueryParams.prototype.hasEnd = function() {
+  return this.endSet_;
+};
+fb.core.view.QueryParams.prototype.getIndexEndValue = function() {
+  fb.core.util.assert(this.endSet_, "Only valid if end has been set");
+  return this.indexEndValue_;
+};
+fb.core.view.QueryParams.prototype.getIndexEndName = function() {
+  fb.core.util.assert(this.endSet_, "Only valid if end has been set");
+  if (this.endNameSet_) {
+    return this.indexEndName_;
+  } else {
+    return fb.core.util.MAX_NAME;
+  }
+};
+fb.core.view.QueryParams.prototype.hasLimit = function() {
+  return this.limitSet_;
+};
+fb.core.view.QueryParams.prototype.hasAnchoredLimit = function() {
+  return this.limitSet_ && this.viewFrom_ !== "";
+};
+fb.core.view.QueryParams.prototype.getLimit = function() {
+  fb.core.util.assert(this.limitSet_, "Only valid if limit has been set");
+  return this.limit_;
+};
+fb.core.view.QueryParams.prototype.getIndex = function() {
+  return this.index_;
+};
+fb.core.view.QueryParams.prototype.copy_ = function() {
+  var copy = new fb.core.view.QueryParams;
+  copy.limitSet_ = this.limitSet_;
+  copy.limit_ = this.limit_;
+  copy.startSet_ = this.startSet_;
+  copy.indexStartValue_ = this.indexStartValue_;
+  copy.startNameSet_ = this.startNameSet_;
+  copy.indexStartName_ = this.indexStartName_;
+  copy.endSet_ = this.endSet_;
+  copy.indexEndValue_ = this.indexEndValue_;
+  copy.endNameSet_ = this.endNameSet_;
+  copy.indexEndName_ = this.indexEndName_;
+  copy.index_ = this.index_;
+  return copy;
+};
+fb.core.view.QueryParams.prototype.limit = function(newLimit) {
+  var newParams = this.copy_();
+  newParams.limitSet_ = true;
+  newParams.limit_ = newLimit;
+  newParams.viewFrom_ = "";
+  return newParams;
+};
+fb.core.view.QueryParams.prototype.limitToFirst = function(newLimit) {
+  var newParams = this.copy_();
+  newParams.limitSet_ = true;
+  newParams.limit_ = newLimit;
+  newParams.viewFrom_ = fb.core.view.QueryParams.WIRE_PROTOCOL_CONSTANTS_.VIEW_FROM_LEFT;
+  return newParams;
+};
+fb.core.view.QueryParams.prototype.limitToLast = function(newLimit) {
+  var newParams = this.copy_();
+  newParams.limitSet_ = true;
+  newParams.limit_ = newLimit;
+  newParams.viewFrom_ = fb.core.view.QueryParams.WIRE_PROTOCOL_CONSTANTS_.VIEW_FROM_RIGHT;
+  return newParams;
+};
+fb.core.view.QueryParams.prototype.startAt = function(indexValue, key) {
+  var newParams = this.copy_();
+  newParams.startSet_ = true;
+  if (!goog.isDef(indexValue)) {
+    indexValue = null;
+  }
+  newParams.indexStartValue_ = indexValue;
+  if (key != null) {
+    newParams.startNameSet_ = true;
+    newParams.indexStartName_ = key;
+  } else {
+    newParams.startNameSet_ = false;
+    newParams.indexStartName_ = "";
+  }
+  return newParams;
+};
+fb.core.view.QueryParams.prototype.endAt = function(indexValue, key) {
+  var newParams = this.copy_();
+  newParams.endSet_ = true;
+  if (!goog.isDef(indexValue)) {
+    indexValue = null;
+  }
+  newParams.indexEndValue_ = indexValue;
+  if (goog.isDef(key)) {
+    newParams.endNameSet_ = true;
+    newParams.indexEndName_ = key;
+  } else {
+    newParams.startEndSet_ = false;
+    newParams.indexEndName_ = "";
+  }
+  return newParams;
+};
+fb.core.view.QueryParams.prototype.orderBy = function(index) {
+  var newParams = this.copy_();
+  newParams.index_ = index;
+  return newParams;
+};
+fb.core.view.QueryParams.prototype.getQueryObject = function() {
+  var WIRE_PROTOCOL_CONSTANTS = fb.core.view.QueryParams.WIRE_PROTOCOL_CONSTANTS_;
+  var obj = {};
+  if (this.startSet_) {
+    obj[WIRE_PROTOCOL_CONSTANTS.INDEX_START_VALUE] = this.indexStartValue_;
+    if (this.startNameSet_) {
+      obj[WIRE_PROTOCOL_CONSTANTS.INDEX_START_NAME] = this.indexStartName_;
+    }
+  }
+  if (this.endSet_) {
+    obj[WIRE_PROTOCOL_CONSTANTS.INDEX_END_VALUE] = this.indexEndValue_;
+    if (this.endNameSet_) {
+      obj[WIRE_PROTOCOL_CONSTANTS.INDEX_END_NAME] = this.indexEndName_;
+    }
+  }
+  if (this.limitSet_) {
+    obj[WIRE_PROTOCOL_CONSTANTS.LIMIT] = this.limit_;
+    var viewFrom = this.viewFrom_;
+    if (viewFrom === "") {
+      if (this.isViewFromLeft()) {
+        viewFrom = WIRE_PROTOCOL_CONSTANTS.VIEW_FROM_LEFT;
+      } else {
+        viewFrom = WIRE_PROTOCOL_CONSTANTS.VIEW_FROM_RIGHT;
+      }
+    }
+    obj[WIRE_PROTOCOL_CONSTANTS.VIEW_FROM] = viewFrom;
+  }
+  if (this.index_ !== fb.core.snap.PriorityIndex) {
+    obj[WIRE_PROTOCOL_CONSTANTS.INDEX] = this.index_.toString();
+  }
+  return obj;
+};
+fb.core.view.QueryParams.prototype.loadsAllData = function() {
+  return!(this.startSet_ || this.endSet_ || this.limitSet_);
+};
+fb.core.view.QueryParams.prototype.isDefault = function() {
+  return this.loadsAllData() && this.index_ == fb.core.snap.PriorityIndex;
+};
+fb.core.view.QueryParams.prototype.getNodeFilter = function() {
+  if (this.loadsAllData()) {
+    return new fb.core.view.filter.IndexedFilter(this.getIndex());
+  } else {
+    if (this.hasLimit()) {
+      return new fb.core.view.filter.LimitedFilter(this);
+    } else {
+      return new fb.core.view.filter.RangedFilter(this);
+    }
+  }
+};
+fb.core.view.QueryParams.prototype.toRestQueryStringParameters = function() {
+  var REST_CONSTANTS = fb.core.view.QueryParams.REST_QUERY_CONSTANTS_;
+  var qs = {};
+  if (this.isDefault()) {
+    return qs;
+  }
+  var orderBy;
+  if (this.index_ === fb.core.snap.PriorityIndex) {
+    orderBy = REST_CONSTANTS.PRIORITY_INDEX;
+  } else {
+    if (this.index_ === fb.core.snap.ValueIndex) {
+      orderBy = REST_CONSTANTS.VALUE_INDEX;
+    } else {
+      fb.core.util.assert(this.index_ instanceof fb.core.snap.SubKeyIndex, "Unrecognized index type!");
+      orderBy = this.index_.toString();
+    }
+  }
+  qs[REST_CONSTANTS.ORDER_BY] = fb.util.json.stringify(orderBy);
+  if (this.startSet_) {
+    qs[REST_CONSTANTS.START_AT] = fb.util.json.stringify(this.indexStartValue_);
+    if (this.startNameSet_) {
+      qs[REST_CONSTANTS.START_AT] += "," + fb.util.json.stringify(this.indexStartName_);
+    }
+  }
+  if (this.endSet_) {
+    qs[REST_CONSTANTS.END_AT] = fb.util.json.stringify(this.indexEndValue_);
+    if (this.endNameSet_) {
+      qs[REST_CONSTANTS.END_AT] += "," + fb.util.json.stringify(this.indexEndName_);
+    }
+  }
+  if (this.limitSet_) {
+    if (this.isViewFromLeft()) {
+      qs[REST_CONSTANTS.LIMIT_TO_FIRST] = this.limit_;
+    } else {
+      qs[REST_CONSTANTS.LIMIT_TO_LAST] = this.limit_;
+    }
+  }
+  return qs;
+};
+if (goog.DEBUG) {
+  fb.core.view.QueryParams.prototype.toString = function() {
+    return fb.util.json.stringify(this.getQueryObject());
+  };
+}
+;goog.provide("fb.core.snap.IndexMap");
+goog.require("fb.core.snap.Index");
+goog.require("fb.core.util");
+fb.core.snap.IndexMap = function(indexes, indexSet) {
+  this.indexes_ = indexes;
+  this.indexSet_ = indexSet;
+};
+fb.core.snap.IndexMap.prototype.get = function(indexKey) {
+  var sortedMap = fb.util.obj.get(this.indexes_, indexKey);
+  if (!sortedMap) {
+    throw new Error("No index defined for " + indexKey);
+  }
+  if (sortedMap === fb.core.snap.Index.Fallback) {
+    return null;
+  } else {
+    return sortedMap;
+  }
+};
+fb.core.snap.IndexMap.prototype.hasIndex = function(indexDefinition) {
+  return goog.object.contains(this.indexSet_, indexDefinition.toString());
+};
+fb.core.snap.IndexMap.prototype.addIndex = function(indexDefinition, existingChildren) {
+  fb.core.util.assert(indexDefinition !== fb.core.snap.KeyIndex, "KeyIndex always exists and isn't meant to be added to the IndexMap.");
+  var childList = [];
+  var sawIndexedValue = false;
+  var iter = existingChildren.getIterator(fb.core.snap.NamedNode.Wrap);
+  var next = iter.getNext();
+  while (next) {
+    sawIndexedValue = sawIndexedValue || indexDefinition.isDefinedOn(next.node);
+    childList.push(next);
+    next = iter.getNext();
+  }
+  var newIndex;
+  if (sawIndexedValue) {
+    newIndex = fb.core.snap.buildChildSet(childList, indexDefinition.getCompare());
+  } else {
+    newIndex = fb.core.snap.Index.Fallback;
+  }
+  var indexName = indexDefinition.toString();
+  var newIndexSet = goog.object.clone(this.indexSet_);
+  newIndexSet[indexName] = indexDefinition;
+  var newIndexes = goog.object.clone(this.indexes_);
+  newIndexes[indexName] = newIndex;
+  return new fb.core.snap.IndexMap(newIndexes, newIndexSet);
+};
+fb.core.snap.IndexMap.prototype.addToIndexes = function(namedNode, existingChildren) {
+  var self = this;
+  var newIndexes = goog.object.map(this.indexes_, function(indexedChildren, indexName) {
+    var index = fb.util.obj.get(self.indexSet_, indexName);
+    fb.core.util.assert(index, "Missing index implementation for " + indexName);
+    if (indexedChildren === fb.core.snap.Index.Fallback) {
+      if (index.isDefinedOn(namedNode.node)) {
+        var childList = [];
+        var iter = existingChildren.getIterator(fb.core.snap.NamedNode.Wrap);
+        var next = iter.getNext();
+        while (next) {
+          if (next.name != namedNode.name) {
+            childList.push(next);
+          }
+          next = iter.getNext();
+        }
+        childList.push(namedNode);
+        return fb.core.snap.buildChildSet(childList, index.getCompare());
+      } else {
+        return fb.core.snap.Index.Fallback;
+      }
+    } else {
+      var existingSnap = existingChildren.get(namedNode.name);
+      var newChildren = indexedChildren;
+      if (existingSnap) {
+        newChildren = newChildren.remove(new fb.core.snap.NamedNode(namedNode.name, existingSnap));
+      }
+      return newChildren.insert(namedNode, namedNode.node);
+    }
+  });
+  return new fb.core.snap.IndexMap(newIndexes, this.indexSet_);
+};
+fb.core.snap.IndexMap.prototype.removeFromIndexes = function(namedNode, existingChildren) {
+  var newIndexes = goog.object.map(this.indexes_, function(indexedChildren) {
+    if (indexedChildren === fb.core.snap.Index.Fallback) {
+      return indexedChildren;
+    } else {
+      var existingSnap = existingChildren.get(namedNode.name);
+      if (existingSnap) {
+        return indexedChildren.remove(new fb.core.snap.NamedNode(namedNode.name, existingSnap));
+      } else {
+        return indexedChildren;
+      }
+    }
+  });
+  return new fb.core.snap.IndexMap(newIndexes, this.indexSet_);
+};
+fb.core.snap.IndexMap.Default = new fb.core.snap.IndexMap({".priority":fb.core.snap.Index.Fallback}, {".priority":fb.core.snap.PriorityIndex});
+goog.provide("fb.core.snap.LeafNode");
+goog.require("fb.core.snap.Node");
+goog.require("fb.core.util");
+fb.core.snap.LeafNode = function(value, opt_priorityNode) {
+  this.value_ = value;
+  fb.core.util.assert(goog.isDef(this.value_) && this.value_ !== null, "LeafNode shouldn't be created with null/undefined value.");
+  this.priorityNode_ = opt_priorityNode || fb.core.snap.EMPTY_NODE;
+  fb.core.snap.validatePriorityNode(this.priorityNode_);
+  this.lazyHash_ = null;
+};
+fb.core.snap.LeafNode.prototype.isLeafNode = function() {
+  return true;
+};
+fb.core.snap.LeafNode.prototype.getPriority = function() {
+  return this.priorityNode_;
+};
+fb.core.snap.LeafNode.prototype.updatePriority = function(newPriorityNode) {
+  return new fb.core.snap.LeafNode(this.value_, newPriorityNode);
+};
+fb.core.snap.LeafNode.prototype.getImmediateChild = function(childName) {
+  if (childName === ".priority") {
+    return this.priorityNode_;
+  } else {
+    return fb.core.snap.EMPTY_NODE;
+  }
+};
+fb.core.snap.LeafNode.prototype.getChild = function(path) {
+  if (path.isEmpty()) {
+    return this;
+  } else {
+    if (path.getFront() === ".priority") {
+      return this.priorityNode_;
+    } else {
+      return fb.core.snap.EMPTY_NODE;
+    }
+  }
+};
+fb.core.snap.LeafNode.prototype.hasChild = function() {
+  return false;
+};
+fb.core.snap.LeafNode.prototype.getPredecessorChildName = function(childName, childNode) {
+  return null;
+};
+fb.core.snap.LeafNode.prototype.updateImmediateChild = function(childName, newChildNode) {
+  if (childName === ".priority") {
+    return this.updatePriority(newChildNode);
+  } else {
+    if (newChildNode.isEmpty() && childName !== ".priority") {
+      return this;
+    } else {
+      return fb.core.snap.EMPTY_NODE.updateImmediateChild(childName, newChildNode).updatePriority(this.priorityNode_);
+    }
+  }
+};
+fb.core.snap.LeafNode.prototype.updateChild = function(path, newChildNode) {
+  var front = path.getFront();
+  if (front === null) {
+    return newChildNode;
+  } else {
+    if (newChildNode.isEmpty() && front !== ".priority") {
+      return this;
+    } else {
+      fb.core.util.assert(front !== ".priority" || path.getLength() === 1, ".priority must be the last token in a path");
+      return this.updateImmediateChild(front, fb.core.snap.EMPTY_NODE.updateChild(path.popFront(), newChildNode));
+    }
+  }
+};
+fb.core.snap.LeafNode.prototype.isEmpty = function() {
+  return false;
+};
+fb.core.snap.LeafNode.prototype.numChildren = function() {
+  return 0;
+};
+fb.core.snap.LeafNode.prototype.val = function(opt_exportFormat) {
+  if (opt_exportFormat && !this.getPriority().isEmpty()) {
+    return{".value":this.getValue(), ".priority":this.getPriority().val()};
+  } else {
+    return this.getValue();
+  }
+};
+fb.core.snap.LeafNode.prototype.hash = function() {
+  if (this.lazyHash_ === null) {
+    var toHash = "";
+    if (!this.priorityNode_.isEmpty()) {
+      toHash += "priority:" + fb.core.snap.priorityHashText((this.priorityNode_.val())) + ":";
+    }
+    var type = typeof this.value_;
+    toHash += type + ":";
+    if (type === "number") {
+      toHash += fb.core.util.doubleToIEEE754String((this.value_));
+    } else {
+      toHash += this.value_;
+    }
+    this.lazyHash_ = fb.core.util.sha1(toHash);
+  }
+  return(this.lazyHash_);
+};
+fb.core.snap.LeafNode.prototype.getValue = function() {
+  return this.value_;
+};
+fb.core.snap.LeafNode.prototype.compareTo = function(other) {
+  if (other === fb.core.snap.EMPTY_NODE) {
+    return 1;
+  } else {
+    if (other instanceof fb.core.snap.ChildrenNode) {
+      return-1;
+    } else {
+      fb.core.util.assert(other.isLeafNode(), "Unknown node type");
+      return this.compareToLeafNode_((other));
+    }
+  }
+};
+fb.core.snap.LeafNode.VALUE_TYPE_ORDER = ["object", "boolean", "number", "string"];
+fb.core.snap.LeafNode.prototype.compareToLeafNode_ = function(otherLeaf) {
+  var otherLeafType = typeof otherLeaf.value_;
+  var thisLeafType = typeof this.value_;
+  var otherIndex = goog.array.indexOf(fb.core.snap.LeafNode.VALUE_TYPE_ORDER, otherLeafType);
+  var thisIndex = goog.array.indexOf(fb.core.snap.LeafNode.VALUE_TYPE_ORDER, thisLeafType);
+  fb.core.util.assert(otherIndex >= 0, "Unknown leaf type: " + otherLeafType);
+  fb.core.util.assert(thisIndex >= 0, "Unknown leaf type: " + thisLeafType);
+  if (otherIndex === thisIndex) {
+    if (thisLeafType === "object") {
+      return 0;
+    } else {
+      if (this.value_ < otherLeaf.value_) {
+        return-1;
+      } else {
+        if (this.value_ === otherLeaf.value_) {
+          return 0;
+        } else {
+          return 1;
+        }
+      }
+    }
+  } else {
+    return thisIndex - otherIndex;
+  }
+};
+fb.core.snap.LeafNode.prototype.withIndex = function() {
+  return this;
+};
+fb.core.snap.LeafNode.prototype.isIndexed = function() {
+  return true;
+};
+fb.core.snap.LeafNode.prototype.equals = function(other) {
+  if (other === this) {
+    return true;
+  } else {
+    if (other.isLeafNode()) {
+      var otherLeaf = (other);
+      return this.value_ === otherLeaf.value_ && this.priorityNode_.equals(otherLeaf.priorityNode_);
+    } else {
+      return false;
+    }
+  }
+};
+if (goog.DEBUG) {
+  fb.core.snap.LeafNode.prototype.toString = function() {
+    return fb.util.json.stringify(this.val(true));
+  };
+}
+;goog.provide("fb.core.snap.ChildrenNode");
+goog.require("fb.core.snap.IndexMap");
+goog.require("fb.core.snap.LeafNode");
+goog.require("fb.core.snap.NamedNode");
+goog.require("fb.core.snap.Node");
+goog.require("fb.core.snap.PriorityIndex");
+goog.require("fb.core.snap.comparators");
+goog.require("fb.core.util");
+goog.require("fb.core.util.SortedMap");
+fb.core.snap.ChildrenNode = function(children, priorityNode, indexMap) {
+  this.children_ = children;
+  this.priorityNode_ = priorityNode;
+  if (this.priorityNode_) {
+    fb.core.snap.validatePriorityNode(this.priorityNode_);
+  }
+  if (children.isEmpty()) {
+    fb.core.util.assert(!this.priorityNode_ || this.priorityNode_.isEmpty(), "An empty node cannot have a priority");
+  }
+  this.indexMap_ = indexMap;
+  this.lazyHash_ = null;
+};
+fb.core.snap.ChildrenNode.prototype.isLeafNode = function() {
+  return false;
+};
+fb.core.snap.ChildrenNode.prototype.getPriority = function() {
+  return this.priorityNode_ || fb.core.snap.EMPTY_NODE;
+};
+fb.core.snap.ChildrenNode.prototype.updatePriority = function(newPriorityNode) {
+  if (this.children_.isEmpty()) {
+    return this;
+  } else {
+    return new fb.core.snap.ChildrenNode(this.children_, newPriorityNode, this.indexMap_);
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getImmediateChild = function(childName) {
+  if (childName === ".priority") {
+    return this.getPriority();
+  } else {
+    var child = this.children_.get(childName);
+    return child === null ? fb.core.snap.EMPTY_NODE : child;
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getChild = function(path) {
+  var front = path.getFront();
+  if (front === null) {
+    return this;
+  }
+  return this.getImmediateChild(front).getChild(path.popFront());
+};
+fb.core.snap.ChildrenNode.prototype.hasChild = function(childName) {
+  return this.children_.get(childName) !== null;
+};
+fb.core.snap.ChildrenNode.prototype.updateImmediateChild = function(childName, newChildNode) {
+  fb.core.util.assert(newChildNode, "We should always be passing snapshot nodes");
+  if (childName === ".priority") {
+    return this.updatePriority(newChildNode);
+  } else {
+    var namedNode = new fb.core.snap.NamedNode(childName, newChildNode);
+    var newChildren, newIndexMap, newPriority;
+    if (newChildNode.isEmpty()) {
+      newChildren = this.children_.remove(childName);
+      newIndexMap = this.indexMap_.removeFromIndexes(namedNode, this.children_);
+    } else {
+      newChildren = this.children_.insert(childName, newChildNode);
+      newIndexMap = this.indexMap_.addToIndexes(namedNode, this.children_);
+    }
+    newPriority = newChildren.isEmpty() ? fb.core.snap.EMPTY_NODE : this.priorityNode_;
+    return new fb.core.snap.ChildrenNode(newChildren, newPriority, newIndexMap);
+  }
+};
+fb.core.snap.ChildrenNode.prototype.updateChild = function(path, newChildNode) {
+  var front = path.getFront();
+  if (front === null) {
+    return newChildNode;
+  } else {
+    fb.core.util.assert(path.getFront() !== ".priority" || path.getLength() === 1, ".priority must be the last token in a path");
+    var newImmediateChild = this.getImmediateChild(front).updateChild(path.popFront(), newChildNode);
+    return this.updateImmediateChild(front, newImmediateChild);
+  }
+};
+fb.core.snap.ChildrenNode.prototype.isEmpty = function() {
+  return this.children_.isEmpty();
+};
+fb.core.snap.ChildrenNode.prototype.numChildren = function() {
+  return this.children_.count();
+};
+fb.core.snap.ChildrenNode.INTEGER_REGEXP_ = /^(0|[1-9]\d*)$/;
+fb.core.snap.ChildrenNode.prototype.val = function(opt_exportFormat) {
+  if (this.isEmpty()) {
+    return null;
+  }
+  var obj = {};
+  var numKeys = 0, maxKey = 0, allIntegerKeys = true;
+  this.forEachChild(fb.core.snap.PriorityIndex, function(key, childNode) {
+    obj[key] = childNode.val(opt_exportFormat);
+    numKeys++;
+    if (allIntegerKeys && fb.core.snap.ChildrenNode.INTEGER_REGEXP_.test(key)) {
+      maxKey = Math.max(maxKey, Number(key));
+    } else {
+      allIntegerKeys = false;
+    }
+  });
+  if (!opt_exportFormat && allIntegerKeys && maxKey < 2 * numKeys) {
+    var array = [];
+    for (var key in obj) {
+      array[key] = obj[key];
+    }
+    return array;
+  } else {
+    if (opt_exportFormat && !this.getPriority().isEmpty()) {
+      obj[".priority"] = this.getPriority().val();
+    }
+    return obj;
+  }
+};
+fb.core.snap.ChildrenNode.prototype.hash = function() {
+  if (this.lazyHash_ === null) {
+    var toHash = "";
+    if (!this.getPriority().isEmpty()) {
+      toHash += "priority:" + fb.core.snap.priorityHashText((this.getPriority().val())) + ":";
+    }
+    this.forEachChild(fb.core.snap.PriorityIndex, function(key, childNode) {
+      var childHash = childNode.hash();
+      if (childHash !== "") {
+        toHash += ":" + key + ":" + childHash;
+      }
+    });
+    this.lazyHash_ = toHash === "" ? "" : fb.core.util.sha1(toHash);
+  }
+  return this.lazyHash_;
+};
+fb.core.snap.ChildrenNode.prototype.getPredecessorChildName = function(childName, childNode, index) {
+  var idx = this.resolveIndex_(index);
+  if (idx) {
+    var predecessor = idx.getPredecessorKey(new fb.core.snap.NamedNode(childName, childNode));
+    return predecessor ? predecessor.name : null;
+  } else {
+    return this.children_.getPredecessorKey(childName);
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getFirstChildName = function(indexDefinition) {
+  var idx = this.resolveIndex_(indexDefinition);
+  if (idx) {
+    var minKey = idx.minKey();
+    return minKey && minKey.name;
+  } else {
+    return this.children_.minKey();
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getFirstChild = function(indexDefinition) {
+  var minKey = this.getFirstChildName(indexDefinition);
+  if (minKey) {
+    return new fb.core.snap.NamedNode(minKey, this.children_.get(minKey));
+  } else {
+    return null;
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getLastChildName = function(indexDefinition) {
+  var idx = this.resolveIndex_(indexDefinition);
+  if (idx) {
+    var maxKey = idx.maxKey();
+    return maxKey && maxKey.name;
+  } else {
+    return this.children_.maxKey();
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getLastChild = function(indexDefinition) {
+  var maxKey = this.getLastChildName(indexDefinition);
+  if (maxKey) {
+    return new fb.core.snap.NamedNode(maxKey, this.children_.get(maxKey));
+  } else {
+    return null;
+  }
+};
+fb.core.snap.ChildrenNode.prototype.forEachChild = function(index, action) {
+  var idx = this.resolveIndex_(index);
+  if (idx) {
+    return idx.inorderTraversal(function(wrappedNode) {
+      return action(wrappedNode.name, wrappedNode.node);
+    });
+  } else {
+    return this.children_.inorderTraversal(action);
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getIterator = function(indexDefinition) {
+  return this.getIteratorFrom(indexDefinition.minPost(), indexDefinition);
+};
+fb.core.snap.ChildrenNode.prototype.getIteratorFrom = function(startPost, indexDefinition) {
+  var idx = this.resolveIndex_(indexDefinition);
+  if (idx) {
+    return idx.getIteratorFrom(startPost, function(key) {
+      return key;
+    });
+  } else {
+    var iterator = this.children_.getIteratorFrom(startPost.name, fb.core.snap.NamedNode.Wrap);
+    var next = iterator.peek();
+    while (next != null && indexDefinition.compare(next, startPost) < 0) {
+      iterator.getNext();
+      next = iterator.peek();
+    }
+    return iterator;
+  }
+};
+fb.core.snap.ChildrenNode.prototype.getReverseIterator = function(indexDefinition) {
+  return this.getReverseIteratorFrom(indexDefinition.maxPost(), indexDefinition);
+};
+fb.core.snap.ChildrenNode.prototype.getReverseIteratorFrom = function(endPost, indexDefinition) {
+  var idx = this.resolveIndex_(indexDefinition);
+  if (idx) {
+    return idx.getReverseIteratorFrom(endPost, function(key) {
+      return key;
+    });
+  } else {
+    var iterator = this.children_.getReverseIteratorFrom(endPost.name, fb.core.snap.NamedNode.Wrap);
+    var next = iterator.peek();
+    while (next != null && indexDefinition.compare(next, endPost) > 0) {
+      iterator.getNext();
+      next = iterator.peek();
+    }
+    return iterator;
+  }
+};
+fb.core.snap.ChildrenNode.prototype.compareTo = function(other) {
+  if (this.isEmpty()) {
+    if (other.isEmpty()) {
+      return 0;
+    } else {
+      return-1;
+    }
+  } else {
+    if (other.isLeafNode() || other.isEmpty()) {
+      return 1;
+    } else {
+      if (other === fb.core.snap.MAX_NODE) {
+        return-1;
+      } else {
+        return 0;
+      }
+    }
+  }
+};
+fb.core.snap.ChildrenNode.prototype.withIndex = function(indexDefinition) {
+  if (indexDefinition === fb.core.snap.KeyIndex || this.indexMap_.hasIndex(indexDefinition)) {
+    return this;
+  } else {
+    var newIndexMap = this.indexMap_.addIndex(indexDefinition, this.children_);
+    return new fb.core.snap.ChildrenNode(this.children_, this.priorityNode_, newIndexMap);
+  }
+};
+fb.core.snap.ChildrenNode.prototype.isIndexed = function(index) {
+  return index === fb.core.snap.KeyIndex || this.indexMap_.hasIndex(index);
+};
+fb.core.snap.ChildrenNode.prototype.equals = function(other) {
+  if (other === this) {
+    return true;
+  } else {
+    if (other.isLeafNode()) {
+      return false;
+    } else {
+      var otherChildrenNode = (other);
+      if (!this.getPriority().equals(otherChildrenNode.getPriority())) {
+        return false;
+      } else {
+        if (this.children_.count() === otherChildrenNode.children_.count()) {
+          var thisIter = this.getIterator(fb.core.snap.PriorityIndex);
+          var otherIter = otherChildrenNode.getIterator(fb.core.snap.PriorityIndex);
+          var thisCurrent = thisIter.getNext();
+          var otherCurrent = otherIter.getNext();
+          while (thisCurrent && otherCurrent) {
+            if (thisCurrent.name !== otherCurrent.name || !thisCurrent.node.equals(otherCurrent.node)) {
+              return false;
+            }
+            thisCurrent = thisIter.getNext();
+            otherCurrent = otherIter.getNext();
+          }
+          return thisCurrent === null && otherCurrent === null;
+        } else {
+          return false;
+        }
+      }
+    }
+  }
+};
+fb.core.snap.ChildrenNode.prototype.resolveIndex_ = function(indexDefinition) {
+  if (indexDefinition === fb.core.snap.KeyIndex) {
+    return null;
+  } else {
+    return this.indexMap_.get(indexDefinition.toString());
+  }
+};
+if (goog.DEBUG) {
+  fb.core.snap.ChildrenNode.prototype.toString = function() {
+    return fb.util.json.stringify(this.val(true));
+  };
+}
+;goog.provide("fb.core.snap");
+goog.require("fb.core.snap.ChildrenNode");
+goog.require("fb.core.snap.IndexMap");
+goog.require("fb.core.snap.LeafNode");
+goog.require("fb.core.util");
+var USE_HINZE = true;
+fb.core.snap.NodeFromJSON = function(json, opt_priority) {
+  if (json === null) {
+    return fb.core.snap.EMPTY_NODE;
+  }
+  var priority = null;
+  if (typeof json === "object" && ".priority" in json) {
+    priority = json[".priority"];
+  } else {
+    if (typeof opt_priority !== "undefined") {
+      priority = opt_priority;
+    }
+  }
+  fb.core.util.assert(priority === null || typeof priority === "string" || typeof priority === "number" || typeof priority === "object" && ".sv" in priority, "Invalid priority type found: " + typeof priority);
+  if (typeof json === "object" && ".value" in json && json[".value"] !== null) {
+    json = json[".value"];
+  }
+  if (typeof json !== "object" || ".sv" in json) {
+    var jsonLeaf = (json);
+    return new fb.core.snap.LeafNode(jsonLeaf, fb.core.snap.NodeFromJSON(priority));
+  }
+  if (!(json instanceof Array) && USE_HINZE) {
+    var children = [];
+    var childrenHavePriority = false;
+    var hinzeJsonObj = (json);
+    fb.util.obj.foreach(hinzeJsonObj, function(key, child) {
+      if (typeof key !== "string" || key.substring(0, 1) !== ".") {
+        var childNode = fb.core.snap.NodeFromJSON(hinzeJsonObj[key]);
+        if (!childNode.isEmpty()) {
+          childrenHavePriority = childrenHavePriority || !childNode.getPriority().isEmpty();
+          children.push(new fb.core.snap.NamedNode(key, childNode));
+        }
+      }
+    });
+    if (children.length == 0) {
+      return fb.core.snap.EMPTY_NODE;
+    }
+    var childSet = (fb.core.snap.buildChildSet(children, fb.core.snap.NAME_ONLY_COMPARATOR, function(namedNode) {
+      return namedNode.name;
+    }, fb.core.snap.NAME_COMPARATOR));
+    if (childrenHavePriority) {
+      var sortedChildSet = fb.core.snap.buildChildSet(children, fb.core.snap.PriorityIndex.getCompare());
+      return new fb.core.snap.ChildrenNode(childSet, fb.core.snap.NodeFromJSON(priority), new fb.core.snap.IndexMap({".priority":sortedChildSet}, {".priority":fb.core.snap.PriorityIndex}));
+    } else {
+      return new fb.core.snap.ChildrenNode(childSet, fb.core.snap.NodeFromJSON(priority), fb.core.snap.IndexMap.Default);
+    }
+  } else {
+    var node = fb.core.snap.EMPTY_NODE;
+    var jsonObj = (json);
+    goog.object.forEach(jsonObj, function(childData, key) {
+      if (fb.util.obj.contains(jsonObj, key)) {
+        if (key.substring(0, 1) !== ".") {
+          var childNode = fb.core.snap.NodeFromJSON(childData);
+          if (childNode.isLeafNode() || !childNode.isEmpty()) {
+            node = node.updateImmediateChild(key, childNode);
+          }
+        }
+      }
+    });
+    return node.updatePriority(fb.core.snap.NodeFromJSON(priority));
+  }
+};
+var LOG_2 = Math.log(2);
+fb.core.snap.Base12Num = function(length) {
+  var logBase2 = function(num) {
+    return parseInt(Math.log(num) / LOG_2, 10);
+  };
+  var bitMask = function(bits) {
+    return parseInt(Array(bits + 1).join("1"), 2);
+  };
+  this.count = logBase2(length + 1);
+  this.current_ = this.count - 1;
+  var mask = bitMask(this.count);
+  this.bits_ = length + 1 & mask;
+};
+fb.core.snap.Base12Num.prototype.nextBitIsOne = function() {
+  var result = !(this.bits_ & 1 << this.current_);
+  this.current_--;
+  return result;
+};
+fb.core.snap.buildChildSet = function(childList, cmp, keyFn, mapSortFn) {
+  childList.sort(cmp);
+  var buildBalancedTree = function(low, high) {
+    var length = high - low;
+    if (length == 0) {
+      return null;
+    } else {
+      if (length == 1) {
+        var namedNode = childList[low];
+        var key = keyFn ? keyFn(namedNode) : namedNode;
+        return new fb.LLRBNode(key, namedNode.node, fb.LLRBNode.BLACK, null, null);
+      } else {
+        var middle = parseInt(length / 2, 10) + low;
+        var left = buildBalancedTree(low, middle);
+        var right = buildBalancedTree(middle + 1, high);
+        namedNode = childList[middle];
+        key = keyFn ? keyFn(namedNode) : namedNode;
+        return new fb.LLRBNode(key, namedNode.node, fb.LLRBNode.BLACK, left, right);
+      }
+    }
+  };
+  var buildFrom12Array = function(base12) {
+    var node = null;
+    var root = null;
+    var index = childList.length;
+    var buildPennant = function(chunkSize, color) {
+      var low = index - chunkSize;
+      var high = index;
+      index -= chunkSize;
+      var childTree = buildBalancedTree(low + 1, high);
+      var namedNode = childList[low];
+      var key = keyFn ? keyFn(namedNode) : namedNode;
+      attachPennant(new fb.LLRBNode(key, namedNode.node, color, null, childTree));
+    };
+    var attachPennant = function(pennant) {
+      if (node) {
+        node.left = pennant;
+        node = pennant;
+      } else {
+        root = pennant;
+        node = pennant;
+      }
+    };
+    for (var i = 0;i < base12.count;++i) {
+      var isOne = base12.nextBitIsOne();
+      var chunkSize = Math.pow(2, base12.count - (i + 1));
+      if (isOne) {
+        buildPennant(chunkSize, fb.LLRBNode.BLACK);
+      } else {
+        buildPennant(chunkSize, fb.LLRBNode.BLACK);
+        buildPennant(chunkSize, fb.LLRBNode.RED);
+      }
+    }
+    return root;
+  };
+  var base12 = new fb.core.snap.Base12Num(childList.length);
+  var root = buildFrom12Array(base12);
+  if (root !== null) {
+    return new fb.core.util.SortedMap(mapSortFn || cmp, root);
+  } else {
+    return new fb.core.util.SortedMap(mapSortFn || cmp);
+  }
+};
+fb.core.snap.priorityHashText = function(priority) {
+  if (typeof priority === "number") {
+    return "number:" + fb.core.util.doubleToIEEE754String(priority);
+  } else {
+    return "string:" + priority;
+  }
+};
+fb.core.snap.validatePriorityNode = function(priorityNode) {
+  if (priorityNode.isLeafNode()) {
+    var val = priorityNode.val();
+    fb.core.util.assert(typeof val === "string" || typeof val === "number" || typeof val === "object" && fb.util.obj.contains(val, ".sv"), "Priority must be a string or number.");
+  } else {
+    fb.core.util.assert(priorityNode === fb.core.snap.MAX_NODE || priorityNode.isEmpty(), "priority of unexpected type.");
+  }
+  fb.core.util.assert(priorityNode === fb.core.snap.MAX_NODE || priorityNode.getPriority().isEmpty(), "Priority nodes can't have a priority of their own.");
+};
+fb.core.snap.EMPTY_NODE = new fb.core.snap.ChildrenNode(new fb.core.util.SortedMap(fb.core.snap.NAME_COMPARATOR), null, fb.core.snap.IndexMap.Default);
+fb.core.snap.MAX_NODE_ = function() {
+  fb.core.snap.ChildrenNode.call(this, new fb.core.util.SortedMap(fb.core.snap.NAME_COMPARATOR), fb.core.snap.EMPTY_NODE, fb.core.snap.IndexMap.Default);
+};
+goog.inherits(fb.core.snap.MAX_NODE_, fb.core.snap.ChildrenNode);
+fb.core.snap.MAX_NODE_.prototype.compareTo = function(other) {
+  if (other === this) {
+    return 0;
+  } else {
+    return 1;
+  }
+};
+fb.core.snap.MAX_NODE_.prototype.equals = function(other) {
+  return other === this;
+};
+fb.core.snap.MAX_NODE_.prototype.getPriority = function() {
+  return this;
+};
+fb.core.snap.MAX_NODE_.prototype.getImmediateChild = function(childName) {
+  return fb.core.snap.EMPTY_NODE;
+};
+fb.core.snap.MAX_NODE_.prototype.isEmpty = function() {
+  return false;
+};
+fb.core.snap.MAX_NODE = new fb.core.snap.MAX_NODE_;
+fb.core.snap.NamedNode.MIN = new fb.core.snap.NamedNode(fb.core.util.MIN_NAME, fb.core.snap.EMPTY_NODE);
+fb.core.snap.NamedNode.MAX = new fb.core.snap.NamedNode(fb.core.util.MAX_NAME, fb.core.snap.MAX_NODE);
+goog.provide("fb.core.view.ViewCache");
+goog.require("fb.core.view.CacheNode");
+goog.require("fb.core.snap");
+fb.core.view.ViewCache = function(eventCache, serverCache) {
+  this.eventCache_ = eventCache;
+  this.serverCache_ = serverCache;
+};
+fb.core.view.ViewCache.Empty = new fb.core.view.ViewCache(new fb.core.view.CacheNode(fb.core.snap.EMPTY_NODE, false, false), new fb.core.view.CacheNode(fb.core.snap.EMPTY_NODE, false, false));
+fb.core.view.ViewCache.prototype.updateEventSnap = function(eventSnap, complete, filtered) {
+  return new fb.core.view.ViewCache(new fb.core.view.CacheNode(eventSnap, complete, filtered), this.serverCache_);
+};
+fb.core.view.ViewCache.prototype.updateServerSnap = function(serverSnap, complete, filtered) {
+  return new fb.core.view.ViewCache(this.eventCache_, new fb.core.view.CacheNode(serverSnap, complete, filtered));
+};
+fb.core.view.ViewCache.prototype.getEventCache = function() {
+  return this.eventCache_;
+};
+fb.core.view.ViewCache.prototype.getCompleteEventSnap = function() {
+  return this.eventCache_.isFullyInitialized() ? this.eventCache_.getNode() : null;
+};
+fb.core.view.ViewCache.prototype.getServerCache = function() {
+  return this.serverCache_;
+};
+fb.core.view.ViewCache.prototype.getCompleteServerSnap = function() {
+  return this.serverCache_.isFullyInitialized() ? this.serverCache_.getNode() : null;
+};
+goog.provide("fb.core.view.View");
+goog.require("fb.core.view.EventGenerator");
+goog.require("fb.core.view.ViewCache");
+goog.require("fb.core.view.ViewProcessor");
+goog.require("fb.core.util");
+fb.core.view.View = function(query, initialViewCache) {
+  this.query_ = query;
+  var params = query.getQueryParams();
+  var indexFilter = new fb.core.view.filter.IndexedFilter(params.getIndex());
+  var filter = params.getNodeFilter();
+  this.processor_ = new fb.core.view.ViewProcessor(filter);
+  var initialServerCache = initialViewCache.getServerCache();
+  var initialEventCache = initialViewCache.getEventCache();
+  var serverSnap = indexFilter.updateFullNode(fb.core.snap.EMPTY_NODE, initialServerCache.getNode(), null);
+  var eventSnap = filter.updateFullNode(fb.core.snap.EMPTY_NODE, initialEventCache.getNode(), null);
+  var newServerCache = new fb.core.view.CacheNode(serverSnap, initialServerCache.isFullyInitialized(), indexFilter.filtersNodes());
+  var newEventCache = new fb.core.view.CacheNode(eventSnap, initialEventCache.isFullyInitialized(), filter.filtersNodes());
+  this.viewCache_ = new fb.core.view.ViewCache(newEventCache, newServerCache);
+  this.eventRegistrations_ = [];
+  this.eventGenerator_ = new fb.core.view.EventGenerator(query);
+};
+fb.core.view.View.prototype.getQuery = function() {
+  return this.query_;
+};
+fb.core.view.View.prototype.getServerCache = function() {
+  return this.viewCache_.getServerCache().getNode();
+};
+fb.core.view.View.prototype.getCompleteServerCache = function(path) {
+  var cache = this.viewCache_.getCompleteServerSnap();
+  if (cache) {
+    if (this.query_.getQueryParams().loadsAllData() || !path.isEmpty() && !cache.getImmediateChild(path.getFront()).isEmpty()) {
+      return cache.getChild(path);
+    }
+  }
+  return null;
+};
+fb.core.view.View.prototype.isEmpty = function() {
+  return this.eventRegistrations_.length === 0;
+};
+fb.core.view.View.prototype.addEventRegistration = function(eventRegistration) {
+  this.eventRegistrations_.push(eventRegistration);
+};
+fb.core.view.View.prototype.removeEventRegistration = function(eventRegistration, cancelError) {
+  var cancelEvents = [];
+  if (cancelError) {
+    fb.core.util.assert(eventRegistration == null, "A cancel should cancel all event registrations.");
+    var path = this.query_.path;
+    goog.array.forEach(this.eventRegistrations_, function(registration) {
+      cancelError = (cancelError);
+      var maybeEvent = registration.createCancelEvent(cancelError, path);
+      if (maybeEvent) {
+        cancelEvents.push(maybeEvent);
+      }
+    });
+  }
+  if (eventRegistration) {
+    var remaining = [];
+    for (var i = 0;i < this.eventRegistrations_.length;++i) {
+      var existing = this.eventRegistrations_[i];
+      if (!existing.matches(eventRegistration)) {
+        remaining.push(existing);
+      } else {
+        if (eventRegistration.hasAnyCallback()) {
+          remaining = remaining.concat(this.eventRegistrations_.slice(i + 1));
+          break;
+        }
+      }
+    }
+    this.eventRegistrations_ = remaining;
+  } else {
+    this.eventRegistrations_ = [];
+  }
+  return cancelEvents;
+};
+fb.core.view.View.prototype.applyOperation = function(operation, writesCache, optCompleteServerCache) {
+  if (operation.type === fb.core.OperationType.MERGE && operation.source.queryId !== null) {
+    fb.core.util.assert(this.viewCache_.getCompleteServerSnap(), "We should always have a full cache before handling merges");
+    fb.core.util.assert(this.viewCache_.getCompleteEventSnap(), "Missing event cache, even though we have a server cache");
+  }
+  var oldViewCache = this.viewCache_;
+  var result = this.processor_.applyOperation(oldViewCache, operation, writesCache, optCompleteServerCache);
+  this.processor_.assertIndexed(result.viewCache);
+  fb.core.util.assert(result.viewCache.getServerCache().isFullyInitialized() || !oldViewCache.getServerCache().isFullyInitialized(), "Once a server snap is complete, it should never go back");
+  this.viewCache_ = result.viewCache;
+  return this.generateEventsForChanges_(result.changes, result.viewCache.getEventCache().getNode(), null);
+};
+fb.core.view.View.prototype.getInitialEvents = function(registration) {
+  var eventSnap = this.viewCache_.getEventCache();
+  var initialChanges = [];
+  if (!eventSnap.getNode().isLeafNode()) {
+    var eventNode = (eventSnap.getNode());
+    eventNode.forEachChild(fb.core.snap.PriorityIndex, function(key, childNode) {
+      initialChanges.push(fb.core.view.Change.childAddedChange(key, childNode));
+    });
+  }
+  if (eventSnap.isFullyInitialized()) {
+    initialChanges.push(fb.core.view.Change.valueChange(eventSnap.getNode()));
+  }
+  return this.generateEventsForChanges_(initialChanges, eventSnap.getNode(), registration);
+};
+fb.core.view.View.prototype.generateEventsForChanges_ = function(changes, eventCache, opt_eventRegistration) {
+  var registrations = opt_eventRegistration ? [opt_eventRegistration] : this.eventRegistrations_;
+  return this.eventGenerator_.generateEventsForChanges(changes, eventCache, registrations);
+};
+goog.provide("fb.core.operation.Merge");
+goog.require("fb.core.util");
+fb.core.operation.Merge = function(source, path, children) {
+  this.type = fb.core.OperationType.MERGE;
+  this.source = source;
+  this.path = path;
+  this.children = children;
+};
+fb.core.operation.Merge.prototype.operationForChild = function(childName) {
+  if (this.path.isEmpty()) {
+    var childTree = this.children.subtree(new fb.core.util.Path(childName));
+    if (childTree.isEmpty()) {
+      return null;
+    } else {
+      if (childTree.value) {
+        return new fb.core.operation.Overwrite(this.source, fb.core.util.Path.Empty, childTree.value);
+      } else {
+        return new fb.core.operation.Merge(this.source, fb.core.util.Path.Empty, childTree);
+      }
+    }
+  } else {
+    fb.core.util.assert(this.path.getFront() === childName, "Can't get a merge for a child not on the path of the operation");
+    return new fb.core.operation.Merge(this.source, this.path.popFront(), this.children);
+  }
+};
+if (goog.DEBUG) {
+  fb.core.operation.Merge.prototype.toString = function() {
+    return "Operation(" + this.path + ": " + this.source.toString() + " merge: " + this.children.toString() + ")";
+  };
+}
+;goog.provide("fb.core.Operation");
+goog.require("fb.core.operation.AckUserWrite");
+goog.require("fb.core.operation.Merge");
+goog.require("fb.core.operation.Overwrite");
+goog.require("fb.core.operation.ListenComplete");
+goog.require("fb.core.util");
+fb.core.OperationType = {OVERWRITE:0, MERGE:1, ACK_USER_WRITE:2, LISTEN_COMPLETE:3};
+fb.core.Operation = function() {
+};
+fb.core.Operation.prototype.source;
+fb.core.Operation.prototype.type;
+fb.core.Operation.prototype.path;
+fb.core.Operation.prototype.operationForChild = goog.abstractMethod;
+fb.core.OperationSource = function(fromUser, fromServer, queryId, tagged) {
+  this.fromUser = fromUser;
+  this.fromServer = fromServer;
+  this.queryId = queryId;
+  this.tagged = tagged;
+  fb.core.util.assert(!tagged || fromServer, "Tagged queries must be from server.");
+};
+fb.core.OperationSource.User = new fb.core.OperationSource(true, false, null, false);
+fb.core.OperationSource.Server = new fb.core.OperationSource(false, true, null, false);
+fb.core.OperationSource.forServerTaggedQuery = function(queryId) {
+  return new fb.core.OperationSource(false, true, queryId, true);
+};
+if (goog.DEBUG) {
+  fb.core.OperationSource.prototype.toString = function() {
+    return this.fromUser ? "user" : this.tagged ? "server(queryID=" + this.queryId + ")" : "server";
+  };
+}
+;goog.provide("fb.core.ReadonlyRestClient");
+goog.require("fb.core.util");
+goog.require("fb.util");
+goog.require("fb.util.json");
+goog.require("fb.util.jwt");
+goog.require("fb.util.obj");
+fb.core.ReadonlyRestClient = goog.defineClass(null, {constructor:function(repoInfo, onDataUpdate) {
+  this.log_ = fb.core.util.logWrapper("p:rest:");
+  this.repoInfo_ = repoInfo;
+  this.onDataUpdate_ = onDataUpdate;
+  this.credential_ = null;
+  this.listens_ = {};
+}, listen:function(query, currentHashFn, tag, onComplete) {
+  var pathString = query.path.toString();
+  this.log_("Listen called for " + pathString + " " + query.queryIdentifier());
+  var listenId = fb.core.ReadonlyRestClient.getListenId_(query, tag);
+  var thisListen = new Object;
+  this.listens_[listenId] = thisListen;
+  var queryStringParamaters = query.getQueryParams().toRestQueryStringParameters();
+  var self = this;
+  this.restRequest_(pathString + ".json", queryStringParamaters, function(error, result) {
+    var data = result;
+    if (error === 404) {
+      data = null;
+      error = null;
+    }
+    if (error === null) {
+      self.onDataUpdate_(pathString, data, false, tag);
+    }
+    if (fb.util.obj.get(self.listens_, listenId) === thisListen) {
+      var status;
+      if (!error) {
+        status = "ok";
+      } else {
+        if (error == 401) {
+          status = "permission_denied";
+        } else {
+          status = "rest_error:" + error;
+        }
+      }
+      onComplete(status, null);
+    }
+  });
+}, unlisten:function(query, tag) {
+  var listenId = fb.core.ReadonlyRestClient.getListenId_(query, tag);
+  delete this.listens_[listenId];
+}, auth:function(cred, opt_callback, opt_cancelCallback) {
+  this.credential_ = cred;
+  var res = fb.util.jwt.decode(cred);
+  var auth = res.data;
+  var expires = res.claims && res.claims["exp"];
+  if (opt_callback) {
+    opt_callback("ok", {"auth":auth, "expires":expires});
+  }
+}, unauth:function(onComplete) {
+  this.credential_ = null;
+  onComplete("ok", null);
+}, onDisconnectPut:function(pathString, data, opt_onComplete) {
+}, onDisconnectMerge:function(pathString, data, opt_onComplete) {
+}, onDisconnectCancel:function(pathString, opt_onComplete) {
+}, put:function(pathString, data, opt_onComplete, opt_hash) {
+}, merge:function(pathString, data, onComplete, opt_hash) {
+}, reportStats:function(stats) {
+}, restRequest_:function(pathString, queryStringParameters, callback) {
+  queryStringParameters = queryStringParameters || {};
+  queryStringParameters["format"] = "export";
+  if (this.credential_) {
+    queryStringParameters["auth"] = this.credential_;
+  }
+  var url = (this.repoInfo_.secure ? "https://" : "http://") + this.repoInfo_.host + pathString + "?" + fb.util.querystring(queryStringParameters);
+  this.log_("Sending REST request for " + url);
+  var xhr = new XMLHttpRequest;
+  var self = this;
+  xhr.onreadystatechange = function() {
+    if (callback && xhr.readyState === 4) {
+      self.log_("REST Response for " + url + " received. status:", xhr.status, "response:", xhr.responseText);
+      var res = null;
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try {
+          res = fb.util.json.eval(xhr.responseText);
+        } catch (e) {
+          fb.core.util.warn("Failed to parse JSON response for " + url + ": " + xhr.responseText);
+        }
+        callback(null, res);
+      } else {
+        if (xhr.status !== 401 && xhr.status !== 404) {
+          fb.core.util.warn("Got unsuccessful REST response for " + url + " Status: " + xhr.status);
+        }
+        callback(xhr.status);
+      }
+      callback = null;
+    }
+  };
+  xhr.open("GET", url, true);
+  xhr.send();
+}, statics:{getListenId_:function(query, opt_tag) {
+  if (goog.isDef(opt_tag)) {
+    return "tag$" + opt_tag;
+  } else {
+    fb.core.util.assert(query.getQueryParams().isDefault(), "should have a tag if it's not a default query.");
+    return query.path.toString();
+  }
+}}});
+goog.provide("fb.core.util.ImmutableTree");
+goog.require("fb.core.util");
+goog.require("fb.core.util.Path");
+goog.require("fb.core.util.SortedMap");
+goog.require("fb.util.json");
+goog.require("fb.util.obj");
+goog.require("goog.object");
+fb.core.util.ImmutableTree = goog.defineClass(null, {constructor:function(value, opt_children) {
+  this.value = value;
+  this.children = opt_children || fb.core.util.ImmutableTree.EmptyChildren_;
+}, statics:{EmptyChildren_:new fb.core.util.SortedMap(fb.core.util.stringCompare), fromObject:function(obj) {
+  var tree = fb.core.util.ImmutableTree.Empty;
+  goog.object.forEach(obj, function(childSnap, childPath) {
+    tree = tree.set(new fb.core.util.Path(childPath), childSnap);
+  });
+  return tree;
+}}, isEmpty:function() {
+  return this.value === null && this.children.isEmpty();
+}, findRootMostMatchingPathAndValue:function(relativePath, predicate) {
+  if (this.value != null && predicate(this.value)) {
+    return{path:fb.core.util.Path.Empty, value:this.value};
+  } else {
+    if (relativePath.isEmpty()) {
+      return null;
+    } else {
+      var front = relativePath.getFront();
+      var child = this.children.get(front);
+      if (child !== null) {
+        var childExistingPathAndValue = child.findRootMostMatchingPathAndValue(relativePath.popFront(), predicate);
+        if (childExistingPathAndValue != null) {
+          var fullPath = (new fb.core.util.Path(front)).child(childExistingPathAndValue.path);
+          return{path:fullPath, value:childExistingPathAndValue.value};
+        } else {
+          return null;
+        }
+      } else {
+        return null;
+      }
+    }
+  }
+}, findRootMostValueAndPath:function(relativePath) {
+  return this.findRootMostMatchingPathAndValue(relativePath, function() {
+    return true;
+  });
+}, subtree:function(relativePath) {
+  if (relativePath.isEmpty()) {
+    return this;
+  } else {
+    var front = relativePath.getFront();
+    var childTree = this.children.get(front);
+    if (childTree !== null) {
+      return childTree.subtree(relativePath.popFront());
+    } else {
+      return fb.core.util.ImmutableTree.Empty;
+    }
+  }
+}, set:function(relativePath, toSet) {
+  if (relativePath.isEmpty()) {
+    return new fb.core.util.ImmutableTree(toSet, this.children);
+  } else {
+    var front = relativePath.getFront();
+    var child = this.children.get(front) || fb.core.util.ImmutableTree.Empty;
+    var newChild = child.set(relativePath.popFront(), toSet);
+    var newChildren = this.children.insert(front, newChild);
+    return new fb.core.util.ImmutableTree(this.value, newChildren);
+  }
+}, remove:function(relativePath) {
+  if (relativePath.isEmpty()) {
+    if (this.children.isEmpty()) {
+      return fb.core.util.ImmutableTree.Empty;
+    } else {
+      return new fb.core.util.ImmutableTree(null, this.children);
+    }
+  } else {
+    var front = relativePath.getFront();
+    var child = this.children.get(front);
+    if (child) {
+      var newChild = child.remove(relativePath.popFront());
+      var newChildren;
+      if (newChild.isEmpty()) {
+        newChildren = this.children.remove(front);
+      } else {
+        newChildren = this.children.insert(front, newChild);
+      }
+      if (this.value === null && newChildren.isEmpty()) {
+        return fb.core.util.ImmutableTree.Empty;
+      } else {
+        return new fb.core.util.ImmutableTree(this.value, newChildren);
+      }
+    } else {
+      return this;
+    }
+  }
+}, get:function(relativePath) {
+  if (relativePath.isEmpty()) {
+    return this.value;
+  } else {
+    var front = relativePath.getFront();
+    var child = this.children.get(front);
+    if (child) {
+      return child.get(relativePath.popFront());
+    } else {
+      return null;
+    }
+  }
+}, setTree:function(relativePath, newTree) {
+  if (relativePath.isEmpty()) {
+    return newTree;
+  } else {
+    var front = relativePath.getFront();
+    var child = this.children.get(front) || fb.core.util.ImmutableTree.Empty;
+    var newChild = child.setTree(relativePath.popFront(), newTree);
+    var newChildren;
+    if (newChild.isEmpty()) {
+      newChildren = this.children.remove(front);
+    } else {
+      newChildren = this.children.insert(front, newChild);
+    }
+    return new fb.core.util.ImmutableTree(this.value, newChildren);
+  }
+}, fold:function(fn) {
+  return this.fold_(fb.core.util.Path.Empty, fn);
+}, fold_:function(pathSoFar, fn) {
+  var accum = {};
+  this.children.inorderTraversal(function(childKey, childTree) {
+    accum[childKey] = childTree.fold_(pathSoFar.child(childKey), fn);
+  });
+  return fn(pathSoFar, this.value, accum);
+}, findOnPath:function(path, f) {
+  return this.findOnPath_(path, fb.core.util.Path.Empty, f);
+}, findOnPath_:function(pathToFollow, pathSoFar, f) {
+  var result = this.value ? f(pathSoFar, this.value) : false;
+  if (result) {
+    return result;
+  } else {
+    if (pathToFollow.isEmpty()) {
+      return null;
+    } else {
+      var front = pathToFollow.getFront();
+      var nextChild = this.children.get(front);
+      if (nextChild) {
+        return nextChild.findOnPath_(pathToFollow.popFront(), pathSoFar.child(front), f);
+      } else {
+        return null;
+      }
+    }
+  }
+}, foreachOnPathWhile:function(path, f) {
+  return this.foreachOnPathWhile_(path, fb.core.util.Path.Empty, f);
+}, foreachOnPathWhile_:function(pathToFollow, currentRelativePath, f) {
+  if (pathToFollow.isEmpty()) {
+    return currentRelativePath;
+  } else {
+    var shouldContinue = true;
+    if (this.value) {
+      shouldContinue = f(currentRelativePath, this.value);
+    }
+    if (shouldContinue === true) {
+      var front = pathToFollow.getFront();
+      var nextChild = this.children.get(front);
+      if (nextChild) {
+        return nextChild.foreachOnPath_(pathToFollow.popFront(), currentRelativePath.child(front), f);
+      } else {
+        return currentRelativePath;
+      }
+    } else {
+      return currentRelativePath;
+    }
+  }
+}, foreachOnPath:function(path, f) {
+  return this.foreachOnPath_(path, fb.core.util.Path.Empty, f);
+}, foreachOnPath_:function(pathToFollow, currentRelativePath, f) {
+  if (pathToFollow.isEmpty()) {
+    return this;
+  } else {
+    if (this.value) {
+      f(currentRelativePath, this.value);
+    }
+    var front = pathToFollow.getFront();
+    var nextChild = this.children.get(front);
+    if (nextChild) {
+      return nextChild.foreachOnPath_(pathToFollow.popFront(), currentRelativePath.child(front), f);
+    } else {
+      return fb.core.util.ImmutableTree.Empty;
+    }
+  }
+}, foreach:function(f) {
+  this.foreach_(fb.core.util.Path.Empty, f);
+}, foreach_:function(currentRelativePath, f) {
+  this.children.inorderTraversal(function(childName, childTree) {
+    childTree.foreach_(currentRelativePath.child(childName), f);
+  });
+  if (this.value) {
+    f(currentRelativePath, this.value);
+  }
+}, foreachChild:function(f) {
+  this.children.inorderTraversal(function(childName, childTree) {
+    if (childTree.value) {
+      f(childName, childTree.value);
+    }
+  });
+}});
+fb.core.util.ImmutableTree.Empty = new fb.core.util.ImmutableTree(null);
+if (goog.DEBUG) {
+  fb.core.util.ImmutableTree.prototype.toString = function() {
+    var json = {};
+    this.foreach(function(relativePath, value) {
+      var pathString = relativePath.toString();
+      json[pathString] = value.toString();
+    });
+    return fb.util.json.stringify(json);
+  };
+}
+;goog.provide("fb.core.CompoundWrite");
+goog.require("fb.core.snap.Node");
+goog.require("fb.core.util");
+goog.require("fb.core.util.ImmutableTree");
+fb.core.CompoundWrite = function(writeTree) {
+  this.writeTree_ = writeTree;
+};
+fb.core.CompoundWrite.Empty = new fb.core.CompoundWrite((new fb.core.util.ImmutableTree(null)));
+fb.core.CompoundWrite.prototype.addWrite = function(path, node) {
+  if (path.isEmpty()) {
+    return new fb.core.CompoundWrite(new fb.core.util.ImmutableTree(node));
+  } else {
+    var rootmost = this.writeTree_.findRootMostValueAndPath(path);
+    if (rootmost != null) {
+      var rootMostPath = rootmost.path, value = rootmost.value;
+      var relativePath = fb.core.util.Path.relativePath(rootMostPath, path);
+      value = value.updateChild(relativePath, node);
+      return new fb.core.CompoundWrite(this.writeTree_.set(rootMostPath, value));
+    } else {
+      var subtree = new fb.core.util.ImmutableTree(node);
+      var newWriteTree = this.writeTree_.setTree(path, subtree);
+      return new fb.core.CompoundWrite(newWriteTree);
+    }
+  }
+};
+fb.core.CompoundWrite.prototype.addWrites = function(path, updates) {
+  var newWrite = this;
+  fb.util.obj.foreach(updates, function(childKey, node) {
+    newWrite = newWrite.addWrite(path.child(childKey), node);
+  });
+  return newWrite;
+};
+fb.core.CompoundWrite.prototype.removeWrite = function(path) {
+  if (path.isEmpty()) {
+    return fb.core.CompoundWrite.Empty;
+  } else {
+    var newWriteTree = this.writeTree_.setTree(path, fb.core.util.ImmutableTree.Empty);
+    return new fb.core.CompoundWrite(newWriteTree);
+  }
+};
+fb.core.CompoundWrite.prototype.hasCompleteWrite = function(path) {
+  return this.getCompleteNode(path) != null;
+};
+fb.core.CompoundWrite.prototype.getCompleteNode = function(path) {
+  var rootmost = this.writeTree_.findRootMostValueAndPath(path);
+  if (rootmost != null) {
+    return this.writeTree_.get(rootmost.path).getChild(fb.core.util.Path.relativePath(rootmost.path, path));
+  } else {
+    return null;
+  }
+};
+fb.core.CompoundWrite.prototype.getCompleteChildren = function() {
+  var children = [];
+  var node = this.writeTree_.value;
+  if (node != null) {
+    if (!node.isLeafNode()) {
+      node = (node);
+      node.forEachChild(fb.core.snap.PriorityIndex, function(childName, childNode) {
+        children.push(new fb.core.snap.NamedNode(childName, childNode));
+      });
+    }
+  } else {
+    this.writeTree_.children.inorderTraversal(function(childName, childTree) {
+      if (childTree.value != null) {
+        children.push(new fb.core.snap.NamedNode(childName, childTree.value));
+      }
+    });
+  }
+  return children;
+};
+fb.core.CompoundWrite.prototype.childCompoundWrite = function(path) {
+  if (path.isEmpty()) {
+    return this;
+  } else {
+    var shadowingNode = this.getCompleteNode(path);
+    if (shadowingNode != null) {
+      return new fb.core.CompoundWrite(new fb.core.util.ImmutableTree(shadowingNode));
+    } else {
+      return new fb.core.CompoundWrite(this.writeTree_.subtree(path));
+    }
+  }
+};
+fb.core.CompoundWrite.prototype.isEmpty = function() {
+  return this.writeTree_.isEmpty();
+};
+fb.core.CompoundWrite.prototype.apply = function(node) {
+  return fb.core.CompoundWrite.applySubtreeWrite_(fb.core.util.Path.Empty, this.writeTree_, node);
+};
+fb.core.CompoundWrite.applySubtreeWrite_ = function(relativePath, writeTree, node) {
+  if (writeTree.value != null) {
+    return node.updateChild(relativePath, writeTree.value);
+  } else {
+    var priorityWrite = null;
+    writeTree.children.inorderTraversal(function(childKey, childTree) {
+      if (childKey === ".priority") {
+        fb.core.util.assert(childTree.value !== null, "Priority writes must always be leaf nodes");
+        priorityWrite = childTree.value;
+      } else {
+        node = fb.core.CompoundWrite.applySubtreeWrite_(relativePath.child(childKey), childTree, node);
+      }
+    });
+    if (!node.getChild(relativePath).isEmpty() && priorityWrite !== null) {
+      node = node.updateChild(relativePath.child(".priority"), (priorityWrite));
+    }
+    return node;
+  }
+};
+goog.provide("fb.core.WriteTree");
+goog.require("fb.core.CompoundWrite");
+goog.require("fb.core.util");
+goog.require("fb.core.view.CacheNode");
+fb.core.WriteRecord;
+fb.core.WriteTree = function() {
+  this.visibleWrites_ = (fb.core.CompoundWrite.Empty);
+  this.allWrites_ = [];
+  this.lastWriteId_ = -1;
+};
+fb.core.WriteTree.prototype.childWrites = function(path) {
+  return new fb.core.WriteTreeRef(path, this);
+};
+fb.core.WriteTree.prototype.addOverwrite = function(path, snap, writeId, visible) {
+  fb.core.util.assert(writeId > this.lastWriteId_, "Stacking an older write on top of newer ones");
+  if (!goog.isDef(visible)) {
+    visible = true;
+  }
+  this.allWrites_.push({path:path, snap:snap, writeId:writeId, visible:visible});
+  if (visible) {
+    this.visibleWrites_ = this.visibleWrites_.addWrite(path, snap);
+  }
+  this.lastWriteId_ = writeId;
+};
+fb.core.WriteTree.prototype.addMerge = function(path, changedChildren, writeId) {
+  fb.core.util.assert(writeId > this.lastWriteId_, "Stacking an older merge on top of newer ones");
+  this.allWrites_.push({path:path, children:changedChildren, writeId:writeId, visible:true});
+  this.visibleWrites_ = this.visibleWrites_.addWrites(path, changedChildren);
+  this.lastWriteId_ = writeId;
+};
+fb.core.WriteTree.prototype.removeWrite = function(writeId) {
+  var idx = goog.array.findIndex(this.allWrites_, function(s) {
+    return s.writeId === writeId;
+  });
+  fb.core.util.assert(idx >= 0, "removeWrite called with nonexistent writeId.");
+  var writeToRemove = this.allWrites_[idx];
+  this.allWrites_.splice(idx, 1);
+  var removedWriteWasVisible = writeToRemove.visible;
+  var removedWriteOverlapsWithOtherWrites = false;
+  var i = this.allWrites_.length - 1;
+  while (removedWriteWasVisible && i >= 0) {
+    var currentWrite = this.allWrites_[i];
+    if (currentWrite.visible) {
+      if (i >= idx && this.recordContainsPath_(currentWrite, writeToRemove.path)) {
+        removedWriteWasVisible = false;
+      } else {
+        if (writeToRemove.path.contains(currentWrite.path)) {
+          removedWriteOverlapsWithOtherWrites = true;
+        }
+      }
+    }
+    i--;
+  }
+  if (!removedWriteWasVisible) {
+    return null;
+  } else {
+    if (removedWriteOverlapsWithOtherWrites) {
+      this.resetTree_();
+      return writeToRemove.path;
+    } else {
+      if (writeToRemove.snap) {
+        this.visibleWrites_ = this.visibleWrites_.removeWrite(writeToRemove.path);
+      } else {
+        var children = writeToRemove.children;
+        var self = this;
+        goog.object.forEach(children, function(childSnap, childName) {
+          self.visibleWrites_ = self.visibleWrites_.removeWrite(writeToRemove.path.child(childName));
+        });
+      }
+      return writeToRemove.path;
+    }
+  }
+};
+fb.core.WriteTree.prototype.getCompleteWriteData = function(path) {
+  return this.visibleWrites_.getCompleteNode(path);
+};
+fb.core.WriteTree.prototype.calcCompleteEventCache = function(treePath, completeServerCache, writeIdsToExclude, includeHiddenWrites) {
+  if (!writeIdsToExclude && !includeHiddenWrites) {
+    var shadowingNode = this.visibleWrites_.getCompleteNode(treePath);
+    if (shadowingNode != null) {
+      return shadowingNode;
+    } else {
+      var subMerge = this.visibleWrites_.childCompoundWrite(treePath);
+      if (subMerge.isEmpty()) {
+        return completeServerCache;
+      } else {
+        if (completeServerCache == null && !subMerge.hasCompleteWrite(fb.core.util.Path.Empty)) {
+          return null;
+        } else {
+          var layeredCache = completeServerCache || fb.core.snap.EMPTY_NODE;
+          return subMerge.apply(layeredCache);
+        }
+      }
+    }
+  } else {
+    var merge = this.visibleWrites_.childCompoundWrite(treePath);
+    if (!includeHiddenWrites && merge.isEmpty()) {
+      return completeServerCache;
+    } else {
+      if (!includeHiddenWrites && completeServerCache == null && !merge.hasCompleteWrite(fb.core.util.Path.Empty)) {
+        return null;
+      } else {
+        var filter = function(write) {
+          return(write.visible || includeHiddenWrites) && (!writeIdsToExclude || !goog.array.contains(writeIdsToExclude, write.writeId)) && (write.path.contains(treePath) || treePath.contains(write.path));
+        };
+        var mergeAtPath = fb.core.WriteTree.layerTree_(this.allWrites_, filter, treePath);
+        layeredCache = completeServerCache || fb.core.snap.EMPTY_NODE;
+        return mergeAtPath.apply(layeredCache);
+      }
+    }
+  }
+};
+fb.core.WriteTree.prototype.calcCompleteEventChildren = function(treePath, completeServerChildren) {
+  var completeChildren = fb.core.snap.EMPTY_NODE;
+  var topLevelSet = this.visibleWrites_.getCompleteNode(treePath);
+  if (topLevelSet) {
+    if (!topLevelSet.isLeafNode()) {
+      topLevelSet.forEachChild(fb.core.snap.PriorityIndex, function(childName, childSnap) {
+        completeChildren = completeChildren.updateImmediateChild(childName, childSnap);
+      });
+    }
+    return completeChildren;
+  } else {
+    if (completeServerChildren) {
+      var merge = this.visibleWrites_.childCompoundWrite(treePath);
+      completeServerChildren.forEachChild(fb.core.snap.PriorityIndex, function(childName, childNode) {
+        var node = merge.childCompoundWrite(new fb.core.util.Path(childName)).apply(childNode);
+        completeChildren = completeChildren.updateImmediateChild(childName, node);
+      });
+      goog.array.forEach(merge.getCompleteChildren(), function(namedNode) {
+        completeChildren = completeChildren.updateImmediateChild(namedNode.name, namedNode.node);
+      });
+      return completeChildren;
+    } else {
+      merge = this.visibleWrites_.childCompoundWrite(treePath);
+      goog.array.forEach(merge.getCompleteChildren(), function(namedNode) {
+        completeChildren = completeChildren.updateImmediateChild(namedNode.name, namedNode.node);
+      });
+      return completeChildren;
+    }
+  }
+};
+fb.core.WriteTree.prototype.calcEventCacheAfterServerOverwrite = function(treePath, childPath, existingEventSnap, existingServerSnap) {
+  fb.core.util.assert(existingEventSnap || existingServerSnap, "Either existingEventSnap or existingServerSnap must exist");
+  var path = treePath.child(childPath);
+  if (this.visibleWrites_.hasCompleteWrite(path)) {
+    return null;
+  } else {
+    var childMerge = this.visibleWrites_.childCompoundWrite(path);
+    if (childMerge.isEmpty()) {
+      return existingServerSnap.getChild(childPath);
+    } else {
+      return childMerge.apply(existingServerSnap.getChild(childPath));
+    }
+  }
+};
+fb.core.WriteTree.prototype.calcCompleteChild = function(treePath, childKey, existingServerSnap) {
+  var path = treePath.child(childKey);
+  var shadowingNode = this.visibleWrites_.getCompleteNode(path);
+  if (shadowingNode != null) {
+    return shadowingNode;
+  } else {
+    if (existingServerSnap.isCompleteForChild(childKey)) {
+      var childMerge = this.visibleWrites_.childCompoundWrite(path);
+      return childMerge.apply(existingServerSnap.getNode().getImmediateChild(childKey));
+    } else {
+      return null;
+    }
+  }
+};
+fb.core.WriteTree.prototype.shadowingWrite = function(path) {
+  return this.visibleWrites_.getCompleteNode(path);
+};
+fb.core.WriteTree.prototype.calcIndexedSlice = function(treePath, completeServerData, startPost, count, reverse, index) {
+  var toIterate;
+  var merge = this.visibleWrites_.childCompoundWrite(treePath);
+  var shadowingNode = merge.getCompleteNode(fb.core.util.Path.Empty);
+  if (shadowingNode != null) {
+    toIterate = shadowingNode;
+  } else {
+    if (completeServerData != null) {
+      toIterate = merge.apply(completeServerData);
+    } else {
+      return[];
+    }
+  }
+  toIterate = toIterate.withIndex(index);
+  if (!toIterate.isEmpty() && !toIterate.isLeafNode()) {
+    var nodes = [];
+    var cmp = index.getCompare();
+    var iter = reverse ? toIterate.getReverseIteratorFrom(startPost, index) : toIterate.getIteratorFrom(startPost, index);
+    var next = iter.getNext();
+    while (next && nodes.length < count) {
+      if (cmp(next, startPost) !== 0) {
+        nodes.push(next);
+      }
+      next = iter.getNext();
+    }
+    return nodes;
+  } else {
+    return[];
+  }
+};
+fb.core.WriteTree.prototype.recordContainsPath_ = function(writeRecord, path) {
+  if (writeRecord.snap) {
+    return writeRecord.path.contains(path);
+  } else {
+    return!!goog.object.findKey(writeRecord.children, function(childSnap, childName) {
+      return writeRecord.path.child(childName).contains(path);
+    });
+  }
+};
+fb.core.WriteTree.prototype.resetTree_ = function() {
+  this.visibleWrites_ = fb.core.WriteTree.layerTree_(this.allWrites_, fb.core.WriteTree.DefaultFilter_, fb.core.util.Path.Empty);
+  if (this.allWrites_.length > 0) {
+    this.lastWriteId_ = this.allWrites_[this.allWrites_.length - 1].writeId;
+  } else {
+    this.lastWriteId_ = -1;
+  }
+};
+fb.core.WriteTree.DefaultFilter_ = function(write) {
+  return write.visible;
+};
+fb.core.WriteTree.layerTree_ = function(writes, filter, treeRoot) {
+  var compoundWrite = fb.core.CompoundWrite.Empty;
+  for (var i = 0;i < writes.length;++i) {
+    var write = writes[i];
+    if (filter(write)) {
+      var writePath = write.path;
+      var relativePath;
+      if (write.snap) {
+        if (treeRoot.contains(writePath)) {
+          relativePath = fb.core.util.Path.relativePath(treeRoot, writePath);
+          compoundWrite = compoundWrite.addWrite(relativePath, write.snap);
+        } else {
+          if (writePath.contains(treeRoot)) {
+            relativePath = fb.core.util.Path.relativePath(writePath, treeRoot);
+            compoundWrite = compoundWrite.addWrite(fb.core.util.Path.Empty, write.snap.getChild(relativePath));
+          } else {
+          }
+        }
+      } else {
+        if (write.children) {
+          if (treeRoot.contains(writePath)) {
+            relativePath = fb.core.util.Path.relativePath(treeRoot, writePath);
+            compoundWrite = compoundWrite.addWrites(relativePath, write.children);
+          } else {
+            if (writePath.contains(treeRoot)) {
+              relativePath = fb.core.util.Path.relativePath(writePath, treeRoot);
+              if (relativePath.isEmpty()) {
+                compoundWrite = compoundWrite.addWrites(fb.core.util.Path.Empty, write.children);
+              } else {
+                var child = fb.util.obj.get(write.children, relativePath.getFront());
+                if (child) {
+                  var deepNode = child.getChild(relativePath.popFront());
+                  compoundWrite = compoundWrite.addWrite(fb.core.util.Path.Empty, deepNode);
+                }
+              }
+            } else {
+            }
+          }
+        } else {
+          throw fb.core.util.assertionError("WriteRecord should have .snap or .children");
+        }
+      }
+    }
+  }
+  return compoundWrite;
+};
+fb.core.WriteTreeRef = function(path, writeTree) {
+  this.treePath_ = path;
+  this.writeTree_ = writeTree;
+};
+fb.core.WriteTreeRef.prototype.calcCompleteEventCache = function(completeServerCache, writeIdsToExclude, includeHiddenWrites) {
+  return this.writeTree_.calcCompleteEventCache(this.treePath_, completeServerCache, writeIdsToExclude, includeHiddenWrites);
+};
+fb.core.WriteTreeRef.prototype.calcCompleteEventChildren = function(completeServerChildren) {
+  return this.writeTree_.calcCompleteEventChildren(this.treePath_, completeServerChildren);
+};
+fb.core.WriteTreeRef.prototype.calcEventCacheAfterServerOverwrite = function(path, existingEventSnap, existingServerSnap) {
+  return this.writeTree_.calcEventCacheAfterServerOverwrite(this.treePath_, path, existingEventSnap, existingServerSnap);
+};
+fb.core.WriteTreeRef.prototype.shadowingWrite = function(path) {
+  return this.writeTree_.shadowingWrite(this.treePath_.child(path));
+};
+fb.core.WriteTreeRef.prototype.calcIndexedSlice = function(completeServerData, startPost, count, reverse, index) {
+  return this.writeTree_.calcIndexedSlice(this.treePath_, completeServerData, startPost, count, reverse, index);
+};
+fb.core.WriteTreeRef.prototype.calcCompleteChild = function(childKey, existingServerCache) {
+  return this.writeTree_.calcCompleteChild(this.treePath_, childKey, existingServerCache);
+};
+fb.core.WriteTreeRef.prototype.child = function(childName) {
+  return new fb.core.WriteTreeRef(this.treePath_.child(childName), this.writeTree_);
+};
+goog.provide("fb.core.SyncPoint");
+goog.require("fb.core.util");
+goog.require("fb.core.util.ImmutableTree");
+goog.require("fb.core.view.ViewCache");
+goog.require("fb.core.view.EventRegistration");
+goog.require("fb.core.view.View");
+goog.require("goog.array");
+fb.core.SyncPoint = function() {
+  this.views_ = {};
+};
+fb.core.SyncPoint.prototype.isEmpty = function() {
+  return goog.object.isEmpty(this.views_);
+};
+fb.core.SyncPoint.prototype.applyOperation = function(operation, writesCache, optCompleteServerCache) {
+  var queryId = operation.source.queryId;
+  if (queryId !== null) {
+    var view = fb.util.obj.get(this.views_, queryId);
+    fb.core.util.assert(view != null, "SyncTree gave us an op for an invalid query.");
+    return view.applyOperation(operation, writesCache, optCompleteServerCache);
+  } else {
+    var events = [];
+    goog.object.forEach(this.views_, function(view) {
+      events = events.concat(view.applyOperation(operation, writesCache, optCompleteServerCache));
+    });
+    return events;
+  }
+};
+fb.core.SyncPoint.prototype.addEventRegistration = function(query, eventRegistration, writesCache, serverCache, serverCacheComplete) {
+  var queryId = query.queryIdentifier();
+  var view = fb.util.obj.get(this.views_, queryId);
+  if (!view) {
+    var eventCache = writesCache.calcCompleteEventCache(serverCacheComplete ? serverCache : null);
+    var eventCacheComplete = false;
+    if (eventCache) {
+      eventCacheComplete = true;
+    } else {
+      if (serverCache instanceof fb.core.snap.ChildrenNode) {
+        eventCache = writesCache.calcCompleteEventChildren(serverCache);
+        eventCacheComplete = false;
+      } else {
+        eventCache = fb.core.snap.EMPTY_NODE;
+        eventCacheComplete = false;
+      }
+    }
+    var viewCache = new fb.core.view.ViewCache(new fb.core.view.CacheNode((eventCache), eventCacheComplete, false), new fb.core.view.CacheNode((serverCache), serverCacheComplete, false));
+    view = new fb.core.view.View(query, viewCache);
+    this.views_[queryId] = view;
+  }
+  view.addEventRegistration(eventRegistration);
+  return view.getInitialEvents(eventRegistration);
+};
+fb.core.SyncPoint.prototype.removeEventRegistration = function(query, eventRegistration, cancelError) {
+  var queryId = query.queryIdentifier();
+  var removed = [];
+  var cancelEvents = [];
+  var hadCompleteView = this.hasCompleteView();
+  if (queryId === "default") {
+    var self = this;
+    goog.object.forEach(this.views_, function(view, viewQueryId) {
+      cancelEvents = cancelEvents.concat(view.removeEventRegistration(eventRegistration, cancelError));
+      if (view.isEmpty()) {
+        delete self.views_[viewQueryId];
+        if (!view.getQuery().getQueryParams().loadsAllData()) {
+          removed.push(view.getQuery());
+        }
+      }
+    });
+  } else {
+    var view = fb.util.obj.get(this.views_, queryId);
+    if (view) {
+      cancelEvents = cancelEvents.concat(view.removeEventRegistration(eventRegistration, cancelError));
+      if (view.isEmpty()) {
+        delete this.views_[queryId];
+        if (!view.getQuery().getQueryParams().loadsAllData()) {
+          removed.push(view.getQuery());
+        }
+      }
+    }
+  }
+  if (hadCompleteView && !this.hasCompleteView()) {
+    removed.push(new Firebase(query.repo, query.path));
+  }
+  return{removed:removed, events:cancelEvents};
+};
+fb.core.SyncPoint.prototype.getQueryViews = function() {
+  return goog.array.filter(goog.object.getValues(this.views_), function(view) {
+    return!view.getQuery().getQueryParams().loadsAllData();
+  });
+};
+fb.core.SyncPoint.prototype.getCompleteServerCache = function(path) {
+  var serverCache = null;
+  goog.object.forEach(this.views_, function(view) {
+    serverCache = serverCache || view.getCompleteServerCache(path);
+  });
+  return serverCache;
+};
+fb.core.SyncPoint.prototype.viewForQuery = function(query) {
+  var params = query.getQueryParams();
+  if (params.loadsAllData()) {
+    return this.getCompleteView();
+  } else {
+    var queryId = query.queryIdentifier();
+    return fb.util.obj.get(this.views_, queryId);
+  }
+};
+fb.core.SyncPoint.prototype.viewExistsForQuery = function(query) {
+  return this.viewForQuery(query) != null;
+};
+fb.core.SyncPoint.prototype.hasCompleteView = function() {
+  return this.getCompleteView() != null;
+};
+fb.core.SyncPoint.prototype.getCompleteView = function() {
+  var completeView = goog.object.findValue(this.views_, function(view) {
+    return view.getQuery().getQueryParams().loadsAllData();
+  });
+  return completeView || null;
+};
+goog.provide("fb.core.SyncTree");
+goog.require("fb.core.Operation");
+goog.require("fb.core.SyncPoint");
+goog.require("fb.core.WriteTree");
+goog.require("fb.core.util");
+fb.core.ListenProvider;
+fb.core.SyncTree = function(listenProvider) {
+  this.syncPointTree_ = fb.core.util.ImmutableTree.Empty;
+  this.pendingWriteTree_ = new fb.core.WriteTree;
+  this.tagToQueryMap_ = {};
+  this.queryToTagMap_ = {};
+  this.listenProvider_ = listenProvider;
+};
+fb.core.SyncTree.prototype.applyUserOverwrite = function(path, newData, writeId, visible) {
+  this.pendingWriteTree_.addOverwrite(path, newData, writeId, visible);
+  if (!visible) {
+    return[];
+  } else {
+    return this.applyOperationToSyncPoints_(new fb.core.operation.Overwrite(fb.core.OperationSource.User, path, newData));
+  }
+};
+fb.core.SyncTree.prototype.applyUserMerge = function(path, changedChildren, writeId) {
+  this.pendingWriteTree_.addMerge(path, changedChildren, writeId);
+  var changeTree = fb.core.util.ImmutableTree.fromObject(changedChildren);
+  return this.applyOperationToSyncPoints_(new fb.core.operation.Merge(fb.core.OperationSource.User, path, changeTree));
+};
+fb.core.SyncTree.prototype.ackUserWrite = function(writeId, revert) {
+  revert = revert || false;
+  var pathToReevaluate = this.pendingWriteTree_.removeWrite(writeId);
+  if (pathToReevaluate == null) {
+    return[];
+  } else {
+    return this.applyOperationToSyncPoints_(new fb.core.operation.AckUserWrite(pathToReevaluate, revert));
+  }
+};
+fb.core.SyncTree.prototype.applyServerOverwrite = function(path, newData) {
+  return this.applyOperationToSyncPoints_(new fb.core.operation.Overwrite(fb.core.OperationSource.Server, path, newData));
+};
+fb.core.SyncTree.prototype.applyServerMerge = function(path, changedChildren) {
+  var changeTree = fb.core.util.ImmutableTree.fromObject(changedChildren);
+  return this.applyOperationToSyncPoints_(new fb.core.operation.Merge(fb.core.OperationSource.Server, path, changeTree));
+};
+fb.core.SyncTree.prototype.applyListenComplete = function(path) {
+  return this.applyOperationToSyncPoints_(new fb.core.operation.ListenComplete(fb.core.OperationSource.Server, path));
+};
+fb.core.SyncTree.prototype.applyTaggedQueryOverwrite = function(path, snap, tag) {
+  var queryKey = this.queryKeyForTag_(tag);
+  if (queryKey != null) {
+    var r = this.parseQueryKey_(queryKey);
+    var queryPath = r.path, queryId = r.queryId;
+    var relativePath = fb.core.util.Path.relativePath(queryPath, path);
+    var op = new fb.core.operation.Overwrite(fb.core.OperationSource.forServerTaggedQuery(queryId), relativePath, snap);
+    return this.applyTaggedOperation_(queryPath, queryId, op);
+  } else {
+    return[];
+  }
+};
+fb.core.SyncTree.prototype.applyTaggedQueryMerge = function(path, changedChildren, tag) {
+  var queryKey = this.queryKeyForTag_(tag);
+  if (queryKey) {
+    var r = this.parseQueryKey_(queryKey);
+    var queryPath = r.path, queryId = r.queryId;
+    var relativePath = fb.core.util.Path.relativePath(queryPath, path);
+    var changeTree = fb.core.util.ImmutableTree.fromObject(changedChildren);
+    var op = new fb.core.operation.Merge(fb.core.OperationSource.forServerTaggedQuery(queryId), relativePath, changeTree);
+    return this.applyTaggedOperation_(queryPath, queryId, op);
+  } else {
+    return[];
+  }
+};
+fb.core.SyncTree.prototype.applyTaggedListenComplete = function(path, tag) {
+  var queryKey = this.queryKeyForTag_(tag);
+  if (queryKey) {
+    var r = this.parseQueryKey_(queryKey);
+    var queryPath = r.path, queryId = r.queryId;
+    var relativePath = fb.core.util.Path.relativePath(queryPath, path);
+    var op = new fb.core.operation.ListenComplete(fb.core.OperationSource.forServerTaggedQuery(queryId), relativePath);
+    return this.applyTaggedOperation_(queryPath, queryId, op);
+  } else {
+    return[];
+  }
+};
+fb.core.SyncTree.prototype.addEventRegistration = function(query, eventRegistration) {
+  var path = query.path;
+  var serverCache = null;
+  var foundAncestorDefaultView = false;
+  this.syncPointTree_.foreachOnPathWhile(path, function(pathToSyncPoint, sp) {
+    var relativePath = fb.core.util.Path.relativePath(pathToSyncPoint, path);
+    serverCache = sp.getCompleteServerCache(relativePath);
+    foundAncestorDefaultView = foundAncestorDefaultView || sp.hasCompleteView();
+    return!serverCache;
+  });
+  var syncPoint = this.syncPointTree_.get(path);
+  if (!syncPoint) {
+    syncPoint = new fb.core.SyncPoint;
+    this.syncPointTree_ = this.syncPointTree_.set(path, syncPoint);
+  } else {
+    foundAncestorDefaultView = foundAncestorDefaultView || syncPoint.hasCompleteView();
+    serverCache = serverCache || syncPoint.getCompleteServerCache(fb.core.util.Path.Empty);
+  }
+  var serverCacheComplete;
+  if (serverCache != null) {
+    serverCacheComplete = true;
+  } else {
+    serverCacheComplete = false;
+    serverCache = fb.core.snap.EMPTY_NODE;
+    var subtree = this.syncPointTree_.subtree(path);
+    subtree.foreachChild(function(childName, childSyncPoint) {
+      var completeCache = childSyncPoint.getCompleteServerCache(fb.core.util.Path.Empty);
+      if (completeCache) {
+        serverCache = serverCache.updateImmediateChild(childName, completeCache);
+      }
+    });
+  }
+  var viewAlreadyExists = syncPoint.viewExistsForQuery(query);
+  if (!viewAlreadyExists && !query.getQueryParams().loadsAllData()) {
+    var queryKey = this.makeQueryKey_(query);
+    fb.core.util.assert(!goog.object.containsKey(this.queryToTagMap_, queryKey), "View does not exist, but we have a tag");
+    var tag = fb.core.SyncTree.getNextQueryTag_();
+    this.queryToTagMap_[queryKey] = tag;
+    this.tagToQueryMap_["_" + tag] = queryKey;
+  }
+  var writesCache = this.pendingWriteTree_.childWrites(path);
+  var events = syncPoint.addEventRegistration(query, eventRegistration, writesCache, serverCache, serverCacheComplete);
+  if (!viewAlreadyExists && !foundAncestorDefaultView) {
+    var view = (syncPoint.viewForQuery(query));
+    events = events.concat(this.setupListener_(query, view));
+  }
+  return events;
+};
+fb.core.SyncTree.prototype.removeEventRegistration = function(query, eventRegistration, cancelError) {
+  var path = query.path;
+  var maybeSyncPoint = this.syncPointTree_.get(path);
+  var cancelEvents = [];
+  if (maybeSyncPoint && (query.queryIdentifier() === "default" || maybeSyncPoint.viewExistsForQuery(query))) {
+    var removedAndEvents = maybeSyncPoint.removeEventRegistration(query, eventRegistration, cancelError);
+    if (maybeSyncPoint.isEmpty()) {
+      this.syncPointTree_ = this.syncPointTree_.remove(path);
+    }
+    var removed = removedAndEvents.removed;
+    cancelEvents = removedAndEvents.events;
+    var removingDefault = -1 !== goog.array.findIndex(removed, function(query) {
+      return query.getQueryParams().loadsAllData();
+    });
+    var covered = this.syncPointTree_.findOnPath(path, function(relativePath, parentSyncPoint) {
+      return parentSyncPoint.hasCompleteView();
+    });
+    if (removingDefault && !covered) {
+      var subtree = this.syncPointTree_.subtree(path);
+      if (!subtree.isEmpty()) {
+        var newViews = this.collectDistinctViewsForSubTree_(subtree);
+        for (var i = 0;i < newViews.length;++i) {
+          var view = newViews[i], newQuery = view.getQuery();
+          var listener = this.createListenerForView_(view);
+          this.listenProvider_.startListening(newQuery, this.tagForQuery_(newQuery), listener.hashFn, listener.onComplete);
+        }
+      } else {
+      }
+    }
+    if (!covered && removed.length > 0 && !cancelError) {
+      if (removingDefault) {
+        var defaultTag = null;
+        this.listenProvider_.stopListening(query, defaultTag);
+      } else {
+        var self = this;
+        goog.array.forEach(removed, function(queryToRemove) {
+          var queryIdToRemove = queryToRemove.queryIdentifier();
+          var tagToRemove = self.queryToTagMap_[self.makeQueryKey_(queryToRemove)];
+          self.listenProvider_.stopListening(queryToRemove, tagToRemove);
+        });
+      }
+    }
+    this.removeTags_(removed);
+  } else {
+  }
+  return cancelEvents;
+};
+fb.core.SyncTree.prototype.calcCompleteEventCache = function(path, writeIdsToExclude) {
+  var includeHiddenSets = true;
+  var writeTree = this.pendingWriteTree_;
+  var serverCache = this.syncPointTree_.findOnPath(path, function(pathSoFar, syncPoint) {
+    var relativePath = fb.core.util.Path.relativePath(pathSoFar, path);
+    var serverCache = syncPoint.getCompleteServerCache(relativePath);
+    if (serverCache) {
+      return serverCache;
+    }
+  });
+  return writeTree.calcCompleteEventCache(path, serverCache, writeIdsToExclude, includeHiddenSets);
+};
+fb.core.SyncTree.prototype.collectDistinctViewsForSubTree_ = function(subtree) {
+  return subtree.fold(function(relativePath, maybeChildSyncPoint, childMap) {
+    if (maybeChildSyncPoint && maybeChildSyncPoint.hasCompleteView()) {
+      var completeView = maybeChildSyncPoint.getCompleteView();
+      return[completeView];
+    } else {
+      var views = [];
+      if (maybeChildSyncPoint) {
+        views = maybeChildSyncPoint.getQueryViews();
+      }
+      goog.object.forEach(childMap, function(childViews) {
+        views = views.concat(childViews);
+      });
+      return views;
+    }
+  });
+};
+fb.core.SyncTree.prototype.removeTags_ = function(queries) {
+  for (var j = 0;j < queries.length;++j) {
+    var removedQuery = queries[j];
+    if (!removedQuery.getQueryParams().loadsAllData()) {
+      var removedQueryKey = this.makeQueryKey_(removedQuery);
+      var removedQueryTag = this.queryToTagMap_[removedQueryKey];
+      delete this.queryToTagMap_[removedQueryKey];
+      delete this.tagToQueryMap_["_" + removedQueryTag];
+    }
+  }
+};
+fb.core.SyncTree.prototype.setupListener_ = function(query, view) {
+  var path = query.path;
+  var tag = this.tagForQuery_(query);
+  var listener = this.createListenerForView_(view);
+  var events = this.listenProvider_.startListening(query, tag, listener.hashFn, listener.onComplete);
+  var subtree = this.syncPointTree_.subtree(path);
+  if (tag) {
+    fb.core.util.assert(!subtree.value.hasCompleteView(), "If we're adding a query, it shouldn't be shadowed");
+  } else {
+    var queriesToStop = subtree.fold(function(relativePath, maybeChildSyncPoint, childMap) {
+      if (!relativePath.isEmpty() && maybeChildSyncPoint && maybeChildSyncPoint.hasCompleteView()) {
+        return[maybeChildSyncPoint.getCompleteView().getQuery()];
+      } else {
+        var queries = [];
+        if (maybeChildSyncPoint) {
+          queries = queries.concat(goog.array.map(maybeChildSyncPoint.getQueryViews(), function(view) {
+            return view.getQuery();
+          }));
+        }
+        goog.object.forEach(childMap, function(childQueries) {
+          queries = queries.concat(childQueries);
+        });
+        return queries;
+      }
+    });
+    for (var i = 0;i < queriesToStop.length;++i) {
+      var queryToStop = queriesToStop[i];
+      this.listenProvider_.stopListening(queryToStop, this.tagForQuery_(queryToStop));
+    }
+  }
+  return events;
+};
+fb.core.SyncTree.prototype.createListenerForView_ = function(view) {
+  var self = this;
+  var query = view.getQuery();
+  var tag = this.tagForQuery_(query);
+  return{hashFn:function() {
+    var cache = view.getServerCache() || fb.core.snap.EMPTY_NODE;
+    return cache.hash();
+  }, onComplete:function(status, data) {
+    if (status === "ok") {
+      if (tag) {
+        return self.applyTaggedListenComplete(query.path, tag);
+      } else {
+        return self.applyListenComplete(query.path);
+      }
+    } else {
+      var error = fb.core.util.errorForServerCode(status);
+      return self.removeEventRegistration(query, null, error);
+    }
+  }};
+};
+fb.core.SyncTree.prototype.makeQueryKey_ = function(query) {
+  return query.path.toString() + "$" + query.queryIdentifier();
+};
+fb.core.SyncTree.prototype.parseQueryKey_ = function(queryKey) {
+  var splitIndex = queryKey.indexOf("$");
+  fb.core.util.assert(splitIndex !== -1 && splitIndex < queryKey.length - 1, "Bad queryKey.");
+  return{queryId:queryKey.substr(splitIndex + 1), path:new fb.core.util.Path(queryKey.substr(0, splitIndex))};
+};
+fb.core.SyncTree.prototype.queryKeyForTag_ = function(tag) {
+  return goog.object.get(this.tagToQueryMap_, "_" + tag);
+};
+fb.core.SyncTree.prototype.tagForQuery_ = function(query) {
+  var queryKey = this.makeQueryKey_(query);
+  return fb.util.obj.get(this.queryToTagMap_, queryKey);
+};
+fb.core.SyncTree.nextQueryTag_ = 1;
+fb.core.SyncTree.getNextQueryTag_ = function() {
+  return fb.core.SyncTree.nextQueryTag_++;
+};
+fb.core.SyncTree.prototype.applyTaggedOperation_ = function(queryPath, queryId, operation) {
+  var syncPoint = this.syncPointTree_.get(queryPath);
+  fb.core.util.assert(syncPoint, "Missing sync point for query tag that we're tracking");
+  var writesCache = this.pendingWriteTree_.childWrites(queryPath);
+  return syncPoint.applyOperation(operation, writesCache, null);
+};
+fb.core.SyncTree.prototype.applyOperationToSyncPoints_ = function(operation) {
+  return this.applyOperationHelper_(operation, this.syncPointTree_, null, this.pendingWriteTree_.childWrites(fb.core.util.Path.Empty));
+};
+fb.core.SyncTree.prototype.applyOperationHelper_ = function(operation, syncPointTree, serverCache, writesCache) {
+  if (operation.path.isEmpty()) {
+    return this.applyOperationDescendantsHelper_(operation, syncPointTree, serverCache, writesCache);
+  } else {
+    var syncPoint = syncPointTree.get(fb.core.util.Path.Empty);
+    if (serverCache == null && syncPoint != null) {
+      serverCache = syncPoint.getCompleteServerCache(fb.core.util.Path.Empty);
+    }
+    var events = [];
+    var childName = operation.path.getFront();
+    var childOperation = operation.operationForChild(childName);
+    var childTree = syncPointTree.children.get(childName);
+    if (childTree && childOperation) {
+      var childServerCache = serverCache ? serverCache.getImmediateChild(childName) : null;
+      var childWritesCache = writesCache.child(childName);
+      events = events.concat(this.applyOperationHelper_(childOperation, childTree, childServerCache, childWritesCache));
+    }
+    if (syncPoint) {
+      events = events.concat(syncPoint.applyOperation(operation, writesCache, serverCache));
+    }
+    return events;
+  }
+};
+fb.core.SyncTree.prototype.applyOperationDescendantsHelper_ = function(operation, syncPointTree, serverCache, writesCache) {
+  var syncPoint = syncPointTree.get(fb.core.util.Path.Empty);
+  if (serverCache == null && syncPoint != null) {
+    serverCache = syncPoint.getCompleteServerCache(fb.core.util.Path.Empty);
+  }
+  var events = [];
+  var self = this;
+  syncPointTree.children.inorderTraversal(function(childName, childTree) {
+    var childServerCache = serverCache ? serverCache.getImmediateChild(childName) : null;
+    var childWritesCache = writesCache.child(childName);
+    var childOperation = operation.operationForChild(childName);
+    if (childOperation) {
+      events = events.concat(self.applyOperationDescendantsHelper_(childOperation, childTree, childServerCache, childWritesCache));
+    }
+  });
+  if (syncPoint) {
+    events = events.concat(syncPoint.applyOperation(operation, writesCache, serverCache));
+  }
+  return events;
+};
+goog.provide("fb.core.util.Tree");
+goog.require("fb.core.util");
+goog.require("fb.core.util.Path");
+goog.require("fb.util.obj");
+goog.require("goog.object");
+fb.core.util.TreeNode = goog.defineClass(null, {constructor:function() {
+  this.children = {};
+  this.childCount = 0;
+  this.value = null;
+}});
+fb.core.util.Tree = goog.defineClass(null, {constructor:function(opt_name, opt_parent, opt_node) {
+  this.name_ = opt_name ? opt_name : "";
+  this.parent_ = opt_parent ? opt_parent : null;
+  this.node_ = opt_node ? opt_node : new fb.core.util.TreeNode;
+}, subTree:function(pathObj) {
+  var path = pathObj instanceof fb.core.util.Path ? pathObj : new fb.core.util.Path(pathObj);
+  var child = this, next;
+  while ((next = path.getFront()) !== null) {
+    var childNode = fb.util.obj.get(child.node_.children, next) || new fb.core.util.TreeNode;
+    child = new fb.core.util.Tree(next, child, childNode);
+    path = path.popFront();
+  }
+  return child;
+}, getValue:function() {
+  return this.node_.value;
+}, setValue:function(value) {
+  fb.core.util.assert(typeof value !== "undefined", "Cannot set value to undefined");
+  this.node_.value = value;
+  this.updateParents_();
+}, clear:function() {
+  this.node_.value = null;
+  this.node_.children = {};
+  this.node_.childCount = 0;
+  this.updateParents_();
+}, hasChildren:function() {
+  return this.node_.childCount > 0;
+}, isEmpty:function() {
+  return this.getValue() === null && !this.hasChildren();
+}, forEachChild:function(action) {
+  var self = this;
+  goog.object.forEach(this.node_.children, function(childTree, child) {
+    action(new fb.core.util.Tree(child, self, childTree));
+  });
+}, forEachDescendant:function(action, opt_includeSelf, opt_childrenFirst) {
+  if (opt_includeSelf && !opt_childrenFirst) {
+    action(this);
+  }
+  this.forEachChild(function(child) {
+    child.forEachDescendant(action, true, opt_childrenFirst);
+  });
+  if (opt_includeSelf && opt_childrenFirst) {
+    action(this);
+  }
+}, forEachAncestor:function(action, opt_includeSelf) {
+  var node = opt_includeSelf ? this : this.parent();
+  while (node !== null) {
+    if (action(node)) {
+      return true;
+    }
+    node = node.parent();
+  }
+  return false;
+}, forEachImmediateDescendantWithValue:function(action) {
+  this.forEachChild(function(child) {
+    if (child.getValue() !== null) {
+      action(child);
+    } else {
+      child.forEachImmediateDescendantWithValue(action);
+    }
+  });
+}, path:function() {
+  return new fb.core.util.Path(this.parent_ === null ? this.name_ : this.parent_.path() + "/" + this.name_);
+}, name:function() {
+  return this.name_;
+}, parent:function() {
+  return this.parent_;
+}, updateParents_:function() {
+  if (this.parent_ !== null) {
+    this.parent_.updateChild_(this.name_, this);
+  }
+}, updateChild_:function(childName, child) {
+  var childEmpty = child.isEmpty();
+  var childExists = fb.util.obj.contains(this.node_.children, childName);
+  if (childEmpty && childExists) {
+    delete this.node_.children[childName];
+    this.node_.childCount--;
+    this.updateParents_();
+  } else {
+    if (!childEmpty && !childExists) {
+      this.node_.children[childName] = child.node_;
+      this.node_.childCount++;
+      this.updateParents_();
+    }
+  }
+}});
+goog.provide("fb.core.util.EventEmitter");
+goog.require("fb.core.util");
+goog.require("goog.array");
+fb.core.util.EventEmitter = goog.defineClass(null, {constructor:function(allowedEvents) {
+  fb.core.util.assert(goog.isArray(allowedEvents) && allowedEvents.length > 0, "Requires a non-empty array");
+  this.allowedEvents_ = allowedEvents;
+  this.listeners_ = {};
+}, getInitialEvent:goog.abstractMethod, trigger:function(eventType, var_args) {
+  var listeners = this.listeners_[eventType] || [];
+  for (var i = 0;i < listeners.length;i++) {
+    listeners[i].callback.apply(listeners[i].context, Array.prototype.slice.call(arguments, 1));
+  }
+}, on:function(eventType, callback, context) {
+  this.validateEventType_(eventType);
+  this.listeners_[eventType] = this.listeners_[eventType] || [];
+  this.listeners_[eventType].push({callback:callback, context:context});
+  var eventData = this.getInitialEvent(eventType);
+  if (eventData) {
+    callback.apply(context, eventData);
+  }
+}, off:function(eventType, callback, context) {
+  this.validateEventType_(eventType);
+  var listeners = this.listeners_[eventType] || [];
+  for (var i = 0;i < listeners.length;i++) {
+    if (listeners[i].callback === callback && (!context || context === listeners[i].context)) {
+      listeners.splice(i, 1);
+      return;
+    }
+  }
+}, validateEventType_:function(eventType) {
+  fb.core.util.assert(goog.array.find(this.allowedEvents_, function(et) {
+    return et === eventType;
+  }), "Unknown event: " + eventType);
+}});
+goog.provide("fb.core.util.nextPushId");
+goog.require("fb.core.util");
+fb.core.util.nextPushId = function() {
+  var PUSH_CHARS = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
+  var lastPushTime = 0;
+  var lastRandChars = [];
+  return function(now) {
+    var duplicateTime = now === lastPushTime;
+    lastPushTime = now;
+    var timeStampChars = new Array(8);
+    for (var i = 7;i >= 0;i--) {
+      timeStampChars[i] = PUSH_CHARS.charAt(now % 64);
+      now = Math.floor(now / 64);
+    }
+    fb.core.util.assert(now === 0, "Cannot push at time == 0");
+    var id = timeStampChars.join("");
+    if (!duplicateTime) {
+      for (i = 0;i < 12;i++) {
+        lastRandChars[i] = Math.floor(Math.random() * 64);
+      }
+    } else {
+      for (i = 11;i >= 0 && lastRandChars[i] === 63;i--) {
+        lastRandChars[i] = 0;
+      }
+      lastRandChars[i]++;
+    }
+    for (i = 0;i < 12;i++) {
+      id += PUSH_CHARS.charAt(lastRandChars[i]);
+    }
+    fb.core.util.assert(id.length === 20, "nextPushId: Length should be 20.");
+    return id;
+  };
+}();
+goog.provide("fb.core.util.OnlineMonitor");
+goog.require("fb.core.util");
+goog.require("fb.core.util.EventEmitter");
+fb.core.util.OnlineMonitor = goog.defineClass(fb.core.util.EventEmitter, {constructor:function() {
+  fb.core.util.EventEmitter.call(this, ["online"]);
+  this.online_ = true;
+  if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
+    var self = this;
+    window.addEventListener("online", function() {
+      if (!self.online_) {
+        self.online_ = true;
+        self.trigger("online", true);
+      }
+    }, false);
+    window.addEventListener("offline", function() {
+      if (self.online_) {
+        self.online_ = false;
+        self.trigger("online", false);
+      }
+    }, false);
+  }
+}, getInitialEvent:function(eventType) {
+  fb.core.util.assert(eventType === "online", "Unknown event type: " + eventType);
+  return[this.online_];
+}, currentlyOnline:function() {
+  return this.online_;
+}});
+goog.addSingletonGetter(fb.core.util.OnlineMonitor);
+goog.provide("fb.core.util.VisibilityMonitor");
+goog.require("fb.core.util");
+goog.require("fb.core.util.EventEmitter");
+fb.core.util.VisibilityMonitor = goog.defineClass(fb.core.util.EventEmitter, {constructor:function() {
+  fb.core.util.EventEmitter.call(this, ["visible"]);
+  var hidden, visibilityChange;
+  if (typeof document !== "undefined" && typeof document.addEventListener !== "undefined") {
+    if (typeof document["hidden"] !== "undefined") {
+      visibilityChange = "visibilitychange";
+      hidden = "hidden";
+    } else {
+      if (typeof document["mozHidden"] !== "undefined") {
+        visibilityChange = "mozvisibilitychange";
+        hidden = "mozHidden";
+      } else {
+        if (typeof document["msHidden"] !== "undefined") {
+          visibilityChange = "msvisibilitychange";
+          hidden = "msHidden";
+        } else {
+          if (typeof document["webkitHidden"] !== "undefined") {
+            visibilityChange = "webkitvisibilitychange";
+            hidden = "webkitHidden";
+          }
+        }
+      }
+    }
+  }
+  this.visible_ = true;
+  if (visibilityChange) {
+    var self = this;
+    document.addEventListener(visibilityChange, function() {
+      var visible = !document[hidden];
+      if (visible !== self.visible_) {
+        self.visible_ = visible;
+        self.trigger("visible", visible);
+      }
+    }, false);
+  }
+}, getInitialEvent:function(eventType) {
+  fb.core.util.assert(eventType === "visible", "Unknown event type: " + eventType);
+  return[this.visible_];
+}});
+goog.addSingletonGetter(fb.core.util.VisibilityMonitor);
+goog.provide("fb.core.util.validation");
+goog.require("fb.core.util");
+goog.require("fb.core.util.Path");
+goog.require("fb.core.util.ValidationPath");
+goog.require("fb.util.obj");
+goog.require("fb.util.utf8");
+goog.require("fb.util.validation");
+fb.core.util.validation = {INVALID_KEY_REGEX_:/[\[\].#$\/\u0000-\u001F\u007F]/, INVALID_PATH_REGEX_:/[\[\].#$\u0000-\u001F\u007F]/, MAX_LEAF_SIZE_:10 * 1024 * 1024, isValidKey:function(key) {
+  return goog.isString(key) && key.length !== 0 && !fb.core.util.validation.INVALID_KEY_REGEX_.test(key);
+}, isValidPathString:function(pathString) {
+  return goog.isString(pathString) && pathString.length !== 0 && !fb.core.util.validation.INVALID_PATH_REGEX_.test(pathString);
+}, isValidRootPathString:function(pathString) {
+  if (pathString) {
+    pathString = pathString.replace(/^\/*\.info(\/|$)/, "/");
+  }
+  return fb.core.util.validation.isValidPathString(pathString);
+}, isValidPriority:function(priority) {
+  return priority === null || goog.isString(priority) || goog.isNumber(priority) && !fb.core.util.isInvalidJSONNumber(priority) || goog.isObject(priority) && fb.util.obj.contains(priority, ".sv");
+}, validateFirebaseDataArg:function(fnName, argumentNumber, data, path, optional) {
+  if (optional && !goog.isDef(data)) {
+    return;
+  }
+  fb.core.util.validation.validateFirebaseData(fb.util.validation.errorPrefix(fnName, argumentNumber, optional), data, path);
+}, validateFirebaseData:function(errorPrefix, data, path) {
+  if (path instanceof fb.core.util.Path) {
+    path = new fb.core.util.ValidationPath(path, errorPrefix);
+  }
+  if (!goog.isDef(data)) {
+    throw new Error(errorPrefix + "contains undefined " + path.toErrorString());
+  }
+  if (goog.isFunction(data)) {
+    throw new Error(errorPrefix + "contains a function " + path.toErrorString() + " with contents: " + data.toString());
+  }
+  if (fb.core.util.isInvalidJSONNumber(data)) {
+    throw new Error(errorPrefix + "contains " + data.toString() + " " + path.toErrorString());
+  }
+  if (goog.isString(data) && data.length > fb.core.util.validation.MAX_LEAF_SIZE_ / 3 && fb.util.utf8.stringLength(data) > fb.core.util.validation.MAX_LEAF_SIZE_) {
+    throw new Error(errorPrefix + "contains a string greater than " + fb.core.util.validation.MAX_LEAF_SIZE_ + " utf8 bytes " + path.toErrorString() + " ('" + data.substring(0, 50) + "...')");
+  }
+  if (goog.isObject(data)) {
+    var hasDotValue = false, hasActualChild = false;
+    fb.util.obj.foreach(data, function(key, value) {
+      if (key === ".value") {
+        hasDotValue = true;
+      } else {
+        if (key !== ".priority" && key !== ".sv") {
+          hasActualChild = true;
+          if (!fb.core.util.validation.isValidKey(key)) {
+            throw new Error(errorPrefix + " contains an invalid key (" + key + ") " + path.toErrorString() + ".  Keys must be non-empty strings " + 'and can\'t contain ".", "#", "$", "/", "[", or "]"');
+          }
+        }
+      }
+      path.push(key);
+      fb.core.util.validation.validateFirebaseData(errorPrefix, value, path);
+      path.pop();
+    });
+    if (hasDotValue && hasActualChild) {
+      throw new Error(errorPrefix + ' contains ".value" child ' + path.toErrorString() + " in addition to actual children.");
+    }
+  }
+}, validateFirebaseMergeDataArg:function(fnName, argumentNumber, data, path, optional) {
+  if (optional && !goog.isDef(data)) {
+    return;
+  }
+  if (!goog.isObject(data) || goog.isArray(data)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + " must be an Object containing " + "the children to replace.");
+  }
+  if (fb.util.obj.contains(data, ".value")) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + ' must not contain ".value".  ' + "To overwrite with a leaf value, just use .set() instead.");
+  }
+  fb.core.util.validation.validateFirebaseDataArg(fnName, argumentNumber, data, path, optional);
+}, validatePriority:function(fnName, argumentNumber, priority, optional) {
+  if (optional && !goog.isDef(priority)) {
+    return;
+  }
+  if (fb.core.util.isInvalidJSONNumber(priority)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "is " + priority.toString() + ", but must be a valid Firebase priority (a string, finite number, " + "server value, or null).");
+  }
+  if (!fb.core.util.validation.isValidPriority(priority)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a valid Firebase priority " + "(a string, finite number, server value, or null).");
+  }
+}, validateEventType:function(fnName, argumentNumber, eventType, optional) {
+  if (optional && !goog.isDef(eventType)) {
+    return;
+  }
+  switch(eventType) {
+    case "value":
+    ;
+    case "child_added":
+    ;
+    case "child_removed":
+    ;
+    case "child_changed":
+    ;
+    case "child_moved":
+      break;
+    default:
+      throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + 'must be a valid event type: "value", "child_added", "child_removed", ' + '"child_changed", or "child_moved".');;
+  }
+}, validateKey:function(fnName, argumentNumber, key, optional) {
+  if (optional && !goog.isDef(key)) {
+    return;
+  }
+  if (!fb.core.util.validation.isValidKey(key)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + 'was an invalid key: "' + key + '".  Firebase keys must be non-empty strings and ' + 'can\'t contain ".", "#", "$", "/", "[", or "]").');
+  }
+}, validatePathString:function(fnName, argumentNumber, pathString, optional) {
+  if (optional && !goog.isDef(pathString)) {
+    return;
+  }
+  if (!fb.core.util.validation.isValidPathString(pathString)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + 'was an invalid path: "' + pathString + '". Paths must be non-empty strings and ' + 'can\'t contain ".", "#", "$", "[", or "]"');
+  }
+}, validateRootPathString:function(fnName, argumentNumber, pathString, optional) {
+  if (pathString) {
+    pathString = pathString.replace(/^\/*\.info(\/|$)/, "/");
+  }
+  fb.core.util.validation.validatePathString(fnName, argumentNumber, pathString, optional);
+}, validateWritablePath:function(fnName, path) {
+  if (path.getFront() === ".info") {
+    throw new Error(fnName + " failed: Can't modify data under /.info/");
+  }
+}, validateUrl:function(fnName, argumentNumber, parsedUrl) {
+  var pathString = parsedUrl.path.toString();
+  if (!goog.isString(parsedUrl.repoInfo.host) || parsedUrl.repoInfo.host.length === 0 || !fb.core.util.validation.isValidKey(parsedUrl.repoInfo.namespace) || pathString.length !== 0 && !fb.core.util.validation.isValidRootPathString(pathString)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, false) + "must be a valid firebase URL and " + 'the path can\'t contain ".", "#", "$", "[", or "]".');
+  }
+}, validateCredential:function(fnName, argumentNumber, cred, optional) {
+  if (optional && !goog.isDef(cred)) {
+    return;
+  }
+  if (!goog.isString(cred)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a valid credential (a string).");
+  }
+}, validateBoolean:function(fnName, argumentNumber, bool, optional) {
+  if (optional && !goog.isDef(bool)) {
+    return;
+  }
+  if (!goog.isBoolean(bool)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a boolean.");
+  }
+}, validateString:function(fnName, argumentNumber, string, optional) {
+  if (optional && !goog.isDef(string)) {
+    return;
+  }
+  if (!goog.isString(string)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a valid string.");
+  }
+}, validateObject:function(fnName, argumentNumber, obj, optional) {
+  if (optional && !goog.isDef(obj)) {
+    return;
+  }
+  if (!goog.isObject(obj) || obj === null) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + "must be a valid object.");
+  }
+}, validateObjectContainsKey:function(fnName, argumentNumber, obj, key, optional, opt_type) {
+  if (optional && !goog.isDef(obj)) {
+    return;
+  }
+  if (!goog.isObject(obj) || obj === null || !fb.util.obj.contains(obj, key)) {
+    throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + 'must contain the key "' + key + '"');
+  }
+  if (opt_type) {
+    var val = fb.util.obj.get(obj, key);
+    if (opt_type === "string" && !goog.isString(val) || opt_type === "boolean" && !goog.isBoolean(val) || opt_type === "function" && !goog.isFunction(val) || opt_type === "object" && !goog.isObject(val)) {
+      throw new Error(fb.util.validation.errorPrefix(fnName, argumentNumber, optional) + 'must contain the key "' + key + '" with type "' + opt_type + '"');
+    }
+  }
+}};
+goog.provide("fb.core.util.CountedSet");
+goog.require("fb.core.util");
+goog.require("fb.util.obj");
+goog.require("goog.object");
+fb.core.util.CountedSet = goog.defineClass(null, {constructor:function() {
+  this.set = {};
+}, add:function(item, val) {
+  this.set[item] = val !== null ? val : true;
+}, contains:function(key) {
+  return fb.util.obj.contains(this.set, key);
+}, get:function(item) {
+  return this.contains(item) ? this.set[item] : undefined;
+}, remove:function(item) {
+  delete this.set[item];
+}, clear:function() {
+  this.set = {};
+}, isEmpty:function() {
+  return goog.object.isEmpty(this.set);
+}, count:function() {
+  return goog.object.getCount(this.set);
+}, each:function(fn) {
+  goog.object.forEach(this.set, function(v, k) {
+    fn(k, v);
+  });
+}, keys:function() {
+  var keys = [];
+  goog.object.forEach(this.set, function(v, k) {
+    keys.push(k);
+  });
+  return keys;
+}});
+goog.provide("fb.core.SparseSnapshotTree");
+goog.require("fb.core.snap.Node");
+goog.require("fb.core.snap.PriorityIndex");
+goog.require("fb.core.util.CountedSet");
+goog.require("fb.core.util.Path");
+fb.core.SparseSnapshotTree = function() {
+  this.value_ = null;
+  this.children_ = null;
+};
+fb.core.SparseSnapshotTree.prototype.find = function(path) {
+  if (this.value_ != null) {
+    return this.value_.getChild(path);
+  } else {
+    if (!path.isEmpty() && this.children_ != null) {
+      var childKey = path.getFront();
+      path = path.popFront();
+      if (this.children_.contains(childKey)) {
+        var childTree = this.children_.get(childKey);
+        return childTree.find(path);
+      } else {
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+};
+fb.core.SparseSnapshotTree.prototype.remember = function(path, data) {
+  if (path.isEmpty()) {
+    this.value_ = data;
+    this.children_ = null;
+  } else {
+    if (this.value_ !== null) {
+      this.value_ = this.value_.updateChild(path, data);
+    } else {
+      if (this.children_ == null) {
+        this.children_ = new fb.core.util.CountedSet;
+      }
+      var childKey = path.getFront();
+      if (!this.children_.contains(childKey)) {
+        this.children_.add(childKey, new fb.core.SparseSnapshotTree);
+      }
+      var child = this.children_.get(childKey);
+      path = path.popFront();
+      child.remember(path, data);
+    }
+  }
+};
+fb.core.SparseSnapshotTree.prototype.forget = function(path) {
+  if (path.isEmpty()) {
+    this.value_ = null;
+    this.children_ = null;
+    return true;
+  } else {
+    if (this.value_ !== null) {
+      if (this.value_.isLeafNode()) {
+        return false;
+      } else {
+        var value = this.value_;
+        this.value_ = null;
+        var self = this;
+        value.forEachChild(fb.core.snap.PriorityIndex, function(key, tree) {
+          self.remember(new fb.core.util.Path(key), tree);
+        });
+        return this.forget(path);
+      }
+    } else {
+      if (this.children_ !== null) {
+        var childKey = path.getFront();
+        path = path.popFront();
+        if (this.children_.contains(childKey)) {
+          var safeToRemove = this.children_.get(childKey).forget(path);
+          if (safeToRemove) {
+            this.children_.remove(childKey);
+          }
+        }
+        if (this.children_.isEmpty()) {
+          this.children_ = null;
+          return true;
+        } else {
+          return false;
+        }
+      } else {
+        return true;
+      }
+    }
+  }
+};
+fb.core.SparseSnapshotTree.prototype.forEachTree = function(prefixPath, func) {
+  if (this.value_ !== null) {
+    func(prefixPath, this.value_);
+  } else {
+    this.forEachChild(function(key, tree) {
+      var path = new fb.core.util.Path(prefixPath.toString() + "/" + key);
+      tree.forEachTree(path, func);
+    });
+  }
+};
+fb.core.SparseSnapshotTree.prototype.forEachChild = function(func) {
+  if (this.children_ !== null) {
+    this.children_.each(function(key, tree) {
+      func(key, tree);
+    });
+  }
+};
+goog.provide("fb.login.Constants");
+fb.login.Constants = {SESSION_PERSISTENCE_KEY_PREFIX:"session", DEFAULT_SERVER_HOST:"auth.firebase.com", SERVER_HOST:"auth.firebase.com", API_VERSION:"v2", POPUP_PATH_TO_CHANNEL:"/auth/channel", POPUP_RELAY_FRAME_NAME:"__winchan_relay_frame", POPUP_CLOSE_CMD:"die", JSONP_CALLBACK_NAMESPACE:"__firebase_auth_jsonp", REDIR_REQUEST_ID_KEY:"redirect_request_id", REDIR_REQUEST_COMPLETION_KEY:"__firebase_request_key", REDIR_CLIENT_OPTIONS_KEY:"redirect_client_options", INTERNAL_REDIRECT_SENTINAL_PATH:"/blank/page.html", 
+CLIENT_OPTION_SESSION_PERSISTENCE:"remember", CLIENT_OPTION_REDIRECT_TO:"redirectTo"};
+goog.provide("fb.login.RequestInfo");
+goog.require("fb.login.Constants");
+fb.login.RequestInfo = function(opt_clientOptions, opt_transportOptions, opt_serverParams) {
+  this.clientOptions = opt_clientOptions || {};
+  this.transportOptions = opt_transportOptions || {};
+  this.serverParams = opt_serverParams || {};
+  if (!this.clientOptions[fb.login.Constants.CLIENT_OPTION_SESSION_PERSISTENCE]) {
+    this.clientOptions[fb.login.Constants.CLIENT_OPTION_SESSION_PERSISTENCE] = "default";
+  }
+};
+fb.login.RequestInfo.CLIENT_OPTIONS = [fb.login.Constants.CLIENT_OPTION_SESSION_PERSISTENCE, fb.login.Constants.CLIENT_OPTION_REDIRECT_TO];
+fb.login.RequestInfo.fromParams = function(opt_params) {
+  var clientOptions = {}, serverParams = {};
+  fb.util.obj.foreach(opt_params || {}, function(param, value) {
+    if (goog.array.contains(fb.login.RequestInfo.CLIENT_OPTIONS, param)) {
+      clientOptions[param] = value;
+    } else {
+      serverParams[param] = value;
+    }
+  });
+  return new fb.login.RequestInfo(clientOptions, {}, serverParams);
+};
+goog.provide("fb.login.SessionManager");
+goog.require("fb.core.storage");
+goog.require("fb.login.Constants");
+goog.require("fb.util.json");
+goog.require("fb.util.jwt");
+fb.login.SessionManager = function(repoInfo, stores) {
+  this.persistenceKey_ = [fb.login.Constants.SESSION_PERSISTENCE_KEY_PREFIX, repoInfo.persistenceKey, repoInfo.namespace].join(":");
+  this.stores_ = stores;
+};
+fb.login.SessionManager.prototype.set = function(data, store) {
+  if (!store) {
+    if (this.stores_.length) {
+      store = this.stores_[0];
+    } else {
+      throw new Error("fb.login.SessionManager : No storage options available!");
+    }
+  }
+  store.set(this.persistenceKey_, data);
+};
+fb.login.SessionManager.prototype.get = function() {
+  var sessions = goog.array.map(this.stores_, goog.bind(this.getFromStore_, this));
+  sessions = goog.array.filter(sessions, function(session) {
+    return session !== null;
+  });
+  goog.array.sort(sessions, function(a, b) {
+    return fb.util.jwt.issuedAtTime(b["token"]) - fb.util.jwt.issuedAtTime(a["token"]);
+  });
+  if (sessions.length > 0) {
+    return sessions.shift();
+  }
+  return null;
+};
+fb.login.SessionManager.prototype.getFromStore_ = function(store) {
+  try {
+    var session = store.get(this.persistenceKey_);
+    if (session && session["token"]) {
+      return session;
+    }
+  } catch (e) {
+  }
+  return null;
+};
+fb.login.SessionManager.prototype.clear = function(store) {
+  var stores = store ? [store] : this.stores_, self = this;
+  goog.array.forEach(this.stores_, function(store) {
+    store.remove(self.persistenceKey_);
+  });
+};
+goog.provide("fb.login.util.environment");
+fb.login.util.environment.isMobileWrapper = function() {
+  return fb.login.util.environment.isMobileCordova() || fb.login.util.environment.isMobileWindows() || fb.login.util.environment.isIosWebview();
+};
+fb.login.util.environment.isMobileCordova = function() {
+  return typeof window !== "undefined" && !!(window["cordova"] || window["phonegap"] || window["PhoneGap"]) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(navigator["userAgent"]);
+};
+fb.login.util.environment.isMobileWindows = function() {
+  return typeof navigator !== "undefined" && (!!navigator["userAgent"].match(/Windows Phone/) || !!window["Windows"] && /^ms-appx:/.test(location.href));
+};
+fb.login.util.environment.isMobileFirefox = function() {
+  return typeof navigator !== "undefined" && (navigator["userAgent"].indexOf("Fennec/") !== -1 || navigator["userAgent"].indexOf("Firefox/") !== -1 && navigator["userAgent"].indexOf("Android") !== -1);
+};
+fb.login.util.environment.isIosWebview = function() {
+  return typeof navigator !== "undefined" && typeof window !== "undefined" && !!(navigator["userAgent"].match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i) || navigator["userAgent"].match(/CriOS/) || navigator["userAgent"].match(/Twitter for iPhone/) || navigator["userAgent"].match(/FBAN\/FBIOS/) || window["navigator"]["standalone"]);
+};
+fb.login.util.environment.isHeadlessBrowser = function() {
+  return typeof navigator !== "undefined" && !!navigator["userAgent"].match(/PhantomJS/);
+};
+fb.login.util.environment.isLocalFile = function() {
+  return typeof location !== "undefined" && /^file:\//.test(location.href);
+};
+fb.login.util.environment.isIE = function() {
+  return typeof navigator !== "undefined" && !!(navigator["userAgent"].match(/MSIE/) || navigator["userAgent"].match(/Trident/));
+};
+fb.login.util.environment.isModernIE = function() {
+  if (typeof navigator === "undefined") {
+    return false;
+  }
+  var ua = navigator["userAgent"], match;
+  if (navigator["appName"] === "Microsoft Internet Explorer") {
+    match = ua.match(/MSIE ([0-9]{1,}[\.0-9]{0,})/);
+    if (match && match.length > 1) {
+      return parseFloat(match[1]) >= 8;
+    }
+  } else {
+    if (ua.indexOf("Trident") > -1) {
+      match = ua.match(/rv:([0-9]{2,2}[\.0-9]{0,})/);
+      if (match && match.length > 1) {
+        return parseFloat(match[1]) >= 8;
+      }
+    }
+  }
+  return false;
+};
+goog.provide("fb.login.transports.util");
+goog.require("fb.login.Constants");
+goog.require("fb.util");
+fb.login.transports.util.findRelay = function() {
+  var loc = window["location"], frames = window["opener"]["frames"], i;
+  for (i = frames.length - 1;i >= 0;i--) {
+    try {
+      if (frames[i]["location"]["protocol"] === window["location"]["protocol"] && frames[i]["location"]["host"] === window["location"]["host"] && frames[i]["name"] === fb.login.Constants.POPUP_RELAY_FRAME_NAME) {
+        return frames[i];
+      }
+    } catch (e) {
+    }
+  }
+  return null;
+};
+fb.login.transports.util.addListener = function(target, event, cb) {
+  if (target["attachEvent"]) {
+    target["attachEvent"]("on" + event, cb);
+  } else {
+    if (target["addEventListener"]) {
+      target["addEventListener"](event, cb, false);
+    }
+  }
+};
+fb.login.transports.util.removeListener = function(target, event, cb) {
+  if (target["detachEvent"]) {
+    target["detachEvent"]("on" + event, cb);
+  } else {
+    if (target["removeEventListener"]) {
+      target["removeEventListener"](event, cb, false);
+    }
+  }
+};
+fb.login.transports.util.extractOrigin = function(url) {
+  if (!/^https?:\/\//.test(url)) {
+    url = window["location"]["href"];
+  }
+  var m = /^(https?:\/\/[\-_a-zA-Z\.0-9:]+)/.exec(url);
+  if (m) {
+    return m[1];
+  }
+  return url;
+};
+fb.login.transports.util.extractRedirectCompletionHash = function(hashStr) {
+  var hash = "";
+  try {
+    hashStr = hashStr.replace("#", "");
+    var hashObj = fb.util.querystringDecode(hashStr);
+    if (hashObj && fb.util.obj.contains(hashObj, fb.login.Constants.REDIR_REQUEST_COMPLETION_KEY)) {
+      hash = fb.util.obj.get(hashObj, fb.login.Constants.REDIR_REQUEST_COMPLETION_KEY);
+    }
+  } catch (e) {
+  }
+  return hash;
+};
+fb.login.transports.util.replaceRedirectCompletionHash = function() {
+  try {
+    var exp = new RegExp("&" + fb.login.Constants.REDIR_REQUEST_COMPLETION_KEY + "=([a-zA-z0-9]*)");
+    document.location.hash = document.location.hash.replace(exp, "");
+  } catch (e) {
+  }
+};
+fb.login.transports.util.getBaseUrl = function() {
+  var parsedUrl = fb.core.util.parseURL(fb.login.Constants.SERVER_HOST);
+  return parsedUrl.scheme + "://" + parsedUrl.host + "/" + fb.login.Constants.API_VERSION;
+};
+fb.login.transports.util.getPopupChannelUrl = function(namespace) {
+  return fb.login.transports.util.getBaseUrl() + "/" + namespace + fb.login.Constants.POPUP_PATH_TO_CHANNEL;
+};
+goog.provide("fb.login.Transport");
+fb.login.Transport = function(options) {
+};
+fb.login.Transport.isAvailable = function() {
+};
+fb.login.Transport.prototype.open = function(url, params, onComplete) {
+};
+fb.login.Transport.prototype.classification = function() {
+};
+goog.provide("fb.login.transports.PopupReceiver");
+goog.require("fb.login.Constants");
+goog.require("fb.login.Transport");
+goog.require("fb.login.transports.util");
+goog.require("fb.login.util.environment");
+goog.require("fb.util.json");
+fb.login.transports.PopupReceiver = function(cb) {
+  var self = this;
+  this.cb = cb;
+  this.targetOrigin = "*";
+  if (fb.login.util.environment.isModernIE()) {
+    this.messageTarget = this.inboundTarget = fb.login.transports.util.findRelay();
+  } else {
+    this.messageTarget = window["opener"];
+    this.inboundTarget = window;
+  }
+  if (!self.messageTarget) {
+    throw "Unable to find relay frame";
+  }
+  fb.login.transports.util.addListener(this.inboundTarget, "message", goog.bind(this.onMessage_, this));
+  fb.login.transports.util.addListener(this.inboundTarget, "message", goog.bind(this.onDie_, this));
+  try {
+    this.doPost_({"a":"ready"});
+  } catch (e) {
+    fb.login.transports.util.addListener(this.messageTarget, "load", function(e) {
+      self.doPost_({"a":"ready"});
+    });
+  }
+  fb.login.transports.util.addListener(window, "unload", goog.bind(this.onUnload_, this));
+};
+fb.login.transports.PopupReceiver.prototype.doPost_ = function(msg) {
+  msg = fb.util.json.stringify(msg);
+  if (fb.login.util.environment.isModernIE()) {
+    this.messageTarget["doPost"](msg, this.targetOrigin);
+  } else {
+    this.messageTarget["postMessage"](msg, this.targetOrigin);
+  }
+};
+fb.login.transports.PopupReceiver.prototype.onMessage_ = function(e) {
+  var self = this, d;
+  try {
+    d = fb.util.json.eval(e["data"]);
+  } catch (err) {
+  }
+  if (!d || d["a"] !== "request") {
+    return;
+  }
+  fb.login.transports.util.removeListener(window, "message", this.onMessage_);
+  this.targetOrigin = e["origin"];
+  if (this.cb) {
+    setTimeout(function() {
+      self.cb(self.targetOrigin, d["d"], function(response, forceKeepWindowOpen) {
+        self.autoClose = !forceKeepWindowOpen;
+        self.cb = undefined;
+        self.doPost_({"a":"response", "d":response, "forceKeepWindowOpen":forceKeepWindowOpen});
+      });
+    }, 0);
+  }
+};
+fb.login.transports.PopupReceiver.prototype.onUnload_ = function() {
+  try {
+    fb.login.transports.util.removeListener(this.inboundTarget, "message", this.onDie_);
+  } catch (err) {
+  }
+  if (this.cb) {
+    this.doPost_({"a":"error", "d":"unknown closed window"});
+    this.cb = undefined;
+  }
+  try {
+    window.close();
+  } catch (err) {
+  }
+};
+fb.login.transports.PopupReceiver.prototype.onDie_ = function(e) {
+  if (this.autoClose && e["data"] === fb.login.Constants.POPUP_CLOSE_CMD) {
+    try {
+      window.close();
+    } catch (err) {
+    }
+  }
+};
+goog.provide("fb.login.transports.Redirect");
+goog.require("fb.constants");
+goog.require("fb.core.storage");
+goog.require("fb.login.Transport");
+goog.require("fb.login.transports.util");
+goog.require("fb.util");
+fb.login.transports.Redirect = function(options) {
+  this.requestId_ = goog.string.getRandomString() + goog.string.getRandomString() + goog.string.getRandomString();
+  this.options_ = options;
+};
+fb.login.transports.Redirect.prototype.open = function(url, params, cb) {
+  fb.core.storage.SessionStorage.set(fb.login.Constants.REDIR_REQUEST_ID_KEY, this.requestId_);
+  fb.core.storage.SessionStorage.set(fb.login.Constants.REDIR_REQUEST_ID_KEY, this.requestId_);
+  params["requestId"] = this.requestId_;
+  params["redirectTo"] = params["redirectTo"] || window["location"]["href"];
+  url += (/\?/.test(url) ? "" : "?") + fb.util.querystring(params);
+  window["location"] = url;
+};
+fb.login.transports.Redirect["isAvailable"] = function() {
+  return!NODE_CLIENT && !fb.login.util.environment.isLocalFile() && !fb.login.util.environment.isMobileCordova();
+};
+fb.login.transports.Redirect.prototype.classification = function() {
+  return "redirect";
+};
+goog.provide("fb.login.Errors");
+var errors = {"NETWORK_ERROR":"Unable to contact the Firebase server.", "SERVER_ERROR":"An unknown server error occurred.", "TRANSPORT_UNAVAILABLE":"There are no login transports available for the requested method.", "REQUEST_INTERRUPTED":"The browser redirected the page before the login request could complete.", "USER_CANCELLED":"The user cancelled authentication."};
+fb.login.Errors.get = function(code) {
+  var msg = fb.util.obj.get(errors, code);
+  var e = new Error(msg, code);
+  e["code"] = code;
+  return e;
+};
+goog.provide("fb.login.transports.Popup");
+goog.require("fb.core.util");
+goog.require("fb.login.Constants");
+goog.require("fb.login.Errors");
+goog.require("fb.login.Transport");
+goog.require("fb.login.transports.util");
+goog.require("fb.login.util.environment");
+goog.require("fb.util");
+goog.require("fb.util.json");
+fb.login.transports.Popup = function(options) {
+  if (!options["window_features"] || fb.login.util.environment.isMobileFirefox()) {
+    options["window_features"] = undefined;
+  }
+  if (!options["window_name"]) {
+    options["window_name"] = "_blank";
+  }
+  this.options = options;
+};
+fb.login.transports.Popup.prototype.open = function(url, params, cb) {
+  var self = this, isIE = fb.login.util.environment.isModernIE(), iframe, messageTarget;
+  if (!this.options["relay_url"]) {
+    return cb(new Error("invalid arguments: origin of url and relay_url must match"));
+  }
+  var origin = fb.login.transports.util.extractOrigin(url);
+  if (origin !== fb.login.transports.util.extractOrigin(self.options["relay_url"])) {
+    if (cb) {
+      setTimeout(function() {
+        cb(new Error("invalid arguments: origin of url and relay_url must match"));
+      }, 0);
+    }
+    return;
+  }
+  if (isIE) {
+    iframe = document.createElement("iframe");
+    iframe["setAttribute"]("src", self.options["relay_url"]);
+    iframe["style"]["display"] = "none";
+    iframe["setAttribute"]("name", fb.login.Constants.POPUP_RELAY_FRAME_NAME);
+    document["body"]["appendChild"](iframe);
+    messageTarget = iframe["contentWindow"];
+  }
+  url += (/\?/.test(url) ? "" : "?") + fb.util.querystring(params);
+  var popup = window.open(url, self.options["window_name"], self.options["window_features"]);
+  if (!messageTarget) {
+    messageTarget = popup;
+  }
+  var closeInterval = setInterval(function() {
+    if (popup && popup["closed"]) {
+      cleanup(false);
+      if (cb) {
+        cb(fb.login.Errors.get("USER_CANCELLED"));
+        cb = null;
+      }
+      return;
+    }
+  }, 500);
+  var req = fb.util.json.stringify({"a":"request", "d":params});
+  function cleanup(forceKeepWindowOpen) {
+    if (iframe) {
+      document["body"]["removeChild"](iframe);
+      iframe = undefined;
+    }
+    if (closeInterval) {
+      closeInterval = clearInterval(closeInterval);
+    }
+    fb.login.transports.util.removeListener(window, "message", onMessage);
+    fb.login.transports.util.removeListener(window, "unload", cleanup);
+    if (popup && !forceKeepWindowOpen) {
+      try {
+        popup["close"]();
+      } catch (securityViolation) {
+        messageTarget["postMessage"](fb.login.Constants.POPUP_CLOSE_CMD, origin);
+      }
+    }
+    popup = messageTarget = undefined;
+  }
+  fb.login.transports.util.addListener(window, "unload", cleanup);
+  function onMessage(e) {
+    if (e["origin"] !== origin) {
+      return;
+    }
+    try {
+      var d = fb.util.json.eval(e["data"]);
+      if (d["a"] === "ready") {
+        messageTarget["postMessage"](req, origin);
+      } else {
+        if (d["a"] === "error") {
+          cleanup(false);
+          if (cb) {
+            cb(d["d"]);
+            cb = null;
+          }
+        } else {
+          if (d["a"] === "response") {
+            cleanup(d["forceKeepWindowOpen"]);
+            if (cb) {
+              cb(null, d["d"]);
+              cb = null;
+            }
+          }
+        }
+      }
+    } catch (err) {
+    }
+  }
+  fb.login.transports.util.addListener(window, "message", onMessage);
+};
+fb.login.transports.Popup["isAvailable"] = function() {
+  return!NODE_CLIENT && "postMessage" in window && !fb.login.util.environment.isLocalFile() && !fb.login.util.environment.isMobileWrapper() && !fb.login.util.environment.isHeadlessBrowser();
+};
+fb.login.transports.Popup.prototype.classification = function() {
+  return "popup";
+};
+goog.provide("fb.login.transports.NodeHttp");
+goog.require("fb.login.Constants");
+goog.require("fb.login.Errors");
+goog.require("fb.login.Transport");
+goog.require("fb.login.transports.util");
+goog.require("fb.login.util.environment");
+goog.require("fb.util");
+goog.require("fb.util.json");
+fb.login.transports.NodeHttp = function(options) {
+  if (!options["method"]) {
+    options["method"] = "GET";
+  }
+  if (!options["headers"]) {
+    options["headers"] = {};
+  }
+  if (!options["headers"]["content_type"]) {
+    options["headers"]["content_type"] = "application/json";
+  }
+  options["headers"]["content_type"] = options["headers"]["content_type"].toLowerCase();
+  this.options = options;
+};
+fb.login.transports.NodeHttp.prototype.open = function(url, params, cb) {
+  var self = this, parsedUrl = fb.core.util.parseURL(url), http = parsedUrl.scheme === "http" ? require("http") : require("https"), method = this.options["method"], payload;
+  var headers = {"Accept":"application/json;text/plain"};
+  goog.object.extend(headers, this.options["headers"]);
+  var requestOpts = {"host":parsedUrl.host.split(":")[0], "port":parsedUrl.port, "path":parsedUrl.pathString, "method":this.options["method"].toUpperCase()};
+  if (method === "GET") {
+    requestOpts["path"] += (/\?/.test(requestOpts["path"]) ? "" : "?") + fb.util.querystring(params);
+    payload = null;
+  } else {
+    var contentType = this.options["headers"]["content_type"];
+    if (contentType === "application/json") {
+      payload = fb.util.json.stringify(params);
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      payload = fb.util.querystring(params);
+    }
+    headers["Content-Length"] = Buffer["byteLength"](payload, "utf8");
+  }
+  requestOpts["headers"] = headers;
+  var req = http["request"](requestOpts, function(response) {
+    var res = "";
+    response["setEncoding"]("utf8");
+    response["on"]("data", function(d) {
+      res += d;
+    });
+    response["on"]("end", function() {
+      try {
+        res = fb.util.json.eval(res + "");
+      } catch (e) {
+      }
+      if (cb) {
+        cb(null, res);
+        cb = null;
+      }
+    });
+  });
+  if (method !== "GET") {
+    req["write"](payload);
+  }
+  req["on"]("error", function(e) {
+    if (e && e["code"] && (e["code"] === "ENOTFOUND" || e["code"] === "ENETDOWN")) {
+      cb(fb.login.Errors.get("NETWORK_ERROR"));
+    } else {
+      cb(fb.login.Errors.get("SERVER_ERROR"));
+    }
+    cb = null;
+  });
+  req["end"]();
+};
+fb.login.transports.NodeHttp["isAvailable"] = function() {
+  return NODE_CLIENT;
+};
+fb.login.transports.NodeHttp.prototype.classification = function() {
+  return "json";
+};
+goog.provide("fb.login.transports.XHR");
+goog.require("fb.login.Constants");
+goog.require("fb.login.Errors");
+goog.require("fb.login.Transport");
+goog.require("fb.login.transports.util");
+goog.require("fb.login.util.environment");
+goog.require("fb.util");
+goog.require("fb.util.json");
+fb.login.transports.XHR = function(options) {
+  if (!options["method"]) {
+    options["method"] = "GET";
+  }
+  if (!options["headers"]) {
+    options["headers"] = {};
+  }
+  if (!options["headers"]["content_type"]) {
+    options["headers"]["content_type"] = "application/json";
+  }
+  options["headers"]["content_type"] = options["headers"]["content_type"].toLowerCase();
+  this.options = options;
+};
+fb.login.transports.XHR.prototype.open = function(url, params, cb) {
+  var self = this;
+  var xhr = new XMLHttpRequest, method = this.options["method"].toUpperCase(), payload;
+  function handleInterrupt_(e) {
+    if (cb) {
+      cb(fb.login.Errors.get("REQUEST_INTERRUPTED"));
+      cb = null;
+    }
+  }
+  fb.login.transports.util.addListener(window, "beforeunload", handleInterrupt_);
+  xhr.onreadystatechange = function() {
+    if (cb && xhr.readyState === 4) {
+      var res;
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try {
+          res = fb.util.json.eval(xhr.responseText);
+        } catch (e) {
+        }
+        cb(null, res);
+      } else {
+        if (xhr.status >= 500 && xhr.status < 600) {
+          cb(fb.login.Errors.get("SERVER_ERROR"));
+        } else {
+          cb(fb.login.Errors.get("NETWORK_ERROR"));
+        }
+      }
+      cb = null;
+      fb.login.transports.util.removeListener(window, "beforeunload", handleInterrupt_);
+    }
+  };
+  if (method === "GET") {
+    url += (/\?/.test(url) ? "" : "?") + fb.util.querystring(params);
+    payload = null;
+  } else {
+    var contentType = this.options["headers"]["content_type"];
+    if (contentType === "application/json") {
+      payload = fb.util.json.stringify(params);
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      payload = fb.util.querystring(params);
+    }
+  }
+  xhr.open(method, url, true);
+  var headers = {"X-Requested-With":"XMLHttpRequest", "Accept":"application/json;text/plain"};
+  goog.object.extend(headers, this.options["headers"]);
+  for (var header in headers) {
+    xhr.setRequestHeader(header, headers[header]);
+  }
+  xhr.send(payload);
+};
+fb.login.transports.XHR["isAvailable"] = function() {
+  return!NODE_CLIENT && !!window["XMLHttpRequest"] && typeof(new XMLHttpRequest).responseType === "string" && (!fb.login.util.environment.isIE() || fb.login.util.environment.isModernIE());
+};
+fb.login.transports.XHR.prototype.classification = function() {
+  return "json";
+};
+goog.provide("fb.login.transports.CordovaInAppBrowser");
+goog.require("fb.core.util");
+goog.require("fb.login.Constants");
+goog.require("fb.login.Errors");
+goog.require("fb.login.RequestInfo");
+goog.require("fb.login.Transport");
+goog.require("fb.login.transports.XHR");
+goog.require("fb.login.transports.util");
+goog.require("fb.login.util.environment");
+goog.require("fb.util");
+goog.require("fb.util.json");
+fb.login.transports.CordovaInAppBrowser = function(options) {
+  this.requestId_ = goog.string.getRandomString() + goog.string.getRandomString() + goog.string.getRandomString();
+  this.options_ = options;
+};
+fb.login.transports.CordovaInAppBrowser.prototype.open = function(url, params, cb) {
+  var self = this, parsedUrl = fb.core.util.parseURL(fb.login.Constants.SERVER_HOST), windowRef;
+  function isSentinelPathMatch(url) {
+    try {
+      var a = document.createElement("a");
+      a["href"] = url;
+      return a["host"] === parsedUrl.host && a["pathname"] === fb.login.Constants.INTERNAL_REDIRECT_SENTINAL_PATH;
+    } catch (e) {
+    }
+    return false;
+  }
+  function onClose_(e) {
+    if (cb) {
+      cb(fb.login.Errors.get("USER_CANCELLED"));
+      cb = null;
+    }
+  }
+  params["requestId"] = this.requestId_;
+  params[fb.login.Constants.CLIENT_OPTION_REDIRECT_TO] = parsedUrl.scheme + "://" + parsedUrl.host + fb.login.Constants.INTERNAL_REDIRECT_SENTINAL_PATH;
+  url += /\?/.test(url) ? "" : "?";
+  url += fb.util.querystring(params);
+  windowRef = window.open(url, "_blank", "location=no");
+  if (!windowRef || !goog.isFunction(windowRef.addEventListener)) {
+    cb(fb.login.Errors.get("TRANSPORT_UNAVAILABLE"));
+    return;
+  }
+  windowRef.addEventListener("loadstart", function(e) {
+    if (!e || !e["url"] || !isSentinelPathMatch(e["url"])) {
+      return;
+    }
+    var reqKey = fb.login.transports.util.extractRedirectCompletionHash(e["url"]);
+    windowRef.removeEventListener("exit", onClose_);
+    windowRef.close();
+    var path = "/auth/session";
+    var requestInfo = new fb.login.RequestInfo(null, null, {"requestId":self.requestId_, "requestKey":reqKey});
+    self.options_["requestWithCredential"](path, requestInfo, cb);
+    cb = null;
+  });
+  windowRef.addEventListener("exit", onClose_);
+};
+fb.login.transports.CordovaInAppBrowser["isAvailable"] = function() {
+  return!NODE_CLIENT && fb.login.util.environment.isMobileCordova();
+};
+fb.login.transports.CordovaInAppBrowser.prototype.classification = function() {
+  return "redirect";
+};
+goog.provide("fb.login.transports.JSONP");
+goog.require("fb.login.Constants");
+goog.require("fb.login.Errors");
+goog.require("fb.login.Transport");
+goog.require("fb.login.transports.util");
+goog.require("fb.util");
+goog.require("fb.util.json");
+fb.login.transports.JSONP = function(options) {
+  if (!options["callback_parameter"]) {
+    options["callback_parameter"] = "callback";
+  }
+  this.options = options;
+  window[fb.login.Constants.JSONP_CALLBACK_NAMESPACE] = window[fb.login.Constants.JSONP_CALLBACK_NAMESPACE] || {};
+};
+fb.login.transports.JSONP.prototype.open = function(url, params, cb) {
+  var id = "fn" + (new Date).getTime() + Math.floor(Math.random() * 99999);
+  params[this.options["callback_parameter"]] = fb.login.Constants.JSONP_CALLBACK_NAMESPACE + "." + id;
+  url += (/\?/.test(url) ? "" : "?") + fb.util.querystring(params);
+  function handleInterrupt_(e) {
+    if (cb) {
+      cb(fb.login.Errors.get("REQUEST_INTERRUPTED"));
+      cb = null;
+    }
+  }
+  fb.login.transports.util.addListener(window, "beforeunload", handleInterrupt_);
+  function cleanup_() {
+    setTimeout(function() {
+      window[fb.login.Constants.JSONP_CALLBACK_NAMESPACE][id] = undefined;
+      if (goog.object.isEmpty(window[fb.login.Constants.JSONP_CALLBACK_NAMESPACE])) {
+        window[fb.login.Constants.JSONP_CALLBACK_NAMESPACE] = undefined;
+      }
+      try {
+        var el = document.getElementById(id);
+        if (el) {
+          el.parentNode.removeChild(el);
+        }
+      } catch (e) {
+      }
+    }, 1);
+    fb.login.transports.util.removeListener(window, "beforeunload", handleInterrupt_);
+  }
+  function onload_(res) {
+    if (cb) {
+      cb(null, res);
+      cb = null;
+    }
+    cleanup_();
+  }
+  window[fb.login.Constants.JSONP_CALLBACK_NAMESPACE][id] = onload_;
+  this.writeScriptTag_(id, url, cb);
+};
+fb.login.transports.JSONP.prototype.writeScriptTag_ = function(id, url, cb) {
+  setTimeout(function() {
+    try {
+      var js = document.createElement("script");
+      js.type = "text/javascript";
+      js.id = id;
+      js.async = true;
+      js.src = url;
+      js.onerror = function() {
+        var el = document.getElementById(id);
+        if (el !== null) {
+          el.parentNode.removeChild(el);
+        }
+        if (cb) {
+          cb(fb.login.Errors.get("NETWORK_ERROR"));
+        }
+      };
+      var ref;
+      var headElements = document.getElementsByTagName("head");
+      if (!headElements || goog.array.isEmpty(headElements)) {
+        ref = document.documentElement;
+      } else {
+        ref = headElements[0];
+      }
+      ref.appendChild(js);
+    } catch (e) {
+      if (cb) {
+        cb(fb.login.Errors.get("NETWORK_ERROR"));
+      }
+    }
+  }, 0);
+};
+fb.login.transports.JSONP["isAvailable"] = function() {
+  return!NODE_CLIENT;
+};
+fb.login.transports.JSONP.prototype.classification = function() {
+  return "json";
+};
+goog.provide("fb.login.AuthenticationManager");
+goog.require("fb.constants");
+goog.require("fb.core.storage");
+goog.require("fb.core.util");
+goog.require("fb.core.util.EventEmitter");
+goog.require("fb.login.Constants");
+goog.require("fb.login.Errors");
+goog.require("fb.login.RequestInfo");
+goog.require("fb.login.SessionManager");
+goog.require("fb.login.transports.CordovaInAppBrowser");
+goog.require("fb.login.transports.JSONP");
+goog.require("fb.login.transports.NodeHttp");
+goog.require("fb.login.transports.Popup");
+goog.require("fb.login.transports.Redirect");
+goog.require("fb.login.transports.XHR");
+fb.login.AuthenticationManager = function(repoInfo, auth, unauth, onAuthStatus) {
+  fb.core.util.EventEmitter.call(this, ["auth_status"]);
+  this.repoInfo_ = repoInfo;
+  this.authConn_ = auth;
+  this.unauthConn_ = unauth;
+  this.onAuthStatus_ = onAuthStatus;
+  this.sessionManager_ = new fb.login.SessionManager(repoInfo, [fb.core.storage.PersistentStorage, fb.core.storage.SessionStorage]);
+  this.authData_ = null;
+  this.redirectRestart_ = false;
+  this.resumeSession();
+};
+goog.inherits(fb.login.AuthenticationManager, fb.core.util.EventEmitter);
+fb.login.AuthenticationManager.prototype.getAuth = function() {
+  return this.authData_ || null;
+};
+fb.login.AuthenticationManager.prototype.resumeSession = function() {
+  var redirectRequestId = fb.core.storage.SessionStorage.get(fb.login.Constants.REDIR_REQUEST_ID_KEY), self = this;
+  if (redirectRequestId) {
+    this.finishOAuthRedirectLogin_();
+  }
+  var session = this.sessionManager_.get();
+  if (session && session["token"]) {
+    this.updateAuthStatus_(session);
+    this.authConn_(session["token"], function(status, data) {
+      self.authOnComplete_(status, data, false, session["token"], session);
+    }, function(cancelStatus, cancelReason) {
+      self.authOnCancel_("resumeSession()", cancelStatus, cancelReason);
+    });
+  } else {
+    this.updateAuthStatus_(null);
+  }
+};
+fb.login.AuthenticationManager.prototype.authenticate = function(cred, userProfile, clientOptions, opt_onComplete, opt_onCancel) {
+  if (this.repoInfo_.isDemoHost()) {
+    fb.core.util.warn("Firebase authentication is not supported on demo Firebases (*.firebaseio-demo.com). " + "To secure your Firebase, create a production Firebase at https://www.firebase.com.");
+  }
+  var self = this;
+  this.authConn_(cred, function(status, data) {
+    self.authOnComplete_(status, data, true, cred, userProfile, clientOptions || {}, opt_onComplete);
+  }, function(cancelStatus, cancelReason) {
+    self.authOnCancel_("auth()", cancelStatus, cancelReason, opt_onCancel);
+  });
+};
+fb.login.AuthenticationManager.prototype.unauthenticate = function(opt_onComplete) {
+  var self = this;
+  this.sessionManager_.clear();
+  self.updateAuthStatus_(null);
+  this.unauthConn_(function(status, errorReason) {
+    if (status === "ok") {
+      fb.core.util.callUserCallback(opt_onComplete, null);
+    } else {
+      var code = (status || "error").toUpperCase();
+      var message = code;
+      if (errorReason) {
+        message += ": " + errorReason;
+      }
+      var error = new Error(message);
+      error["code"] = code;
+      fb.core.util.callUserCallback(opt_onComplete, error);
+    }
+  });
+};
+fb.login.AuthenticationManager.prototype.authOnComplete_ = function(status, authConnResult, newSession, cred, authData, opt_clientOptions, opt_onComplete) {
+  if (status === "ok") {
+    if (newSession) {
+      var tokenPayload = authConnResult["auth"];
+      authData["auth"] = tokenPayload;
+      authData["expires"] = authConnResult["expires"];
+      authData["token"] = fb.util.jwt.isValidFormat(cred) ? cred : "";
+      var uid = null;
+      if (tokenPayload && fb.util.obj.contains(tokenPayload, "uid")) {
+        uid = fb.util.obj.get(tokenPayload, "uid");
+      } else {
+        if (fb.util.obj.contains(authData, "uid")) {
+          uid = fb.util.obj.get(authData, "uid");
+        }
+      }
+      authData["uid"] = uid;
+      var provider = "custom";
+      if (tokenPayload && fb.util.obj.contains(tokenPayload, "provider")) {
+        provider = fb.util.obj.get(tokenPayload, "provider");
+      } else {
+        if (fb.util.obj.contains(authData, "provider")) {
+          provider = fb.util.obj.get(authData, "provider");
+        }
+      }
+      authData["provider"] = provider;
+      this.sessionManager_.clear();
+      if (fb.util.jwt.isValidFormat(cred)) {
+        opt_clientOptions = opt_clientOptions || {};
+        var store = fb.core.storage.PersistentStorage;
+        if (opt_clientOptions[fb.login.Constants.CLIENT_OPTION_SESSION_PERSISTENCE] === "sessionOnly") {
+          store = fb.core.storage.SessionStorage;
+        }
+        if (opt_clientOptions[fb.login.Constants.CLIENT_OPTION_SESSION_PERSISTENCE] !== "none") {
+          this.sessionManager_.set(authData, store);
+        }
+      }
+      this.updateAuthStatus_(authData);
+    }
+    fb.core.util.callUserCallback(opt_onComplete, null, authData);
+    return;
+  }
+  this.handleBadAuthStatus_();
+  var code = (status || "error").toUpperCase();
+  var message = code;
+  if (authConnResult) {
+    message += ": " + authConnResult;
+  }
+  var error = new Error(message);
+  error["code"] = code;
+  fb.core.util.callUserCallback(opt_onComplete, error);
+};
+fb.login.AuthenticationManager.prototype.authOnCancel_ = function(fromFunction, cancelStatus, cancelReason, opt_onCancel) {
+  fb.core.util.warn(fromFunction + " was canceled: " + cancelReason);
+  this.handleBadAuthStatus_();
+  var err = new Error(cancelReason);
+  err["code"] = cancelStatus.toUpperCase();
+  fb.core.util.callUserCallback(opt_onCancel, err);
+};
+fb.login.AuthenticationManager.prototype.handleBadAuthStatus_ = function() {
+  this.sessionManager_.clear();
+  this.updateAuthStatus_(null);
+};
+fb.login.AuthenticationManager.prototype.authWithCredential = function(provider, opt_params, opt_options, opt_onComplete) {
+  this.checkServerSettingsOrThrow();
+  var requestInfo = new fb.login.RequestInfo(opt_options || {}, {}, opt_params || {});
+  var transports;
+  if (NODE_CLIENT) {
+    transports = [fb.login.transports.NodeHttp];
+  } else {
+    transports = [fb.login.transports.XHR, fb.login.transports.JSONP];
+  }
+  this.authWithTransports_(transports, "/auth/" + provider, requestInfo, opt_onComplete);
+};
+fb.login.AuthenticationManager.prototype.authWithPopup = function(provider, opt_params, opt_onComplete) {
+  this.checkServerSettingsOrThrow();
+  var transports = [fb.login.transports.Popup, fb.login.transports.CordovaInAppBrowser], requestInfo = fb.login.RequestInfo.fromParams(opt_params), width = 625, height = 625;
+  if (provider === "anonymous" || provider === "password") {
+    setTimeout(function() {
+      fb.core.util.callUserCallback(opt_onComplete, fb.login.Errors.get("TRANSPORT_UNAVAILABLE"));
+    }, 0);
+    return;
+  }
+  requestInfo.transportOptions["window_features"] = "" + "menubar=yes," + "modal=yes," + "alwaysRaised=yes" + "location=yes," + "resizable=yes," + "scrollbars=yes," + "status=yes," + "height=" + height + "," + "width=" + width + "," + "top=" + (typeof screen === "object" ? (screen["height"] - height) * .5 : 0) + "," + "left=" + (typeof screen === "object" ? (screen["width"] - width) * .5 : 0);
+  requestInfo.transportOptions["relay_url"] = fb.login.transports.util.getPopupChannelUrl(this.repoInfo_.namespace);
+  requestInfo.transportOptions["requestWithCredential"] = goog.bind(this.requestWithCredential, this);
+  this.authWithTransports_(transports, "/auth/" + provider, requestInfo, opt_onComplete);
+};
+fb.login.AuthenticationManager.prototype.authWithRedirect = function(provider, opt_params, opt_onErr) {
+  this.checkServerSettingsOrThrow();
+  var transports = [fb.login.transports.Redirect], requestInfo = fb.login.RequestInfo.fromParams(opt_params);
+  if (provider === "anonymous" || provider === "firebase") {
+    fb.core.util.callUserCallback(opt_onErr, fb.login.Errors.get("TRANSPORT_UNAVAILABLE"));
+    return;
+  }
+  fb.core.storage.SessionStorage.set(fb.login.Constants.REDIR_CLIENT_OPTIONS_KEY, requestInfo.clientOptions);
+  this.authWithTransports_(transports, "/auth/" + provider, requestInfo, opt_onErr);
+};
+fb.login.AuthenticationManager.prototype.finishOAuthRedirectLogin_ = function() {
+  var redirectRequestId = fb.core.storage.SessionStorage.get(fb.login.Constants.REDIR_REQUEST_ID_KEY);
+  if (redirectRequestId) {
+    var clientOptions = fb.core.storage.SessionStorage.get(fb.login.Constants.REDIR_CLIENT_OPTIONS_KEY);
+    fb.core.storage.SessionStorage.remove(fb.login.Constants.REDIR_REQUEST_ID_KEY);
+    fb.core.storage.SessionStorage.remove(fb.login.Constants.REDIR_CLIENT_OPTIONS_KEY);
+    var transports = [fb.login.transports.XHR, fb.login.transports.JSONP], serverParams = {"requestId":redirectRequestId, "requestKey":fb.login.transports.util.extractRedirectCompletionHash(document.location.hash)}, transportOptions = {}, requestInfo = new fb.login.RequestInfo(clientOptions, transportOptions, serverParams);
+    this.redirectRestart_ = true;
+    fb.login.transports.util.replaceRedirectCompletionHash();
+    this.authWithTransports_(transports, "/auth/session", requestInfo, function(error) {
+      this.redirectRestart_ = false;
+    }.bind(this));
+  }
+};
+fb.login.AuthenticationManager.prototype.createUser = function(params, opt_onComplete) {
+  this.checkServerSettingsOrThrow();
+  var path = "/users";
+  var requestInfo = fb.login.RequestInfo.fromParams(params);
+  requestInfo.serverParams["_method"] = "POST";
+  this.requestWithCredential(path, requestInfo, function(err, res) {
+    if (err) {
+      fb.core.util.callUserCallback(opt_onComplete, err);
+    } else {
+      fb.core.util.callUserCallback(opt_onComplete, err, res);
+    }
+  });
+};
+fb.login.AuthenticationManager.prototype.removeUser = function(params, opt_onComplete) {
+  var self = this;
+  this.checkServerSettingsOrThrow();
+  var path = "/users/" + encodeURIComponent(params["email"]);
+  var requestInfo = fb.login.RequestInfo.fromParams(params);
+  requestInfo.serverParams["_method"] = "DELETE";
+  this.requestWithCredential(path, requestInfo, function(err, res) {
+    if (!err && res && res["uid"]) {
+      if (self.authData_ && self.authData_["uid"] && self.authData_["uid"] === res["uid"]) {
+        self.unauthenticate();
+      }
+    }
+    fb.core.util.callUserCallback(opt_onComplete, err);
+  });
+};
+fb.login.AuthenticationManager.prototype.changePassword = function(params, opt_onComplete) {
+  this.checkServerSettingsOrThrow();
+  var path = "/users/" + encodeURIComponent(params["email"]) + "/password";
+  var requestInfo = fb.login.RequestInfo.fromParams(params);
+  requestInfo.serverParams["_method"] = "PUT";
+  requestInfo.serverParams["password"] = params["newPassword"];
+  this.requestWithCredential(path, requestInfo, function(err, res) {
+    fb.core.util.callUserCallback(opt_onComplete, err);
+  });
+};
+fb.login.AuthenticationManager.prototype.changeEmail = function(params, opt_onComplete) {
+  this.checkServerSettingsOrThrow();
+  var path = "/users/" + encodeURIComponent(params["oldEmail"]) + "/email";
+  var requestInfo = fb.login.RequestInfo.fromParams(params);
+  requestInfo.serverParams["_method"] = "PUT";
+  requestInfo.serverParams["email"] = params["newEmail"];
+  requestInfo.serverParams["password"] = params["password"];
+  this.requestWithCredential(path, requestInfo, function(err, res) {
+    fb.core.util.callUserCallback(opt_onComplete, err);
+  });
+};
+fb.login.AuthenticationManager.prototype.resetPassword = function(params, opt_onComplete) {
+  this.checkServerSettingsOrThrow();
+  var path = "/users/" + encodeURIComponent(params["email"]) + "/password";
+  var requestInfo = fb.login.RequestInfo.fromParams(params);
+  requestInfo.serverParams["_method"] = "POST";
+  this.requestWithCredential(path, requestInfo, function(err, res) {
+    fb.core.util.callUserCallback(opt_onComplete, err);
+  });
+};
+fb.login.AuthenticationManager.prototype.requestWithCredential = function(path, requestInfo, opt_onComplete) {
+  var transports;
+  if (NODE_CLIENT) {
+    transports = [fb.login.transports.NodeHttp];
+  } else {
+    transports = [fb.login.transports.XHR, fb.login.transports.JSONP];
+  }
+  this.requestWithTransports_(transports, path, requestInfo, opt_onComplete);
+};
+fb.login.AuthenticationManager.prototype.authWithTransports_ = function(transports, path, requestInfo, opt_onComplete) {
+  var self = this;
+  this.requestWithTransports_(transports, path, requestInfo, function onLoginReturned(err, res) {
+    if (err || !(res && res["token"] && res["uid"])) {
+      fb.core.util.callUserCallback(opt_onComplete, err || fb.login.Errors.get("UNKNOWN_ERROR"));
+    } else {
+      res = (res);
+      self.authenticate(res["token"], res, requestInfo.clientOptions, function(err, authData) {
+        if (err) {
+          fb.core.util.callUserCallback(opt_onComplete, err);
+        } else {
+          fb.core.util.callUserCallback(opt_onComplete, null, authData);
+        }
+      });
+    }
+  });
+};
+fb.login.AuthenticationManager.prototype.requestWithTransports_ = function(transports, path, requestInfo, opt_onComplete) {
+  var availableTransports = goog.array.filter(transports, function(transport) {
+    return typeof transport["isAvailable"] === "function" && transport["isAvailable"]();
+  });
+  if (availableTransports.length === 0) {
+    setTimeout(function() {
+      fb.core.util.callUserCallback(opt_onComplete, fb.login.Errors.get("TRANSPORT_UNAVAILABLE"));
+    }, 0);
+    return;
+  }
+  var transport = availableTransports.shift();
+  var transportObj = new transport(requestInfo.transportOptions);
+  var request = fb.util.obj.clone(requestInfo.serverParams);
+  request["v"] = this.versionString();
+  request["transport"] = transportObj.classification();
+  request["suppress_status_codes"] = true;
+  var url = fb.login.transports.util.getBaseUrl() + "/" + this.repoInfo_.namespace + path;
+  transportObj.open(url, request, function onTransportReturned(err, res) {
+    if (err) {
+      fb.core.util.callUserCallback(opt_onComplete, err);
+    } else {
+      if (res && res["error"]) {
+        var e = new Error(res["error"]["message"]);
+        e["code"] = res["error"]["code"];
+        e["details"] = res["error"]["details"];
+        fb.core.util.callUserCallback(opt_onComplete, e);
+      } else {
+        fb.core.util.callUserCallback(opt_onComplete, null, res);
+      }
+    }
+  });
+};
+fb.login.AuthenticationManager.prototype.updateAuthStatus_ = function(authData) {
+  var stateChanged = this.authData_ !== null || authData !== null;
+  this.authData_ = authData;
+  if (stateChanged) {
+    this.trigger("auth_status", authData);
+  }
+  this.onAuthStatus_(authData !== null);
+};
+fb.login.AuthenticationManager.prototype.getInitialEvent = function(event) {
+  fb.core.util.assert(event === "auth_status", 'initial event must be of type "auth_status"');
+  if (this.redirectRestart_) {
+    return null;
+  }
+  return[this.authData_];
+};
+fb.login.AuthenticationManager.prototype.versionString = function() {
+  return(NODE_CLIENT ? "node-" : "js-") + CLIENT_VERSION;
+};
+fb.login.AuthenticationManager.prototype.checkServerSettingsOrThrow = function() {
+  if (this.repoInfo_.isCustomHost() && fb.login.Constants.SERVER_HOST === fb.login.Constants.DEFAULT_SERVER_HOST) {
+    throw new Error("This custom Firebase server ('" + this.repoInfo_.domain + "') does not support delegated login.");
+  }
+};
+goog.provide("fb.realtime.Transport");
+goog.require("fb.core.RepoInfo");
+fb.realtime.Transport = function(connId, repoInfo, sessionId) {
+};
+fb.realtime.Transport.prototype.open = function(onMessage, onDisconnect) {
+};
+fb.realtime.Transport.prototype.start = function() {
+};
+fb.realtime.Transport.prototype.close = function() {
+};
+fb.realtime.Transport.prototype.send = function(data) {
+};
+fb.realtime.Transport.prototype.bytesReceived;
+fb.realtime.Transport.prototype.bytesSent;
+goog.provide("fb.realtime.Constants");
+fb.realtime.Constants = {PROTOCOL_VERSION:"5", VERSION_PARAM:"v", SESSION_PARAM:"s", REFERER_PARAM:"r", FORGE_REF:"f", FORGE_DOMAIN:"firebaseio.com"};
+goog.provide("fb.realtime.polling.PacketReceiver");
+fb.realtime.polling.PacketReceiver = function(onMessage) {
+  this.onMessage_ = onMessage;
+  this.pendingResponses = [];
+  this.currentResponseNum = 0;
+  this.closeAfterResponse = -1;
+  this.onClose = null;
+};
+fb.realtime.polling.PacketReceiver.prototype.closeAfter = function(responseNum, callback) {
+  this.closeAfterResponse = responseNum;
+  this.onClose = callback;
+  if (this.closeAfterResponse < this.currentResponseNum) {
+    this.onClose();
+    this.onClose = null;
+  }
+};
+fb.realtime.polling.PacketReceiver.prototype.handleResponse = function(requestNum, data) {
+  this.pendingResponses[requestNum] = data;
+  while (this.pendingResponses[this.currentResponseNum]) {
+    var toProcess = this.pendingResponses[this.currentResponseNum];
+    delete this.pendingResponses[this.currentResponseNum];
+    for (var i = 0;i < toProcess.length;++i) {
+      if (toProcess[i]) {
+        var self = this;
+        fb.core.util.exceptionGuard(function() {
+          self.onMessage_(toProcess[i]);
+        });
+      }
+    }
+    if (this.currentResponseNum === this.closeAfterResponse) {
+      if (this.onClose) {
+        clearTimeout(this.onClose);
+        this.onClose();
+        this.onClose = null;
+      }
+      break;
+    }
+    this.currentResponseNum++;
+  }
+};
+goog.provide("fb.realtime.BrowserPollConnection");
+goog.require("fb.constants");
+goog.require("fb.core.stats.StatsManager");
+goog.require("fb.core.util");
+goog.require("fb.core.util.CountedSet");
+goog.require("fb.realtime.Constants");
+goog.require("fb.realtime.Transport");
+goog.require("fb.realtime.polling.PacketReceiver");
+goog.require("fb.util.json");
+var FIREBASE_LONGPOLL_START_PARAM = "start";
+var FIREBASE_LONGPOLL_CLOSE_COMMAND = "close";
+var FIREBASE_LONGPOLL_COMMAND_CB_NAME = "pLPCommand";
+var FIREBASE_LONGPOLL_DATA_CB_NAME = "pRTLPCB";
+var FIREBASE_LONGPOLL_ID_PARAM = "id";
+var FIREBASE_LONGPOLL_PW_PARAM = "pw";
+var FIREBASE_LONGPOLL_SERIAL_PARAM = "ser";
+var FIREBASE_LONGPOLL_CALLBACK_ID_PARAM = "cb";
+var FIREBASE_LONGPOLL_SEGMENT_NUM_PARAM = "seg";
+var FIREBASE_LONGPOLL_SEGMENTS_IN_PACKET = "ts";
+var FIREBASE_LONGPOLL_DATA_PARAM = "d";
+var FIREBASE_LONGPOLL_DISCONN_FRAME_PARAM = "disconn";
+var FIREBASE_LONGPOLL_DISCONN_FRAME_REQUEST_PARAM = "dframe";
+var MAX_URL_DATA_SIZE = 1870;
+var SEG_HEADER_SIZE = 30;
+var MAX_PAYLOAD_SIZE = MAX_URL_DATA_SIZE - SEG_HEADER_SIZE;
+var KEEPALIVE_REQUEST_INTERVAL = 25E3;
+var LP_CONNECT_TIMEOUT = 3E4;
+fb.realtime.BrowserPollConnection = function(connId, repoInfo, sessionId) {
+  this.connId = connId;
+  this.log_ = fb.core.util.logWrapper(connId);
+  this.repoInfo = repoInfo;
+  this.bytesSent = 0;
+  this.bytesReceived = 0;
+  this.stats_ = fb.core.stats.StatsManager.getCollection(repoInfo);
+  this.sessionId = sessionId;
+  this.everConnected_ = false;
+  this.urlFn = function(params) {
+    if (repoInfo.needsQueryParam()) {
+      params["ns"] = repoInfo.namespace;
+    }
+    var pairs = [];
+    for (var k in params) {
+      if (params.hasOwnProperty(k)) {
+        pairs.push(k + "=" + params[k]);
+      }
+    }
+    return(repoInfo.secure ? "https://" : "http://") + repoInfo.internalHost + "/.lp?" + pairs.join("&");
+  };
+};
+fb.realtime.BrowserPollConnection.prototype.open = function(onMessage, onDisconnect) {
+  this.curSegmentNum = 0;
+  this.onDisconnect_ = onDisconnect;
+  this.myPacketOrderer = new fb.realtime.polling.PacketReceiver(onMessage);
+  this.isClosed_ = false;
+  var self = this;
+  this.connectTimeoutTimer_ = setTimeout(function() {
+    self.log_("Timed out trying to connect.");
+    self.onClosed_();
+    self.connectTimeoutTimer_ = null;
+  }, Math.floor(LP_CONNECT_TIMEOUT));
+  fb.core.util.executeWhenDOMReady(function() {
+    if (self.isClosed_) {
+      return;
+    }
+    self.scriptTagHolder = new FirebaseIFrameScriptHolder(function(command, arg1, arg2, arg3, arg4) {
+      self.incrementIncomingBytes_(arguments);
+      if (!self.scriptTagHolder) {
+        return;
+      }
+      if (self.connectTimeoutTimer_) {
+        clearTimeout(self.connectTimeoutTimer_);
+        self.connectTimeoutTimer_ = null;
+      }
+      self.everConnected_ = true;
+      if (command == FIREBASE_LONGPOLL_START_PARAM) {
+        self.id = arg1;
+        self.password = arg2;
+      } else {
+        if (command === FIREBASE_LONGPOLL_CLOSE_COMMAND) {
+          if (arg1) {
+            self.scriptTagHolder.sendNewPolls = false;
+            self.myPacketOrderer.closeAfter(arg1, function() {
+              self.onClosed_();
+            });
+          } else {
+            self.onClosed_();
+          }
+        } else {
+          throw new Error("Unrecognized command received: " + command);
+        }
+      }
+    }, function(pN, data) {
+      self.incrementIncomingBytes_(arguments);
+      self.myPacketOrderer.handleResponse(pN, data);
+    }, function() {
+      self.onClosed_();
+    }, self.urlFn);
+    var urlParams = {};
+    urlParams[FIREBASE_LONGPOLL_START_PARAM] = "t";
+    urlParams[FIREBASE_LONGPOLL_SERIAL_PARAM] = Math.floor(Math.random() * 1E8);
+    if (self.scriptTagHolder.uniqueCallbackIdentifier) {
+      urlParams[FIREBASE_LONGPOLL_CALLBACK_ID_PARAM] = self.scriptTagHolder.uniqueCallbackIdentifier;
+    }
+    urlParams[fb.realtime.Constants.VERSION_PARAM] = fb.realtime.Constants.PROTOCOL_VERSION;
+    if (self.sessionId) {
+      urlParams[fb.realtime.Constants.SESSION_PARAM] = self.sessionId;
+    }
+    if (!NODE_CLIENT && typeof location !== "undefined" && location.href && location.href.indexOf(fb.realtime.Constants.FORGE_DOMAIN) !== -1) {
+      urlParams[fb.realtime.Constants.REFERER_PARAM] = fb.realtime.Constants.FORGE_REF;
+    }
+    var connectURL = self.urlFn(urlParams);
+    self.log_("Connecting via long-poll to " + connectURL);
+    self.scriptTagHolder.addTag(connectURL, function() {
+    });
+  });
+};
+fb.realtime.BrowserPollConnection.prototype.start = function() {
+  this.scriptTagHolder.startLongPoll(this.id, this.password);
+  this.addDisconnectPingFrame(this.id, this.password);
+};
+fb.realtime.BrowserPollConnection.forceAllow = function() {
+  fb.realtime.BrowserPollConnection.forceAllow_ = true;
+};
+fb.realtime.BrowserPollConnection.forceDisallow = function() {
+  fb.realtime.BrowserPollConnection.forceDisallow_ = true;
+};
+fb.realtime.BrowserPollConnection["isAvailable"] = function() {
+  return!fb.realtime.BrowserPollConnection.forceDisallow_ && !fb.core.util.isChromeExtensionContentScript() && !fb.core.util.isWindowsStoreApp() && (fb.realtime.BrowserPollConnection.forceAllow_ || !NODE_CLIENT);
+};
+fb.realtime.BrowserPollConnection.prototype.markConnectionHealthy = function() {
+};
+fb.realtime.BrowserPollConnection.prototype.shutdown_ = function() {
+  this.isClosed_ = true;
+  if (this.scriptTagHolder) {
+    this.scriptTagHolder.close();
+    this.scriptTagHolder = null;
+  }
+  if (this.myDisconnFrame) {
+    document.body.removeChild(this.myDisconnFrame);
+    this.myDisconnFrame = null;
+  }
+  if (this.connectTimeoutTimer_) {
+    clearTimeout(this.connectTimeoutTimer_);
+    this.connectTimeoutTimer_ = null;
+  }
+};
+fb.realtime.BrowserPollConnection.prototype.onClosed_ = function() {
+  if (!this.isClosed_) {
+    this.log_("Longpoll is closing itself");
+    this.shutdown_();
+    if (this.onDisconnect_) {
+      this.onDisconnect_(this.everConnected_);
+      this.onDisconnect_ = null;
+    }
+  }
+};
+fb.realtime.BrowserPollConnection.prototype.close = function() {
+  if (!this.isClosed_) {
+    this.log_("Longpoll is being closed.");
+    this.shutdown_();
+  }
+};
+fb.realtime.BrowserPollConnection.prototype.send = function(data) {
+  var dataStr = fb.util.json.stringify(data);
+  this.bytesSent += dataStr.length;
+  this.stats_.incrementCounter("bytes_sent", dataStr.length);
+  var base64data = fb.core.util.base64Encode(dataStr);
+  var dataSegs = fb.core.util.splitStringBySize(base64data, MAX_PAYLOAD_SIZE);
+  for (var i = 0;i < dataSegs.length;i++) {
+    this.scriptTagHolder.enqueueSegment(this.curSegmentNum, dataSegs.length, dataSegs[i]);
+    this.curSegmentNum++;
+  }
+};
+fb.realtime.BrowserPollConnection.prototype.addDisconnectPingFrame = function(id, pw) {
+  if (NODE_CLIENT) {
+    return;
+  }
+  this.myDisconnFrame = document.createElement("iframe");
+  var urlParams = {};
+  urlParams[FIREBASE_LONGPOLL_DISCONN_FRAME_REQUEST_PARAM] = "t";
+  urlParams[FIREBASE_LONGPOLL_ID_PARAM] = id;
+  urlParams[FIREBASE_LONGPOLL_PW_PARAM] = pw;
+  this.myDisconnFrame.src = this.urlFn(urlParams);
+  this.myDisconnFrame.style.display = "none";
+  document.body.appendChild(this.myDisconnFrame);
+};
+fb.realtime.BrowserPollConnection.prototype.incrementIncomingBytes_ = function(args) {
+  var bytesReceived = fb.util.json.stringify(args).length;
+  this.bytesReceived += bytesReceived;
+  this.stats_.incrementCounter("bytes_received", bytesReceived);
+};
+function FirebaseIFrameScriptHolder(commandCB, onMessageCB, onDisconnectCB, urlFn) {
+  this.urlFn = urlFn;
+  this.onDisconnect = onDisconnectCB;
+  this.outstandingRequests = new fb.core.util.CountedSet;
+  this.pendingSegs = [];
+  this.currentSerial = Math.floor(Math.random() * 1E8);
+  this.sendNewPolls = true;
+  if (!NODE_CLIENT) {
+    this.uniqueCallbackIdentifier = fb.core.util.LUIDGenerator();
+    window[FIREBASE_LONGPOLL_COMMAND_CB_NAME + this.uniqueCallbackIdentifier] = commandCB;
+    window[FIREBASE_LONGPOLL_DATA_CB_NAME + this.uniqueCallbackIdentifier] = onMessageCB;
+    this.myIFrame = this.createIFrame_();
+    var script = "";
+    if (this.myIFrame.src && this.myIFrame.src.substr(0, "javascript:".length) === "javascript:") {
+      var currentDomain = document.domain;
+      script = '<script>document.domain="' + currentDomain + '";\x3c/script>';
+    }
+    var iframeContents = "<html><body>" + script + "</body></html>";
+    try {
+      this.myIFrame.doc.open();
+      this.myIFrame.doc.write(iframeContents);
+      this.myIFrame.doc.close();
+    } catch (e) {
+      fb.core.util.log("frame writing exception");
+      if (e.stack) {
+        fb.core.util.log(e.stack);
+      }
+      fb.core.util.log(e);
+    }
+  } else {
+    this.commandCB = commandCB;
+    this.onMessageCB = onMessageCB;
+  }
+}
+FirebaseIFrameScriptHolder.prototype.createIFrame_ = function() {
+  var iframe = document.createElement("iframe");
+  iframe.style.display = "none";
+  if (document.body) {
+    document.body.appendChild(iframe);
+    try {
+      var a = iframe.contentWindow.document;
+      if (!a) {
+        fb.core.util.log("No IE domain setting required");
+      }
+    } catch (e) {
+      var domain = document.domain;
+      iframe.src = "javascript:void((function(){document.open();document.domain='" + domain + "';document.close();})())";
+    }
+  } else {
+    throw "Document body has not initialized. Wait to initialize Firebase until after the document is ready.";
+  }
+  if (iframe.contentDocument) {
+    iframe.doc = iframe.contentDocument;
+  } else {
+    if (iframe.contentWindow) {
+      iframe.doc = iframe.contentWindow.document;
+    } else {
+      if (iframe.document) {
+        iframe.doc = iframe.document;
+      }
+    }
+  }
+  return iframe;
+};
+FirebaseIFrameScriptHolder.prototype.close = function() {
+  this.alive = false;
+  if (this.myIFrame) {
+    this.myIFrame.doc.body.innerHTML = "";
+    var self = this;
+    setTimeout(function() {
+      if (self.myIFrame !== null) {
+        document.body.removeChild(self.myIFrame);
+        self.myIFrame = null;
+      }
+    }, Math.floor(0));
+  }
+  if (NODE_CLIENT && this.myID) {
+    var urlParams = {};
+    urlParams[FIREBASE_LONGPOLL_DISCONN_FRAME_PARAM] = "t";
+    urlParams[FIREBASE_LONGPOLL_ID_PARAM] = this.myID;
+    urlParams[FIREBASE_LONGPOLL_PW_PARAM] = this.myPW;
+    var theURL = this.urlFn(urlParams);
+    FirebaseIFrameScriptHolder.nodeRestRequest(theURL);
+  }
+  var onDisconnect = this.onDisconnect;
+  if (onDisconnect) {
+    this.onDisconnect = null;
+    onDisconnect();
+  }
+};
+FirebaseIFrameScriptHolder.prototype.startLongPoll = function(id, pw) {
+  this.myID = id;
+  this.myPW = pw;
+  this.alive = true;
+  while (this.newRequest_()) {
+  }
+};
+FirebaseIFrameScriptHolder.prototype.newRequest_ = function() {
+  if (this.alive && this.sendNewPolls && this.outstandingRequests.count() < (this.pendingSegs.length > 0 ? 2 : 1)) {
+    this.currentSerial++;
+    var urlParams = {};
+    urlParams[FIREBASE_LONGPOLL_ID_PARAM] = this.myID;
+    urlParams[FIREBASE_LONGPOLL_PW_PARAM] = this.myPW;
+    urlParams[FIREBASE_LONGPOLL_SERIAL_PARAM] = this.currentSerial;
+    var theURL = this.urlFn(urlParams);
+    var curDataString = "";
+    var i = 0;
+    while (this.pendingSegs.length > 0) {
+      var nextSeg = this.pendingSegs[0];
+      if (nextSeg.d.length + SEG_HEADER_SIZE + curDataString.length <= MAX_URL_DATA_SIZE) {
+        var theSeg = this.pendingSegs.shift();
+        curDataString = curDataString + "&" + FIREBASE_LONGPOLL_SEGMENT_NUM_PARAM + i + "=" + theSeg.seg + "&" + FIREBASE_LONGPOLL_SEGMENTS_IN_PACKET + i + "=" + theSeg.ts + "&" + FIREBASE_LONGPOLL_DATA_PARAM + i + "=" + theSeg.d;
+        i++;
+      } else {
+        break;
+      }
+    }
+    theURL = theURL + curDataString;
+    this.addLongPollTag_(theURL, this.currentSerial);
+    return true;
+  } else {
+    return false;
+  }
+};
+FirebaseIFrameScriptHolder.prototype.enqueueSegment = function(segnum, totalsegs, data) {
+  this.pendingSegs.push({seg:segnum, ts:totalsegs, d:data});
+  if (this.alive) {
+    this.newRequest_();
+  }
+};
+FirebaseIFrameScriptHolder.prototype.addLongPollTag_ = function(url, serial) {
+  var self = this;
+  self.outstandingRequests.add(serial, 1);
+  var doNewRequest = function() {
+    self.outstandingRequests.remove(serial);
+    self.newRequest_();
+  };
+  var keepaliveTimeout = setTimeout(doNewRequest, Math.floor(KEEPALIVE_REQUEST_INTERVAL));
+  var readyStateCB = function() {
+    clearTimeout(keepaliveTimeout);
+    doNewRequest();
+  };
+  this.addTag(url, readyStateCB);
+};
+FirebaseIFrameScriptHolder.prototype.addTag = function(url, loadCB) {
+  if (NODE_CLIENT) {
+    this.doNodeLongPoll(url, loadCB);
+  } else {
+    var self = this;
+    setTimeout(function() {
+      try {
+        if (!self.sendNewPolls) {
+          return;
+        }
+        var newScript = self.myIFrame.doc.createElement("script");
+        newScript.type = "text/javascript";
+        newScript.async = true;
+        newScript.src = url;
+        newScript.onload = newScript.onreadystatechange = function() {
+          var rstate = newScript.readyState;
+          if (!rstate || rstate === "loaded" || rstate === "complete") {
+            newScript.onload = newScript.onreadystatechange = null;
+            if (newScript.parentNode) {
+              newScript.parentNode.removeChild(newScript);
+            }
+            loadCB();
+          }
+        };
+        newScript.onerror = function() {
+          fb.core.util.log("Long-poll script failed to load: " + url);
+          self.sendNewPolls = false;
+          self.close();
+        };
+        self.myIFrame.doc.body.appendChild(newScript);
+      } catch (e) {
+      }
+    }, Math.floor(1));
+  }
+};
+if (typeof NODE_CLIENT !== "undefined" && NODE_CLIENT) {
+  FirebaseIFrameScriptHolder.request = null;
+  FirebaseIFrameScriptHolder.nodeRestRequest = function(req, onComplete) {
+    if (!FirebaseIFrameScriptHolder.request) {
+      FirebaseIFrameScriptHolder.request = (require("request"));
+    }
+    FirebaseIFrameScriptHolder.request(req, function(error, response, body) {
+      if (error) {
+        throw "Rest request for " + req.url + " failed.";
+      }
+      if (onComplete) {
+        onComplete(body);
+      }
+    });
+  };
+  FirebaseIFrameScriptHolder.prototype.doNodeLongPoll = function(url, loadCB) {
+    var self = this;
+    FirebaseIFrameScriptHolder.nodeRestRequest({url:url, forever:true}, function(body) {
+      self.evalBody(body);
+      loadCB();
+    });
+  };
+  FirebaseIFrameScriptHolder.prototype.evalBody = function(body) {
+    eval("var jsonpCB = function(" + FIREBASE_LONGPOLL_COMMAND_CB_NAME + ", " + FIREBASE_LONGPOLL_DATA_CB_NAME + ") {" + body + "}");
+    jsonpCB(this.commandCB, this.onMessageCB);
+  };
+}
+;goog.provide("fb.realtime.WebSocketConnection");
+goog.require("fb.constants");
+goog.require("fb.core.stats.StatsManager");
+goog.require("fb.core.storage");
+goog.require("fb.core.util");
+goog.require("fb.realtime.Constants");
+goog.require("fb.realtime.Transport");
+goog.require("fb.util.json");
+var WEBSOCKET_MAX_FRAME_SIZE = 16384;
+var WEBSOCKET_KEEPALIVE_INTERVAL = 45E3;
+fb.WebSocket = null;
+if (NODE_CLIENT) {
+  goog.require("fb.core.util.NodePatches");
+  fb.WebSocket = require("faye-websocket")["Client"];
+} else {
+  if (typeof MozWebSocket !== "undefined") {
+    fb.WebSocket = MozWebSocket;
+  } else {
+    if (typeof WebSocket !== "undefined") {
+      fb.WebSocket = WebSocket;
+    }
+  }
+}
+fb.realtime.WebSocketConnection = function(connId, repoInfo, sessionId) {
+  this.connId = connId;
+  this.log_ = fb.core.util.logWrapper(this.connId);
+  this.keepaliveTimer = null;
+  this.frames = null;
+  this.totalFrames = 0;
+  this.bytesSent = 0;
+  this.bytesReceived = 0;
+  this.stats_ = fb.core.stats.StatsManager.getCollection(repoInfo);
+  this.connURL = (repoInfo.secure ? "wss://" : "ws://") + repoInfo.internalHost + "/.ws?" + fb.realtime.Constants.VERSION_PARAM + "=" + fb.realtime.Constants.PROTOCOL_VERSION;
+  if (!NODE_CLIENT && typeof location !== "undefined" && location.href && location.href.indexOf(fb.realtime.Constants.FORGE_DOMAIN) !== -1) {
+    this.connURL = this.connURL + "&" + fb.realtime.Constants.REFERER_PARAM + "=" + fb.realtime.Constants.FORGE_REF;
+  }
+  if (repoInfo.needsQueryParam()) {
+    this.connURL = this.connURL + "&ns=" + repoInfo.namespace;
+  }
+  if (sessionId) {
+    this.connURL = this.connURL + "&" + fb.realtime.Constants.SESSION_PARAM + "=" + sessionId;
+  }
+};
+fb.realtime.WebSocketConnection.prototype.open = function(onMess, onDisconn) {
+  this.onDisconnect = onDisconn;
+  this.onMessage = onMess;
+  this.log_("Websocket connecting to " + this.connURL);
+  this.everConnected_ = false;
+  fb.core.storage.PersistentStorage.set("previous_websocket_failure", true);
+  try {
+    if (NODE_CLIENT) {
+      var options = {"headers":{"User-Agent":"Firebase/" + fb.realtime.Constants.PROTOCOL_VERSION + "/" + CLIENT_VERSION + "/" + process.platform + "/Node"}};
+      this.mySock = new fb.WebSocket(this.connURL, [], options);
+    } else {
+      this.mySock = new fb.WebSocket(this.connURL);
+    }
+  } catch (e) {
+    this.log_("Error instantiating WebSocket.");
+    var error = e.message || e.data;
+    if (error) {
+      this.log_(error);
+    }
+    this.onClosed_();
+    return;
+  }
+  var self = this;
+  this.mySock.onopen = function() {
+    self.log_("Websocket connected.");
+    self.everConnected_ = true;
+  };
+  this.mySock.onclose = function() {
+    self.log_("Websocket connection was disconnected.");
+    self.mySock = null;
+    self.onClosed_();
+  };
+  this.mySock.onmessage = function(m) {
+    self.handleIncomingFrame(m);
+  };
+  this.mySock.onerror = function(e) {
+    self.log_("WebSocket error.  Closing connection.");
+    var error = e.message || e.data;
+    if (error) {
+      self.log_(error);
+    }
+    self.onClosed_();
+  };
+};
+fb.realtime.WebSocketConnection.prototype.start = function() {
+};
+fb.realtime.WebSocketConnection.forceDisallow = function() {
+  fb.realtime.WebSocketConnection.forceDisallow_ = true;
+};
+fb.realtime.WebSocketConnection["isAvailable"] = function() {
+  var isOldAndroid = false;
+  if (typeof navigator !== "undefined" && navigator.userAgent) {
+    var oldAndroidRegex = /Android ([0-9]{0,}\.[0-9]{0,})/;
+    var oldAndroidMatch = navigator.userAgent.match(oldAndroidRegex);
+    if (oldAndroidMatch && oldAndroidMatch.length > 1) {
+      if (parseFloat(oldAndroidMatch[1]) < 4.4) {
+        isOldAndroid = true;
+      }
+    }
+  }
+  return!isOldAndroid && fb.WebSocket !== null && !fb.realtime.WebSocketConnection.forceDisallow_;
+};
+fb.realtime.WebSocketConnection["responsesRequiredToBeHealthy"] = 2;
+fb.realtime.WebSocketConnection["healthyTimeout"] = 3E4;
+fb.realtime.WebSocketConnection.previouslyFailed = function() {
+  return fb.core.storage.PersistentStorage.isInMemoryStorage || fb.core.storage.PersistentStorage.get("previous_websocket_failure") === true;
+};
+fb.realtime.WebSocketConnection.prototype.markConnectionHealthy = function() {
+  fb.core.storage.PersistentStorage.remove("previous_websocket_failure");
+};
+fb.realtime.WebSocketConnection.prototype.appendFrame_ = function(data) {
+  this.frames.push(data);
+  if (this.frames.length == this.totalFrames) {
+    var fullMess = this.frames.join("");
+    this.frames = null;
+    var jsonMess = fb.util.json.eval(fullMess);
+    this.onMessage(jsonMess);
+  }
+};
+fb.realtime.WebSocketConnection.prototype.handleNewFrameCount_ = function(frameCount) {
+  this.totalFrames = frameCount;
+  this.frames = [];
+};
+fb.realtime.WebSocketConnection.prototype.extractFrameCount_ = function(data) {
+  fb.core.util.assert(this.frames === null, "We already have a frame buffer");
+  if (data.length <= 6) {
+    var frameCount = Number(data);
+    if (!isNaN(frameCount)) {
+      this.handleNewFrameCount_(frameCount);
+      return null;
+    }
+  }
+  this.handleNewFrameCount_(1);
+  return data;
+};
+fb.realtime.WebSocketConnection.prototype.handleIncomingFrame = function(mess) {
+  if (this.mySock === null) {
+    return;
+  }
+  var data = mess["data"];
+  this.bytesReceived += data.length;
+  this.stats_.incrementCounter("bytes_received", data.length);
+  this.resetKeepAlive();
+  if (this.frames !== null) {
+    this.appendFrame_(data);
+  } else {
+    var remainingData = this.extractFrameCount_(data);
+    if (remainingData !== null) {
+      this.appendFrame_(remainingData);
+    }
+  }
+};
+fb.realtime.WebSocketConnection.prototype.send = function(data) {
+  this.resetKeepAlive();
+  var dataStr = fb.util.json.stringify(data);
+  this.bytesSent += dataStr.length;
+  this.stats_.incrementCounter("bytes_sent", dataStr.length);
+  var dataSegs = fb.core.util.splitStringBySize(dataStr, WEBSOCKET_MAX_FRAME_SIZE);
+  if (dataSegs.length > 1) {
+    this.mySock.send(String(dataSegs.length));
+  }
+  for (var i = 0;i < dataSegs.length;i++) {
+    this.mySock.send(dataSegs[i]);
+  }
+};
+fb.realtime.WebSocketConnection.prototype.shutdown_ = function() {
+  this.isClosed_ = true;
+  if (this.keepaliveTimer) {
+    clearInterval(this.keepaliveTimer);
+    this.keepaliveTimer = null;
+  }
+  if (this.mySock) {
+    this.mySock.close();
+    this.mySock = null;
+  }
+};
+fb.realtime.WebSocketConnection.prototype.onClosed_ = function() {
+  if (!this.isClosed_) {
+    this.log_("WebSocket is closing itself");
+    this.shutdown_();
+    if (this.onDisconnect) {
+      this.onDisconnect(this.everConnected_);
+      this.onDisconnect = null;
+    }
+  }
+};
+fb.realtime.WebSocketConnection.prototype.close = function() {
+  if (!this.isClosed_) {
+    this.log_("WebSocket is being closed");
+    this.shutdown_();
+  }
+};
+fb.realtime.WebSocketConnection.prototype.resetKeepAlive = function() {
+  var self = this;
+  clearInterval(this.keepaliveTimer);
+  this.keepaliveTimer = setInterval(function() {
+    if (self.mySock) {
+      self.mySock.send("0");
+    }
+    self.resetKeepAlive();
+  }, Math.floor(WEBSOCKET_KEEPALIVE_INTERVAL));
+};
+goog.require("fb.constants");
+goog.require("fb.realtime.BrowserPollConnection");
+goog.require("fb.realtime.Transport");
+goog.provide("fb.realtime.TransportManager");
+goog.require("fb.realtime.WebSocketConnection");
+fb.realtime.TransportManager = function(repoInfo) {
+  this.initTransports_(repoInfo);
+};
+fb.realtime.TransportManager.ALL_TRANSPORTS = [fb.realtime.BrowserPollConnection, fb.realtime.WebSocketConnection];
+fb.realtime.TransportManager.prototype.initTransports_ = function(repoInfo) {
+  var isWebSocketsAvailable = fb.realtime.WebSocketConnection && fb.realtime.WebSocketConnection["isAvailable"]();
+  var isSkipPollConnection = isWebSocketsAvailable && !fb.realtime.WebSocketConnection.previouslyFailed();
+  if (repoInfo.webSocketOnly) {
+    if (!isWebSocketsAvailable) {
+      fb.core.util.warn("wss:// URL used, but browser isn't known to support websockets.  Trying anyway.");
+    }
+    isSkipPollConnection = true;
+  }
+  if (isSkipPollConnection) {
+    this.transports_ = [fb.realtime.WebSocketConnection];
+  } else {
+    var transports = this.transports_ = [];
+    fb.core.util.each(fb.realtime.TransportManager.ALL_TRANSPORTS, function(i, transport) {
+      if (transport && transport["isAvailable"]()) {
+        transports.push(transport);
+      }
+    });
+  }
+};
+fb.realtime.TransportManager.prototype.initialTransport = function() {
+  if (this.transports_.length > 0) {
+    return this.transports_[0];
+  } else {
+    throw new Error("No transports available");
+  }
+};
+fb.realtime.TransportManager.prototype.upgradeTransport = function() {
+  if (this.transports_.length > 1) {
+    return this.transports_[1];
+  } else {
+    return null;
+  }
+};
+goog.provide("fb.realtime.Connection");
+goog.require("fb.core.storage");
+goog.require("fb.core.util");
+goog.require("fb.realtime.Constants");
+goog.require("fb.realtime.TransportManager");
+var UPGRADE_TIMEOUT = 6E4;
+var DELAY_BEFORE_SENDING_EXTRA_REQUESTS = 5E3;
+var BYTES_SENT_HEALTHY_OVERRIDE = 10 * 1024;
+var BYTES_RECEIVED_HEALTHY_OVERRIDE = 100 * 1024;
+var REALTIME_STATE_CONNECTING = 0;
+var REALTIME_STATE_CONNECTED = 1;
+var REALTIME_STATE_DISCONNECTED = 2;
+var MESSAGE_TYPE = "t";
+var MESSAGE_DATA = "d";
+var CONTROL_SHUTDOWN = "s";
+var CONTROL_RESET = "r";
+var CONTROL_ERROR = "e";
+var CONTROL_PONG = "o";
+var SWITCH_ACK = "a";
+var END_TRANSMISSION = "n";
+var PING = "p";
+var SERVER_HELLO = "h";
+fb.realtime.Connection = function(connId, repoInfo, onMessage, onReady, onDisconnect, onKill) {
+  this.id = connId;
+  this.log_ = fb.core.util.logWrapper("c:" + this.id + ":");
+  this.onMessage_ = onMessage;
+  this.onReady_ = onReady;
+  this.onDisconnect_ = onDisconnect;
+  this.onKill_ = onKill;
+  this.repoInfo_ = repoInfo;
+  this.pendingDataMessages = [];
+  this.connectionCount = 0;
+  this.transportManager_ = new fb.realtime.TransportManager(repoInfo);
+  this.state_ = REALTIME_STATE_CONNECTING;
+  this.log_("Connection created");
+  this.start_();
+};
+fb.realtime.Connection.prototype.start_ = function() {
+  var conn = this.transportManager_.initialTransport();
+  this.conn_ = new conn(this.nextTransportId_(), this.repoInfo_);
+  this.primaryResponsesRequired_ = conn["responsesRequiredToBeHealthy"] || 0;
+  var onMessageReceived = this.connReceiver_(this.conn_);
+  var onConnectionLost = this.disconnReceiver_(this.conn_);
+  this.tx_ = this.conn_;
+  this.rx_ = this.conn_;
+  this.secondaryConn_ = null;
+  this.isHealthy_ = false;
+  var self = this;
+  setTimeout(function() {
+    self.conn_ && self.conn_.open(onMessageReceived, onConnectionLost);
+  }, Math.floor(0));
+  var healthyTimeout_ms = conn["healthyTimeout"] || 0;
+  if (healthyTimeout_ms > 0) {
+    this.healthyTimeout_ = setTimeout(function() {
+      self.healthyTimeout_ = null;
+      if (!self.isHealthy_) {
+        if (self.conn_ && self.conn_.bytesReceived > BYTES_RECEIVED_HEALTHY_OVERRIDE) {
+          self.log_("Connection exceeded healthy timeout but has received " + self.conn_.bytesReceived + " bytes.  Marking connection healthy.");
+          self.isHealthy_ = true;
+          self.conn_.markConnectionHealthy();
+        } else {
+          if (self.conn_ && self.conn_.bytesSent > BYTES_SENT_HEALTHY_OVERRIDE) {
+            self.log_("Connection exceeded healthy timeout but has sent " + self.conn_.bytesSent + " bytes.  Leaving connection alive.");
+          } else {
+            self.log_("Closing unhealthy connection after timeout.");
+            self.close();
+          }
+        }
+      }
+    }, Math.floor(healthyTimeout_ms));
+  }
+};
+fb.realtime.Connection.prototype.nextTransportId_ = function() {
+  return "c:" + this.id + ":" + this.connectionCount++;
+};
+fb.realtime.Connection.prototype.disconnReceiver_ = function(conn) {
+  var self = this;
+  return function(everConnected) {
+    if (conn === self.conn_) {
+      self.onConnectionLost_(everConnected);
+    } else {
+      if (conn === self.secondaryConn_) {
+        self.log_("Secondary connection lost.");
+        self.onSecondaryConnectionLost_();
+      } else {
+        self.log_("closing an old connection");
+      }
+    }
+  };
+};
+fb.realtime.Connection.prototype.connReceiver_ = function(conn) {
+  var self = this;
+  return function(message) {
+    if (self.state_ != REALTIME_STATE_DISCONNECTED) {
+      if (conn === self.rx_) {
+        self.onPrimaryMessageReceived_(message);
+      } else {
+        if (conn === self.secondaryConn_) {
+          self.onSecondaryMessageReceived_(message);
+        } else {
+          self.log_("message on old connection");
+        }
+      }
+    }
+  };
+};
+fb.realtime.Connection.prototype.sendRequest = function(dataMsg) {
+  var msg = {"t":"d", "d":dataMsg};
+  this.sendData_(msg);
+};
+fb.realtime.Connection.prototype.tryCleanupConnection = function() {
+  if (this.tx_ === this.secondaryConn_ && this.rx_ === this.secondaryConn_) {
+    this.log_("cleaning up and promoting a connection: " + this.secondaryConn_.connId);
+    this.conn_ = this.secondaryConn_;
+    this.secondaryConn_ = null;
+  }
+};
+fb.realtime.Connection.prototype.onSecondaryControl_ = function(controlData) {
+  if (MESSAGE_TYPE in controlData) {
+    var cmd = controlData[MESSAGE_TYPE];
+    if (cmd === SWITCH_ACK) {
+      this.upgradeIfSecondaryHealthy_();
+    } else {
+      if (cmd === CONTROL_RESET) {
+        this.log_("Got a reset on secondary, closing it");
+        this.secondaryConn_.close();
+        if (this.tx_ === this.secondaryConn_ || this.rx_ === this.secondaryConn_) {
+          this.close();
+        }
+      } else {
+        if (cmd === CONTROL_PONG) {
+          this.log_("got pong on secondary.");
+          this.secondaryResponsesRequired_--;
+          this.upgradeIfSecondaryHealthy_();
+        }
+      }
+    }
+  }
+};
+fb.realtime.Connection.prototype.onSecondaryMessageReceived_ = function(parsedData) {
+  var layer = fb.core.util.requireKey("t", parsedData);
+  var data = fb.core.util.requireKey("d", parsedData);
+  if (layer == "c") {
+    this.onSecondaryControl_(data);
+  } else {
+    if (layer == "d") {
+      this.pendingDataMessages.push(data);
+    } else {
+      throw new Error("Unknown protocol layer: " + layer);
+    }
+  }
+};
+fb.realtime.Connection.prototype.upgradeIfSecondaryHealthy_ = function() {
+  if (this.secondaryResponsesRequired_ <= 0) {
+    this.log_("Secondary connection is healthy.");
+    this.isHealthy_ = true;
+    this.secondaryConn_.markConnectionHealthy();
+    this.proceedWithUpgrade_();
+  } else {
+    this.log_("sending ping on secondary.");
+    this.secondaryConn_.send({"t":"c", "d":{"t":PING, "d":{}}});
+  }
+};
+fb.realtime.Connection.prototype.proceedWithUpgrade_ = function() {
+  this.secondaryConn_.start();
+  this.log_("sending client ack on secondary");
+  this.secondaryConn_.send({"t":"c", "d":{"t":SWITCH_ACK, "d":{}}});
+  this.log_("Ending transmission on primary");
+  this.conn_.send({"t":"c", "d":{"t":END_TRANSMISSION, "d":{}}});
+  this.tx_ = this.secondaryConn_;
+  this.tryCleanupConnection();
+};
+fb.realtime.Connection.prototype.onPrimaryMessageReceived_ = function(parsedData) {
+  var layer = fb.core.util.requireKey("t", parsedData);
+  var data = fb.core.util.requireKey("d", parsedData);
+  if (layer == "c") {
+    this.onControl_(data);
+  } else {
+    if (layer == "d") {
+      this.onDataMessage_(data);
+    }
+  }
+};
+fb.realtime.Connection.prototype.onDataMessage_ = function(message) {
+  this.onPrimaryResponse_();
+  this.onMessage_(message);
+};
+fb.realtime.Connection.prototype.onPrimaryResponse_ = function() {
+  if (!this.isHealthy_) {
+    this.primaryResponsesRequired_--;
+    if (this.primaryResponsesRequired_ <= 0) {
+      this.log_("Primary connection is healthy.");
+      this.isHealthy_ = true;
+      this.conn_.markConnectionHealthy();
+    }
+  }
+};
+fb.realtime.Connection.prototype.onControl_ = function(controlData) {
+  var cmd = fb.core.util.requireKey(MESSAGE_TYPE, controlData);
+  if (MESSAGE_DATA in controlData) {
+    var payload = controlData[MESSAGE_DATA];
+    if (cmd === SERVER_HELLO) {
+      this.onHandshake_(payload);
+    } else {
+      if (cmd === END_TRANSMISSION) {
+        this.log_("recvd end transmission on primary");
+        this.rx_ = this.secondaryConn_;
+        for (var i = 0;i < this.pendingDataMessages.length;++i) {
+          this.onDataMessage_(this.pendingDataMessages[i]);
+        }
+        this.pendingDataMessages = [];
+        this.tryCleanupConnection();
+      } else {
+        if (cmd === CONTROL_SHUTDOWN) {
+          this.onConnectionShutdown_(payload);
+        } else {
+          if (cmd === CONTROL_RESET) {
+            this.onReset_(payload);
+          } else {
+            if (cmd === CONTROL_ERROR) {
+              fb.core.util.error("Server Error: " + payload);
+            } else {
+              if (cmd === CONTROL_PONG) {
+                this.log_("got pong on primary.");
+                this.onPrimaryResponse_();
+                this.sendPingOnPrimaryIfNecessary_();
+              } else {
+                fb.core.util.error("Unknown control packet command: " + cmd);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+fb.realtime.Connection.prototype.onHandshake_ = function(handshake) {
+  var timestamp = handshake["ts"];
+  var version = handshake["v"];
+  var host = handshake["h"];
+  this.sessionId = handshake["s"];
+  this.repoInfo_.updateHost(host);
+  if (this.state_ == REALTIME_STATE_CONNECTING) {
+    this.conn_.start();
+    this.onConnectionEstablished_(this.conn_, timestamp);
+    if (fb.realtime.Constants.PROTOCOL_VERSION !== version) {
+      fb.core.util.warn("Protocol version mismatch detected");
+    }
+    this.tryStartUpgrade_();
+  }
+};
+fb.realtime.Connection.prototype.tryStartUpgrade_ = function() {
+  var conn = this.transportManager_.upgradeTransport();
+  if (conn) {
+    this.startUpgrade_(conn);
+  }
+};
+fb.realtime.Connection.prototype.startUpgrade_ = function(conn) {
+  this.secondaryConn_ = new conn(this.nextTransportId_(), this.repoInfo_, this.sessionId);
+  this.secondaryResponsesRequired_ = conn["responsesRequiredToBeHealthy"] || 0;
+  var onMessage = this.connReceiver_(this.secondaryConn_);
+  var onDisconnect = this.disconnReceiver_(this.secondaryConn_);
+  this.secondaryConn_.open(onMessage, onDisconnect);
+  var self = this;
+  setTimeout(function() {
+    if (self.secondaryConn_) {
+      self.log_("Timed out trying to upgrade.");
+      self.secondaryConn_.close();
+    }
+  }, Math.floor(UPGRADE_TIMEOUT));
+};
+fb.realtime.Connection.prototype.onReset_ = function(host) {
+  this.log_("Reset packet received.  New host: " + host);
+  this.repoInfo_.updateHost(host);
+  if (this.state_ === REALTIME_STATE_CONNECTED) {
+    this.close();
+  } else {
+    this.closeConnections_();
+    this.start_();
+  }
+};
+fb.realtime.Connection.prototype.onConnectionEstablished_ = function(conn, timestamp) {
+  this.log_("Realtime connection established.");
+  this.conn_ = conn;
+  this.state_ = REALTIME_STATE_CONNECTED;
+  if (this.onReady_) {
+    this.onReady_(timestamp);
+    this.onReady_ = null;
+  }
+  var self = this;
+  if (this.primaryResponsesRequired_ === 0) {
+    this.log_("Primary connection is healthy.");
+    this.isHealthy_ = true;
+  } else {
+    setTimeout(function() {
+      self.sendPingOnPrimaryIfNecessary_();
+    }, Math.floor(DELAY_BEFORE_SENDING_EXTRA_REQUESTS));
+  }
+};
+fb.realtime.Connection.prototype.sendPingOnPrimaryIfNecessary_ = function() {
+  if (!this.isHealthy_ && this.state_ === REALTIME_STATE_CONNECTED) {
+    this.log_("sending ping on primary.");
+    this.sendData_({"t":"c", "d":{"t":PING, "d":{}}});
+  }
+};
+fb.realtime.Connection.prototype.onSecondaryConnectionLost_ = function() {
+  var conn = this.secondaryConn_;
+  this.secondaryConn_ = null;
+  if (this.tx_ === conn || this.rx_ === conn) {
+    this.close();
+  }
+};
+fb.realtime.Connection.prototype.onConnectionLost_ = function(everConnected) {
+  this.conn_ = null;
+  if (!everConnected && this.state_ === REALTIME_STATE_CONNECTING) {
+    this.log_("Realtime connection failed.");
+    if (this.repoInfo_.isCacheableHost()) {
+      fb.core.storage.PersistentStorage.remove("host:" + this.repoInfo_.host);
+      this.repoInfo_.internalHost = this.repoInfo_.host;
+    }
+  } else {
+    if (this.state_ === REALTIME_STATE_CONNECTED) {
+      this.log_("Realtime connection lost.");
+    }
+  }
+  this.close();
+};
+fb.realtime.Connection.prototype.onConnectionShutdown_ = function(reason) {
+  this.log_("Connection shutdown command received. Shutting down...");
+  if (this.onKill_) {
+    this.onKill_(reason);
+    this.onKill_ = null;
+  }
+  this.onDisconnect_ = null;
+  this.close();
+};
+fb.realtime.Connection.prototype.sendData_ = function(data) {
+  if (this.state_ !== REALTIME_STATE_CONNECTED) {
+    throw "Connection is not connected";
+  } else {
+    this.tx_.send(data);
+  }
+};
+fb.realtime.Connection.prototype.close = function() {
+  if (this.state_ !== REALTIME_STATE_DISCONNECTED) {
+    this.log_("Closing realtime connection.");
+    this.state_ = REALTIME_STATE_DISCONNECTED;
+    this.closeConnections_();
+    if (this.onDisconnect_) {
+      this.onDisconnect_();
+      this.onDisconnect_ = null;
+    }
+  }
+};
+fb.realtime.Connection.prototype.closeConnections_ = function() {
+  this.log_("Shutting down all connections");
+  if (this.conn_) {
+    this.conn_.close();
+    this.conn_ = null;
+  }
+  if (this.secondaryConn_) {
+    this.secondaryConn_.close();
+    this.secondaryConn_ = null;
+  }
+  if (this.healthyTimeout_) {
+    clearTimeout(this.healthyTimeout_);
+    this.healthyTimeout_ = null;
+  }
+};
+goog.provide("fb.core.PersistentConnection");
+goog.require("fb.core.ServerActions");
+goog.require("fb.core.util");
+goog.require("fb.core.util.OnlineMonitor");
+goog.require("fb.core.util.VisibilityMonitor");
+goog.require("fb.login.util.environment");
+goog.require("fb.realtime.Connection");
+goog.require("fb.util.json");
+goog.require("fb.util.jwt");
+var RECONNECT_MIN_DELAY = 1E3;
+var RECONNECT_MAX_DELAY_DEFAULT = 60 * 5 * 1E3;
+var RECONNECT_MAX_DELAY_FOR_ADMINS = 30 * 1E3;
+var RECONNECT_DELAY_MULTIPLIER = 1.3;
+var RECONNECT_DELAY_RESET_TIMEOUT = 3E4;
+fb.core.PersistentConnection = function(repoInfo, onDataUpdate, onConnectStatus, onServerInfoUpdate) {
+  this.id = fb.core.PersistentConnection.nextPersistentConnectionId_++;
+  this.log_ = fb.core.util.logWrapper("p:" + this.id + ":");
+  this.interrupted_ = false;
+  this.killed_ = false;
+  this.listens_ = {};
+  this.outstandingPuts_ = [];
+  this.outstandingPutCount_ = 0;
+  this.onDisconnectRequestQueue_ = [];
+  this.connected_ = false;
+  this.reconnectDelay_ = RECONNECT_MIN_DELAY;
+  this.maxReconnectDelay_ = RECONNECT_MAX_DELAY_DEFAULT;
+  this.onDataUpdate_ = onDataUpdate;
+  this.onConnectStatus_ = onConnectStatus;
+  this.onServerInfoUpdate_ = onServerInfoUpdate;
+  this.repoInfo_ = repoInfo;
+  this.securityDebugCallback_ = null;
+  this.requestCBHash_ = {};
+  this.requestNumber_ = 0;
+  this.firstConnection_ = true;
+  this.lastConnectionAttemptTime_ = null;
+  this.lastConnectionEstablishedTime_ = null;
+  this.scheduleConnect_(0);
+  fb.core.util.VisibilityMonitor.getInstance().on("visible", this.onVisible_, this);
+  if (repoInfo.host.indexOf("fblocal") === -1) {
+    fb.core.util.OnlineMonitor.getInstance().on("online", this.onOnline_, this);
+  }
+};
+fb.core.PersistentConnection.nextPersistentConnectionId_ = 0;
+fb.core.PersistentConnection.nextConnectionId_ = 0;
+fb.core.PersistentConnection.prototype.sendRequest = function(action, body, onResponse) {
+  var curReqNum = ++this.requestNumber_;
+  var msg = {"r":curReqNum, "a":action, "b":body};
+  this.log_(fb.util.json.stringify(msg));
+  fb.core.util.assert(this.connected_, "sendRequest call when we're not connected not allowed.");
+  this.realtime_.sendRequest(msg);
+  if (onResponse) {
+    this.requestCBHash_[curReqNum] = onResponse;
+  }
+};
+fb.core.PersistentConnection.prototype.listen = function(query, currentHashFn, tag, onComplete) {
+  var queryId = query.queryIdentifier();
+  var pathString = query.path.toString();
+  this.log_("Listen called for " + pathString + " " + queryId);
+  this.listens_[pathString] = this.listens_[pathString] || {};
+  fb.core.util.assert(!this.listens_[pathString][queryId], "listen() called twice for same path/queryId.");
+  var listenSpec = {onComplete:onComplete, hashFn:currentHashFn, query:query, tag:tag};
+  this.listens_[pathString][queryId] = listenSpec;
+  if (this.connected_) {
+    this.sendListen_(listenSpec);
+  }
+};
+fb.core.PersistentConnection.prototype.sendListen_ = function(listenSpec) {
+  var query = listenSpec.query;
+  var pathString = query.path.toString();
+  var queryId = query.queryIdentifier();
+  var self = this;
+  this.log_("Listen on " + pathString + " for " + queryId);
+  var req = {"p":pathString};
+  var action = "q";
+  if (listenSpec.tag) {
+    req["q"] = query.queryObject();
+    req["t"] = listenSpec.tag;
+  }
+  req["h"] = listenSpec.hashFn();
+  this.sendRequest(action, req, function(message) {
+    var payload = message["d"];
+    var status = message["s"];
+    self.warnOnListenWarnings_(payload, query);
+    var currentListenSpec = self.listens_[pathString] && self.listens_[pathString][queryId];
+    if (currentListenSpec === listenSpec) {
+      self.log_("listen response", message);
+      if (status !== "ok") {
+        self.removeListen_(pathString, queryId);
+      }
+      if (listenSpec.onComplete) {
+        listenSpec.onComplete(status, payload);
+      }
+    }
+  });
+};
+fb.core.PersistentConnection.prototype.warnOnListenWarnings_ = function(payload, query) {
+  if (payload && typeof payload === "object" && fb.util.obj.contains(payload, "w")) {
+    var warnings = fb.util.obj.get(payload, "w");
+    if (goog.isArray(warnings) && goog.array.contains(warnings, "no_index")) {
+      var indexSpec = '".indexOn": "' + query.getQueryParams().getIndex().toString() + '"';
+      var indexPath = query.path.toString();
+      fb.core.util.warn("Using an unspecified index. Consider adding " + indexSpec + " at " + indexPath + " to your security rules for better performance");
+    }
+  }
+};
+fb.core.PersistentConnection.prototype.auth = function(cred, opt_callback, opt_cancelCallback) {
+  this.credential_ = {cred:cred, firstRequestSent:false, callback:opt_callback, cancelCallback:opt_cancelCallback};
+  this.log_("Authenticating using credential: " + cred);
+  this.tryAuth();
+  this.reduceReconnectDelayIfAdminCredential_(cred);
+};
+fb.core.PersistentConnection.prototype.reduceReconnectDelayIfAdminCredential_ = function(credential) {
+  var isFirebaseSecret = credential.length == 40;
+  if (isFirebaseSecret || fb.util.jwt.isAdmin(credential)) {
+    this.log_("Admin auth credential detected.  Reducing max reconnect time.");
+    this.maxReconnectDelay_ = RECONNECT_MAX_DELAY_FOR_ADMINS;
+  }
+};
+fb.core.PersistentConnection.prototype.unauth = function(onComplete) {
+  delete this.credential_;
+  if (this.connected_) {
+    this.sendRequest("unauth", {}, function(result) {
+      var status = result["s"];
+      var errorReason = result["d"];
+      onComplete(status, errorReason);
+    });
+  }
+};
+fb.core.PersistentConnection.prototype.tryAuth = function() {
+  var authdata = this.credential_;
+  var self = this;
+  if (this.connected_ && authdata) {
+    var requestData = {"cred":authdata.cred};
+    this.sendRequest("auth", requestData, function(res) {
+      var status = res["s"];
+      var data = res["d"] || "error";
+      if (status !== "ok" && self.credential_ === authdata) {
+        delete self.credential_;
+      }
+      if (!authdata.firstRequestSent) {
+        authdata.firstRequestSent = true;
+        if (authdata.callback) {
+          authdata.callback(status, data);
+        }
+      } else {
+        if (status !== "ok" && authdata.cancelCallback) {
+          authdata.cancelCallback(status, data);
+        }
+      }
+    });
+  }
+};
+fb.core.PersistentConnection.prototype.unlisten = function(query, tag) {
+  var pathString = query.path.toString();
+  var queryId = query.queryIdentifier();
+  this.log_("Unlisten called for " + pathString + " " + queryId);
+  var listen = this.removeListen_(pathString, queryId);
+  if (listen && this.connected_) {
+    this.sendUnlisten_(pathString, queryId, query.queryObject(), tag);
+  }
+};
+fb.core.PersistentConnection.prototype.sendUnlisten_ = function(pathString, queryId, queryObj, tag) {
+  this.log_("Unlisten on " + pathString + " for " + queryId);
+  var self = this;
+  var req = {"p":pathString};
+  var action = "n";
+  if (tag) {
+    req["q"] = queryObj;
+    req["t"] = tag;
+  }
+  this.sendRequest(action, req);
+};
+fb.core.PersistentConnection.prototype.onDisconnectPut = function(pathString, data, opt_onComplete) {
+  if (this.connected_) {
+    this.sendOnDisconnect_("o", pathString, data, opt_onComplete);
+  } else {
+    this.onDisconnectRequestQueue_.push({pathString:pathString, action:"o", data:data, onComplete:opt_onComplete});
+  }
+};
+fb.core.PersistentConnection.prototype.onDisconnectMerge = function(pathString, data, opt_onComplete) {
+  if (this.connected_) {
+    this.sendOnDisconnect_("om", pathString, data, opt_onComplete);
+  } else {
+    this.onDisconnectRequestQueue_.push({pathString:pathString, action:"om", data:data, onComplete:opt_onComplete});
+  }
+};
+fb.core.PersistentConnection.prototype.onDisconnectCancel = function(pathString, opt_onComplete) {
+  if (this.connected_) {
+    this.sendOnDisconnect_("oc", pathString, null, opt_onComplete);
+  } else {
+    this.onDisconnectRequestQueue_.push({pathString:pathString, action:"oc", data:null, onComplete:opt_onComplete});
+  }
+};
+fb.core.PersistentConnection.prototype.sendOnDisconnect_ = function(action, pathString, data, opt_onComplete) {
+  var self = this;
+  var request = {"p":pathString, "d":data};
+  self.log_("onDisconnect " + action, request);
+  this.sendRequest(action, request, function(response) {
+    if (opt_onComplete) {
+      setTimeout(function() {
+        opt_onComplete(response["s"], response["d"]);
+      }, Math.floor(0));
+    }
+  });
+};
+fb.core.PersistentConnection.prototype.put = function(pathString, data, opt_onComplete, opt_hash) {
+  this.putInternal("p", pathString, data, opt_onComplete, opt_hash);
+};
+fb.core.PersistentConnection.prototype.merge = function(pathString, data, onComplete, opt_hash) {
+  this.putInternal("m", pathString, data, onComplete, opt_hash);
+};
+fb.core.PersistentConnection.prototype.putInternal = function(action, pathString, data, opt_onComplete, opt_hash) {
+  var request = {"p":pathString, "d":data};
+  if (goog.isDef(opt_hash)) {
+    request["h"] = opt_hash;
+  }
+  this.outstandingPuts_.push({action:action, request:request, onComplete:opt_onComplete});
+  this.outstandingPutCount_++;
+  var index = this.outstandingPuts_.length - 1;
+  if (this.connected_) {
+    this.sendPut_(index);
+  } else {
+    this.log_("Buffering put: " + pathString);
+  }
+};
+fb.core.PersistentConnection.prototype.sendPut_ = function(index) {
+  var self = this;
+  var action = this.outstandingPuts_[index].action;
+  var request = this.outstandingPuts_[index].request;
+  var onComplete = this.outstandingPuts_[index].onComplete;
+  this.outstandingPuts_[index].queued = this.connected_;
+  this.sendRequest(action, request, function(message) {
+    self.log_(action + " response", message);
+    delete self.outstandingPuts_[index];
+    self.outstandingPutCount_--;
+    if (self.outstandingPutCount_ === 0) {
+      self.outstandingPuts_ = [];
+    }
+    if (onComplete) {
+      onComplete(message["s"], message["d"]);
+    }
+  });
+};
+fb.core.PersistentConnection.prototype.reportStats = function(stats) {
+  if (this.connected_) {
+    var request = {"c":stats};
+    this.log_("reportStats", request);
+    this.sendRequest("s", request, function(result) {
+      var status = result["s"];
+      if (status !== "ok") {
+        var errorReason = result["d"];
+        this.log_("reportStats", "Error sending stats: " + errorReason);
+      }
+    });
+  }
+};
+fb.core.PersistentConnection.prototype.onDataMessage_ = function(message) {
+  if ("r" in message) {
+    this.log_("from server: " + fb.util.json.stringify(message));
+    var reqNum = message["r"];
+    var onResponse = this.requestCBHash_[reqNum];
+    if (onResponse) {
+      delete this.requestCBHash_[reqNum];
+      onResponse(message["b"]);
+    }
+  } else {
+    if ("error" in message) {
+      throw "A server-side error has occurred: " + message["error"];
+    } else {
+      if ("a" in message) {
+        this.onDataPush_(message["a"], message["b"]);
+      }
+    }
+  }
+};
+fb.core.PersistentConnection.prototype.onDataPush_ = function(action, body) {
+  this.log_("handleServerMessage", action, body);
+  if (action === "d") {
+    this.onDataUpdate_(body["p"], body["d"], false, body["t"]);
+  } else {
+    if (action === "m") {
+      this.onDataUpdate_(body["p"], body["d"], true, body["t"]);
+    } else {
+      if (action === "c") {
+        this.onListenRevoked_(body["p"], body["q"]);
+      } else {
+        if (action === "ac") {
+          this.onAuthRevoked_(body["s"], body["d"]);
+        } else {
+          if (action === "sd") {
+            this.onSecurityDebugPacket_(body);
+          } else {
+            fb.core.util.error("Unrecognized action received from server: " + fb.util.json.stringify(action) + "\nAre you using the latest client?");
+          }
+        }
+      }
+    }
+  }
+};
+fb.core.PersistentConnection.prototype.onReady_ = function(timestamp) {
+  this.log_("connection ready");
+  this.connected_ = true;
+  this.lastConnectionEstablishedTime_ = (new Date).getTime();
+  this.handleTimestamp_(timestamp);
+  if (this.firstConnection_) {
+    this.sendConnectStats_();
+  }
+  this.restoreState_();
+  this.firstConnection_ = false;
+  this.onConnectStatus_(true);
+};
+fb.core.PersistentConnection.prototype.scheduleConnect_ = function(timeout) {
+  fb.core.util.assert(!this.realtime_, "Scheduling a connect when we're already connected/ing?");
+  if (this.establishConnectionTimer_) {
+    clearTimeout(this.establishConnectionTimer_);
+  }
+  var self = this;
+  this.establishConnectionTimer_ = setTimeout(function() {
+    self.establishConnectionTimer_ = null;
+    self.establishConnection_();
+  }, Math.floor(timeout));
+};
+fb.core.PersistentConnection.prototype.onVisible_ = function(visible) {
+  if (visible && !this.visible_ && this.reconnectDelay_ === this.maxReconnectDelay_) {
+    this.log_("Window became visible.  Reducing delay.");
+    this.reconnectDelay_ = RECONNECT_MIN_DELAY;
+    if (!this.realtime_) {
+      this.scheduleConnect_(0);
+    }
+  }
+  this.visible_ = visible;
+};
+fb.core.PersistentConnection.prototype.onOnline_ = function(online) {
+  if (online) {
+    this.log_("Browser went online.");
+    this.reconnectDelay_ = RECONNECT_MIN_DELAY;
+    if (!this.realtime_) {
+      this.scheduleConnect_(0);
+    }
+  } else {
+    this.log_("Browser went offline.  Killing connection.");
+    if (this.realtime_) {
+      this.realtime_.close();
+    }
+  }
+};
+fb.core.PersistentConnection.prototype.onRealtimeDisconnect_ = function() {
+  this.log_("data client disconnected");
+  this.connected_ = false;
+  this.realtime_ = null;
+  this.cancelSentTransactions_();
+  this.requestCBHash_ = {};
+  if (this.shouldReconnect_()) {
+    if (!this.visible_) {
+      this.log_("Window isn't visible.  Delaying reconnect.");
+      this.reconnectDelay_ = this.maxReconnectDelay_;
+      this.lastConnectionAttemptTime_ = (new Date).getTime();
+    } else {
+      if (this.lastConnectionEstablishedTime_) {
+        var timeSinceLastConnectSucceeded = (new Date).getTime() - this.lastConnectionEstablishedTime_;
+        if (timeSinceLastConnectSucceeded > RECONNECT_DELAY_RESET_TIMEOUT) {
+          this.reconnectDelay_ = RECONNECT_MIN_DELAY;
+        }
+        this.lastConnectionEstablishedTime_ = null;
+      }
+    }
+    var timeSinceLastConnectAttempt = (new Date).getTime() - this.lastConnectionAttemptTime_;
+    var reconnectDelay = Math.max(0, this.reconnectDelay_ - timeSinceLastConnectAttempt);
+    reconnectDelay = Math.random() * reconnectDelay;
+    this.log_("Trying to reconnect in " + reconnectDelay + "ms");
+    this.scheduleConnect_(reconnectDelay);
+    this.reconnectDelay_ = Math.min(this.maxReconnectDelay_, this.reconnectDelay_ * RECONNECT_DELAY_MULTIPLIER);
+  }
+  this.onConnectStatus_(false);
+};
+fb.core.PersistentConnection.prototype.establishConnection_ = function() {
+  if (this.shouldReconnect_()) {
+    this.log_("Making a connection attempt");
+    this.lastConnectionAttemptTime_ = (new Date).getTime();
+    this.lastConnectionEstablishedTime_ = null;
+    var onDataMessage = goog.bind(this.onDataMessage_, this);
+    var onReady = goog.bind(this.onReady_, this);
+    var onDisconnect = goog.bind(this.onRealtimeDisconnect_, this);
+    var connId = this.id + ":" + fb.core.PersistentConnection.nextConnectionId_++;
+    var self = this;
+    this.realtime_ = new fb.realtime.Connection(connId, this.repoInfo_, onDataMessage, onReady, onDisconnect, function(reason) {
+      fb.core.util.warn(reason + " (" + self.repoInfo_.toString() + ")");
+      self.killed_ = true;
+    });
+  }
+};
+fb.core.PersistentConnection.prototype.interrupt = function() {
+  this.interrupted_ = true;
+  if (this.realtime_) {
+    this.realtime_.close();
+  } else {
+    if (this.establishConnectionTimer_) {
+      clearTimeout(this.establishConnectionTimer_);
+      this.establishConnectionTimer_ = null;
+    }
+    if (this.connected_) {
+      this.onRealtimeDisconnect_();
+    }
+  }
+};
+fb.core.PersistentConnection.prototype.resume = function() {
+  this.interrupted_ = false;
+  this.reconnectDelay_ = RECONNECT_MIN_DELAY;
+  if (!this.realtime_) {
+    this.scheduleConnect_(0);
+  }
+};
+fb.core.PersistentConnection.prototype.handleTimestamp_ = function(timestamp) {
+  var delta = timestamp - (new Date).getTime();
+  this.onServerInfoUpdate_({"serverTimeOffset":delta});
+};
+fb.core.PersistentConnection.prototype.cancelSentTransactions_ = function() {
+  for (var i = 0;i < this.outstandingPuts_.length;i++) {
+    var put = this.outstandingPuts_[i];
+    if (put && "h" in put.request && put.queued) {
+      if (put.onComplete) {
+        put.onComplete("disconnect");
+      }
+      delete this.outstandingPuts_[i];
+      this.outstandingPutCount_--;
+    }
+  }
+  if (this.outstandingPutCount_ === 0) {
+    this.outstandingPuts_ = [];
+  }
+};
+fb.core.PersistentConnection.prototype.onListenRevoked_ = function(pathString, opt_query) {
+  var queryId;
+  if (!opt_query) {
+    queryId = "default";
+  } else {
+    queryId = goog.array.map(opt_query, function(q) {
+      return fb.core.util.ObjectToUniqueKey(q);
+    }).join("$");
+  }
+  var listen = this.removeListen_(pathString, queryId);
+  if (listen && listen.onComplete) {
+    listen.onComplete("permission_denied");
+  }
+};
+fb.core.PersistentConnection.prototype.removeListen_ = function(pathString, queryId) {
+  var normalizedPathString = (new fb.core.util.Path(pathString)).toString();
+  var listen;
+  if (goog.isDef(this.listens_[normalizedPathString])) {
+    listen = this.listens_[normalizedPathString][queryId];
+    delete this.listens_[normalizedPathString][queryId];
+    if (goog.object.getCount(this.listens_[normalizedPathString]) === 0) {
+      delete this.listens_[normalizedPathString];
+    }
+  } else {
+    listen = undefined;
+  }
+  return listen;
+};
+fb.core.PersistentConnection.prototype.onAuthRevoked_ = function(statusCode, explanation) {
+  var cred = this.credential_;
+  delete this.credential_;
+  if (cred && cred.cancelCallback) {
+    cred.cancelCallback(statusCode, explanation);
+  }
+};
+fb.core.PersistentConnection.prototype.onSecurityDebugPacket_ = function(body) {
+  if (this.securityDebugCallback_) {
+    this.securityDebugCallback_(body);
+  } else {
+    if ("msg" in body && typeof console !== "undefined") {
+      console.log("FIREBASE: " + body["msg"].replace("\n", "\nFIREBASE: "));
+    }
+  }
+};
+fb.core.PersistentConnection.prototype.restoreState_ = function() {
+  this.tryAuth();
+  var self = this;
+  goog.object.forEach(this.listens_, function(queries, pathString) {
+    goog.object.forEach(queries, function(listenSpec) {
+      self.sendListen_(listenSpec);
+    });
+  });
+  for (var i = 0;i < this.outstandingPuts_.length;i++) {
+    if (this.outstandingPuts_[i]) {
+      this.sendPut_(i);
+    }
+  }
+  while (this.onDisconnectRequestQueue_.length) {
+    var request = this.onDisconnectRequestQueue_.shift();
+    this.sendOnDisconnect_(request.action, request.pathString, request.data, request.onComplete);
+  }
+};
+fb.core.PersistentConnection.prototype.sendConnectStats_ = function() {
+  var stats = {};
+  stats["sdk.js." + CLIENT_VERSION.replace(/\./g, "-")] = 1;
+  if (fb.login.util.environment.isMobileCordova()) {
+    stats["framework.cordova"] = 1;
+  }
+  this.reportStats(stats);
+};
+fb.core.PersistentConnection.prototype.shouldReconnect_ = function() {
+  var online = fb.core.util.OnlineMonitor.getInstance().currentlyOnline();
+  return!this.killed_ && !this.interrupted_ && online;
+};
+goog.provide("fb.api.INTERNAL");
+goog.require("fb.core.PersistentConnection");
+goog.require("fb.realtime.Connection");
+goog.require("fb.login.transports.PopupReceiver");
+goog.require("fb.login.Constants");
+fb.api.INTERNAL = {};
+fb.api.INTERNAL.forceLongPolling = function() {
+  fb.realtime.WebSocketConnection.forceDisallow();
+  fb.realtime.BrowserPollConnection.forceAllow();
+};
+goog.exportProperty(fb.api.INTERNAL, "forceLongPolling", fb.api.INTERNAL.forceLongPolling);
+fb.api.INTERNAL.forceWebSockets = function() {
+  fb.realtime.BrowserPollConnection.forceDisallow();
+};
+goog.exportProperty(fb.api.INTERNAL, "forceWebSockets", fb.api.INTERNAL.forceWebSockets);
+fb.api.INTERNAL.setSecurityDebugCallback = function(ref, callback) {
+  ref.repo.persistentConnection_.securityDebugCallback_ = callback;
+};
+goog.exportProperty(fb.api.INTERNAL, "setSecurityDebugCallback", fb.api.INTERNAL.setSecurityDebugCallback);
+fb.api.INTERNAL.stats = function(ref, showDelta) {
+  ref.repo.stats(showDelta);
+};
+goog.exportProperty(fb.api.INTERNAL, "stats", fb.api.INTERNAL.stats);
+fb.api.INTERNAL.statsIncrementCounter = function(ref, metric) {
+  ref.repo.statsIncrementCounter(metric);
+};
+goog.exportProperty(fb.api.INTERNAL, "statsIncrementCounter", fb.api.INTERNAL.statsIncrementCounter);
+fb.api.INTERNAL.dataUpdateCount = function(ref) {
+  return ref.repo.dataUpdateCount;
+};
+goog.exportProperty(fb.api.INTERNAL, "dataUpdateCount", fb.api.INTERNAL.dataUpdateCount);
+fb.api.INTERNAL.interceptServerData = function(ref, callback) {
+  return ref.repo.interceptServerData_(callback);
+};
+goog.exportProperty(fb.api.INTERNAL, "interceptServerData", fb.api.INTERNAL.interceptServerData);
+fb.api.INTERNAL.onLoginPopupOpen = function(callback) {
+  new fb.login.transports.PopupReceiver(callback);
+};
+goog.exportProperty(fb.api.INTERNAL, "onPopupOpen", fb.api.INTERNAL.onLoginPopupOpen);
+fb.api.INTERNAL.setAuthenticationServer = function(host) {
+  fb.login.Constants.SERVER_HOST = host;
+};
+goog.exportProperty(fb.api.INTERNAL, "setAuthenticationServer", fb.api.INTERNAL.setAuthenticationServer);
+goog.provide("fb.api.DataSnapshot");
+goog.require("fb.core.snap");
+goog.require("fb.core.util.SortedMap");
+goog.require("fb.core.util.validation");
+fb.api.DataSnapshot = function(node, ref, index) {
+  this.node_ = node;
+  this.query_ = ref;
+  this.index_ = index;
+};
+fb.api.DataSnapshot.prototype.val = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.val", 0, 0, arguments.length);
+  return this.node_.val();
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "val", fb.api.DataSnapshot.prototype.val);
+fb.api.DataSnapshot.prototype.exportVal = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.exportVal", 0, 0, arguments.length);
+  return this.node_.val(true);
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "exportVal", fb.api.DataSnapshot.prototype.exportVal);
+fb.api.DataSnapshot.prototype.exists = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.exists", 0, 0, arguments.length);
+  return!this.node_.isEmpty();
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "exists", fb.api.DataSnapshot.prototype.exists);
+fb.api.DataSnapshot.prototype.child = function(childPathString) {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.child", 0, 1, arguments.length);
+  if (goog.isNumber(childPathString)) {
+    childPathString = String(childPathString);
+  }
+  fb.core.util.validation.validatePathString("Firebase.DataSnapshot.child", 1, childPathString, false);
+  var childPath = new fb.core.util.Path(childPathString);
+  var childRef = this.query_.child(childPath);
+  return new fb.api.DataSnapshot(this.node_.getChild(childPath), childRef, fb.core.snap.PriorityIndex);
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "child", fb.api.DataSnapshot.prototype.child);
+fb.api.DataSnapshot.prototype.hasChild = function(childPathString) {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.hasChild", 1, 1, arguments.length);
+  fb.core.util.validation.validatePathString("Firebase.DataSnapshot.hasChild", 1, childPathString, false);
+  var childPath = new fb.core.util.Path(childPathString);
+  return!this.node_.getChild(childPath).isEmpty();
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "hasChild", fb.api.DataSnapshot.prototype.hasChild);
+fb.api.DataSnapshot.prototype.getPriority = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.getPriority", 0, 0, arguments.length);
+  return(this.node_.getPriority().val());
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "getPriority", fb.api.DataSnapshot.prototype.getPriority);
+fb.api.DataSnapshot.prototype.forEach = function(action) {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.forEach", 1, 1, arguments.length);
+  fb.util.validation.validateCallback("Firebase.DataSnapshot.forEach", 1, action, false);
+  if (this.node_.isLeafNode()) {
+    return false;
+  }
+  var childrenNode = (this.node_);
+  var self = this;
+  return!!childrenNode.forEachChild(this.index_, function(key, node) {
+    return action(new fb.api.DataSnapshot(node, self.query_.child(key), fb.core.snap.PriorityIndex));
+  });
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "forEach", fb.api.DataSnapshot.prototype.forEach);
+fb.api.DataSnapshot.prototype.hasChildren = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.hasChildren", 0, 0, arguments.length);
+  if (this.node_.isLeafNode()) {
+    return false;
+  } else {
+    return!this.node_.isEmpty();
+  }
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "hasChildren", fb.api.DataSnapshot.prototype.hasChildren);
+fb.api.DataSnapshot.prototype.name = function() {
+  fb.core.util.warn("Firebase.DataSnapshot.name() being deprecated. " + "Please use Firebase.DataSnapshot.key() instead.");
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.name", 0, 0, arguments.length);
+  return this.key();
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "name", fb.api.DataSnapshot.prototype.name);
+fb.api.DataSnapshot.prototype.key = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.key", 0, 0, arguments.length);
+  return this.query_.key();
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "key", fb.api.DataSnapshot.prototype.key);
+fb.api.DataSnapshot.prototype.numChildren = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.numChildren", 0, 0, arguments.length);
+  return this.node_.numChildren();
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "numChildren", fb.api.DataSnapshot.prototype.numChildren);
+fb.api.DataSnapshot.prototype.ref = function() {
+  fb.util.validation.validateArgCount("Firebase.DataSnapshot.ref", 0, 0, arguments.length);
+  return this.query_;
+};
+goog.exportProperty(fb.api.DataSnapshot.prototype, "ref", fb.api.DataSnapshot.prototype.ref);
+goog.provide("fb.core.Repo");
+goog.require("fb.api.DataSnapshot");
+goog.require("fb.core.PersistentConnection");
+goog.require("fb.core.ReadonlyRestClient");
+goog.require("fb.core.SnapshotHolder");
+goog.require("fb.core.SparseSnapshotTree");
+goog.require("fb.core.SyncTree");
+goog.require("fb.core.stats.StatsCollection");
+goog.require("fb.core.stats.StatsListener");
+goog.require("fb.core.stats.StatsManager");
+goog.require("fb.core.stats.StatsReporter");
+goog.require("fb.core.util");
+goog.require("fb.core.util.ServerValues");
+goog.require("fb.core.util.Tree");
+goog.require("fb.core.view.EventQueue");
+goog.require("fb.login.AuthenticationManager");
+goog.require("fb.util.json");
+goog.require("fb.util.jwt");
+goog.require("goog.string");
+fb.core.Repo = function(repoInfo, forceRestClient) {
+  this.repoInfo_ = repoInfo;
+  this.stats_ = fb.core.stats.StatsManager.getCollection(repoInfo);
+  this.eventQueue_ = new fb.core.view.EventQueue;
+  this.nextWriteId_ = 1;
+  this.persistentConnection_ = null;
+  this.server_;
+  if (forceRestClient || fb.core.util.beingCrawled()) {
+    this.server_ = new fb.core.ReadonlyRestClient(this.repoInfo_, goog.bind(this.onDataUpdate_, this));
+    setTimeout(goog.bind(this.onConnectStatus_, this, true), 0);
+  } else {
+    this.persistentConnection_ = new fb.core.PersistentConnection(this.repoInfo_, goog.bind(this.onDataUpdate_, this), goog.bind(this.onConnectStatus_, this), goog.bind(this.onServerInfoUpdate_, this));
+    this.server_ = this.persistentConnection_;
+  }
+  this.statsReporter_ = fb.core.stats.StatsManager.getOrCreateReporter(repoInfo, goog.bind(function() {
+    return new fb.core.stats.StatsReporter(this.stats_, this.server_);
+  }, this));
+  this.transactions_init_();
+  this.infoData_ = new fb.core.SnapshotHolder;
+  var self = this;
+  this.infoSyncTree_ = new fb.core.SyncTree({startListening:function(query, tag, currentHashFn, onComplete) {
+    var infoEvents = [];
+    var node = self.infoData_.getNode(query.path);
+    if (!node.isEmpty()) {
+      infoEvents = self.infoSyncTree_.applyServerOverwrite(query.path, node);
+      setTimeout(function() {
+        onComplete("ok");
+      }, 0);
+    }
+    return infoEvents;
+  }, stopListening:goog.nullFunction});
+  this.updateInfo_("connected", false);
+  this.onDisconnect_ = new fb.core.SparseSnapshotTree;
+  this.auth = new fb.login.AuthenticationManager(repoInfo, goog.bind(this.server_.auth, this.server_), goog.bind(this.server_.unauth, this.server_), goog.bind(this.onAuthStatus_, this));
+  this.dataUpdateCount = 0;
+  this.interceptServerDataCallback_ = null;
+  this.serverSyncTree_ = new fb.core.SyncTree({startListening:function(query, tag, currentHashFn, onComplete) {
+    self.server_.listen(query, currentHashFn, tag, function(status, data) {
+      var events = onComplete(status, data);
+      self.eventQueue_.raiseEventsForChangedPath(query.path, events);
+    });
+    return[];
+  }, stopListening:function(query, tag) {
+    self.server_.unlisten(query, tag);
+  }});
+};
+fb.core.Repo.prototype.toString = function() {
+  return(this.repoInfo_.secure ? "https://" : "http://") + this.repoInfo_.host;
+};
+fb.core.Repo.prototype.name = function() {
+  return this.repoInfo_.namespace;
+};
+fb.core.Repo.prototype.serverTime = function() {
+  var offsetNode = this.infoData_.getNode(new fb.core.util.Path(".info/serverTimeOffset"));
+  var offset = (offsetNode.val()) || 0;
+  return(new Date).getTime() + offset;
+};
+fb.core.Repo.prototype.generateServerValues = function() {
+  return fb.core.util.ServerValues.generateWithValues({"timestamp":this.serverTime()});
+};
+fb.core.Repo.prototype.onDataUpdate_ = function(pathString, data, isMerge, tag) {
+  this.dataUpdateCount++;
+  var path = new fb.core.util.Path(pathString);
+  data = this.interceptServerDataCallback_ ? this.interceptServerDataCallback_(pathString, data) : data;
+  var events = [];
+  if (tag) {
+    if (isMerge) {
+      var taggedChildren = goog.object.map((data), function(raw) {
+        return fb.core.snap.NodeFromJSON(raw);
+      });
+      events = this.serverSyncTree_.applyTaggedQueryMerge(path, taggedChildren, tag);
+    } else {
+      var taggedSnap = fb.core.snap.NodeFromJSON(data);
+      events = this.serverSyncTree_.applyTaggedQueryOverwrite(path, taggedSnap, tag);
+    }
+  } else {
+    if (isMerge) {
+      var changedChildren = goog.object.map((data), function(raw) {
+        return fb.core.snap.NodeFromJSON(raw);
+      });
+      events = this.serverSyncTree_.applyServerMerge(path, changedChildren);
+    } else {
+      var snap = fb.core.snap.NodeFromJSON(data);
+      events = this.serverSyncTree_.applyServerOverwrite(path, snap);
+    }
+  }
+  var affectedPath = path;
+  if (events.length > 0) {
+    affectedPath = this.rerunTransactions_(path);
+  }
+  this.eventQueue_.raiseEventsForChangedPath(affectedPath, events);
+};
+fb.core.Repo.prototype.interceptServerData_ = function(callback) {
+  this.interceptServerDataCallback_ = callback;
+};
+fb.core.Repo.prototype.onConnectStatus_ = function(connectStatus) {
+  this.updateInfo_("connected", connectStatus);
+  if (connectStatus === false) {
+    this.runOnDisconnectEvents_();
+  }
+};
+fb.core.Repo.prototype.onServerInfoUpdate_ = function(updates) {
+  var self = this;
+  fb.core.util.each(updates, function(value, key) {
+    self.updateInfo_(key, value);
+  });
+};
+fb.core.Repo.prototype.onAuthStatus_ = function(authStatus) {
+  this.updateInfo_("authenticated", authStatus);
+};
+fb.core.Repo.prototype.updateInfo_ = function(pathString, value) {
+  var path = new fb.core.util.Path("/.info/" + pathString);
+  var newNode = fb.core.snap.NodeFromJSON(value);
+  this.infoData_.updateSnapshot(path, newNode);
+  var events = this.infoSyncTree_.applyServerOverwrite(path, newNode);
+  this.eventQueue_.raiseEventsForChangedPath(path, events);
+};
+fb.core.Repo.prototype.getNextWriteId_ = function() {
+  return this.nextWriteId_++;
+};
+fb.core.Repo.prototype.setWithPriority = function(path, newVal, newPriority, onComplete) {
+  this.log_("set", {path:path.toString(), value:newVal, priority:newPriority});
+  var serverValues = this.generateServerValues();
+  var newNodeUnresolved = fb.core.snap.NodeFromJSON(newVal, newPriority);
+  var newNode = fb.core.util.ServerValues.resolveDeferredValueSnapshot(newNodeUnresolved, serverValues);
+  var writeId = this.getNextWriteId_();
+  var events = this.serverSyncTree_.applyUserOverwrite(path, newNode, writeId, true);
+  this.eventQueue_.queueEvents(events);
+  var self = this;
+  this.server_.put(path.toString(), newNodeUnresolved.val(true), function(status, errorReason) {
+    var success = status === "ok";
+    if (!success) {
+      fb.core.util.warn("set at " + path + " failed: " + status);
+    }
+    var clearEvents = self.serverSyncTree_.ackUserWrite(writeId, !success);
+    self.eventQueue_.raiseEventsForChangedPath(path, clearEvents);
+    self.callOnCompleteCallback(onComplete, status, errorReason);
+  });
+  var affectedPath = this.abortTransactions_(path);
+  this.rerunTransactions_(affectedPath);
+  this.eventQueue_.raiseEventsForChangedPath(affectedPath, []);
+};
+fb.core.Repo.prototype.update = function(path, childrenToMerge, onComplete) {
+  this.log_("update", {path:path.toString(), value:childrenToMerge});
+  var empty = true;
+  var serverValues = this.generateServerValues();
+  var changedChildren = {};
+  goog.object.forEach(childrenToMerge, function(changedValue, changedKey) {
+    empty = false;
+    var newNodeUnresolved = fb.core.snap.NodeFromJSON(changedValue);
+    changedChildren[changedKey] = fb.core.util.ServerValues.resolveDeferredValueSnapshot(newNodeUnresolved, serverValues);
+  });
+  if (!empty) {
+    var writeId = this.getNextWriteId_();
+    var events = this.serverSyncTree_.applyUserMerge(path, changedChildren, writeId);
+    this.eventQueue_.queueEvents(events);
+    var self = this;
+    this.server_.merge(path.toString(), childrenToMerge, function(status, errorReason) {
+      var success = status === "ok";
+      if (!success) {
+        fb.core.util.warn("update at " + path + " failed: " + status);
+      }
+      var clearEvents = self.serverSyncTree_.ackUserWrite(writeId, !success);
+      var affectedPath = path;
+      if (clearEvents.length > 0) {
+        affectedPath = self.rerunTransactions_(path);
+      }
+      self.eventQueue_.raiseEventsForChangedPath(affectedPath, clearEvents);
+      self.callOnCompleteCallback(onComplete, status, errorReason);
+    });
+    var affectedPath = this.abortTransactions_(path);
+    this.rerunTransactions_(affectedPath);
+    this.eventQueue_.raiseEventsForChangedPath(path, []);
+  } else {
+    fb.core.util.log("update() called with empty data.  Don't do anything.");
+    this.callOnCompleteCallback(onComplete, "ok");
+  }
+};
+fb.core.Repo.prototype.runOnDisconnectEvents_ = function() {
+  this.log_("onDisconnectEvents");
+  var self = this;
+  var serverValues = this.generateServerValues();
+  var resolvedOnDisconnectTree = fb.core.util.ServerValues.resolveDeferredValueTree(this.onDisconnect_, serverValues);
+  var events = [];
+  resolvedOnDisconnectTree.forEachTree(fb.core.util.Path.Empty, function(path, snap) {
+    events = events.concat(self.serverSyncTree_.applyServerOverwrite(path, snap));
+    var affectedPath = self.abortTransactions_(path);
+    self.rerunTransactions_(affectedPath);
+  });
+  this.onDisconnect_ = new fb.core.SparseSnapshotTree;
+  this.eventQueue_.raiseEventsForChangedPath(fb.core.util.Path.Empty, events);
+};
+fb.core.Repo.prototype.onDisconnectCancel = function(path, onComplete) {
+  var self = this;
+  this.server_.onDisconnectCancel(path.toString(), function(status, errorReason) {
+    if (status === "ok") {
+      self.onDisconnect_.forget(path);
+    }
+    self.callOnCompleteCallback(onComplete, status, errorReason);
+  });
+};
+fb.core.Repo.prototype.onDisconnectSet = function(path, value, onComplete) {
+  var self = this;
+  var newNode = fb.core.snap.NodeFromJSON(value);
+  this.server_.onDisconnectPut(path.toString(), newNode.val(true), function(status, errorReason) {
+    if (status === "ok") {
+      self.onDisconnect_.remember(path, newNode);
+    }
+    self.callOnCompleteCallback(onComplete, status, errorReason);
+  });
+};
+fb.core.Repo.prototype.onDisconnectSetWithPriority = function(path, value, priority, onComplete) {
+  var self = this;
+  var newNode = fb.core.snap.NodeFromJSON(value, priority);
+  this.server_.onDisconnectPut(path.toString(), newNode.val(true), function(status, errorReason) {
+    if (status === "ok") {
+      self.onDisconnect_.remember(path, newNode);
+    }
+    self.callOnCompleteCallback(onComplete, status, errorReason);
+  });
+};
+fb.core.Repo.prototype.onDisconnectUpdate = function(path, childrenToMerge, onComplete) {
+  var empty = true;
+  for (var childName in childrenToMerge) {
+    empty = false;
+  }
+  if (empty) {
+    fb.core.util.log("onDisconnect().update() called with empty data.  Don't do anything.");
+    this.callOnCompleteCallback(onComplete, "ok");
+    return;
+  }
+  var self = this;
+  this.server_.onDisconnectMerge(path.toString(), childrenToMerge, function(status, errorReason) {
+    if (status === "ok") {
+      for (var childName in childrenToMerge) {
+        var newChildNode = fb.core.snap.NodeFromJSON(childrenToMerge[childName]);
+        self.onDisconnect_.remember(path.child(childName), newChildNode);
+      }
+    }
+    self.callOnCompleteCallback(onComplete, status, errorReason);
+  });
+};
+fb.core.Repo.prototype.addEventCallbackForQuery = function(query, eventRegistration) {
+  var events;
+  if (query.path.getFront() === ".info") {
+    events = this.infoSyncTree_.addEventRegistration(query, eventRegistration);
+  } else {
+    events = this.serverSyncTree_.addEventRegistration(query, eventRegistration);
+  }
+  this.eventQueue_.raiseEventsAtPath(query.path, events);
+};
+fb.core.Repo.prototype.removeEventCallbackForQuery = function(query, eventRegistration) {
+  var events;
+  if (query.path.getFront() === ".info") {
+    events = this.infoSyncTree_.removeEventRegistration(query, eventRegistration);
+  } else {
+    events = this.serverSyncTree_.removeEventRegistration(query, eventRegistration);
+  }
+  this.eventQueue_.raiseEventsAtPath(query.path, events);
+};
+fb.core.Repo.prototype.interrupt = function() {
+  if (this.persistentConnection_) {
+    this.persistentConnection_.interrupt();
+  }
+};
+fb.core.Repo.prototype.resume = function() {
+  if (this.persistentConnection_) {
+    this.persistentConnection_.resume();
+  }
+};
+fb.core.Repo.prototype.stats = function(showDelta) {
+  if (typeof console === "undefined") {
+    return;
+  }
+  var stats;
+  if (showDelta) {
+    if (!this.statsListener_) {
+      this.statsListener_ = new fb.core.stats.StatsListener(this.stats_);
+    }
+    stats = this.statsListener_.get();
+  } else {
+    stats = this.stats_.get();
+  }
+  var longestName = goog.array.reduce(goog.object.getKeys(stats), function(previousValue, currentValue, index, array) {
+    return Math.max(currentValue.length, previousValue);
+  }, 0);
+  for (var stat in stats) {
+    var value = stats[stat];
+    for (var i = stat.length;i < longestName + 2;i++) {
+      stat += " ";
+    }
+    console.log(stat + value);
+  }
+};
+fb.core.Repo.prototype.statsIncrementCounter = function(metric) {
+  this.stats_.incrementCounter(metric);
+  this.statsReporter_.includeStat(metric);
+};
+fb.core.Repo.prototype.log_ = function(var_args) {
+  var prefix = "";
+  if (this.persistentConnection_) {
+    prefix = this.persistentConnection_.id + ":";
+  }
+  fb.core.util.log(prefix, arguments);
+};
+fb.core.Repo.prototype.callOnCompleteCallback = function(callback, status, errorReason) {
+  if (callback) {
+    fb.core.util.exceptionGuard(function() {
+      if (status == "ok") {
+        callback(null);
+      } else {
+        var code = (status || "error").toUpperCase();
+        var message = code;
+        if (errorReason) {
+          message += ": " + errorReason;
+        }
+        var error = new Error(message);
+        error.code = code;
+        callback(error);
+      }
+    });
+  }
+};
+goog.provide("fb.core.Repo_transaction");
+goog.require("fb.core.Repo");
+goog.require("fb.core.snap.PriorityIndex");
+goog.require("fb.core.util");
+fb.core.TransactionStatus = {RUN:1, SENT:2, COMPLETED:3, SENT_NEEDS_ABORT:4, NEEDS_ABORT:5};
+fb.core.Repo.MAX_TRANSACTION_RETRIES_ = 25;
+fb.core.Transaction;
+fb.core.Repo.prototype.transactions_init_ = function() {
+  this.transactionQueueTree_ = new fb.core.util.Tree;
+};
+fb.core.Repo.prototype.startTransaction = function(path, transactionUpdate, onComplete, applyLocally) {
+  this.log_("transaction on " + path);
+  var valueCallback = function() {
+  };
+  var watchRef = new Firebase(this, path);
+  watchRef.on("value", valueCallback);
+  var unwatcher = function() {
+    watchRef.off("value", valueCallback);
+  };
+  var transaction = ({path:path, update:transactionUpdate, onComplete:onComplete, status:null, order:fb.core.util.LUIDGenerator(), applyLocally:applyLocally, retryCount:0, unwatcher:unwatcher, abortReason:null, currentWriteId:null, currentInputSnapshot:null, currentOutputSnapshotRaw:null, currentOutputSnapshotResolved:null});
+  var currentState = this.getLatestState_(path);
+  transaction.currentInputSnapshot = currentState;
+  var newVal = transaction.update(currentState.val());
+  if (!goog.isDef(newVal)) {
+    transaction.unwatcher();
+    transaction.currentOutputSnapshotRaw = null;
+    transaction.currentOutputSnapshotResolved = null;
+    if (transaction.onComplete) {
+      var snapshot = new fb.api.DataSnapshot((transaction.currentInputSnapshot), new Firebase(this, transaction.path), fb.core.snap.PriorityIndex);
+      transaction.onComplete(null, false, snapshot);
+    }
+  } else {
+    fb.core.util.validation.validateFirebaseData("transaction failed: Data returned ", newVal, transaction.path);
+    transaction.status = fb.core.TransactionStatus.RUN;
+    var queueNode = this.transactionQueueTree_.subTree(path);
+    var nodeQueue = queueNode.getValue() || [];
+    nodeQueue.push(transaction);
+    queueNode.setValue(nodeQueue);
+    var priorityForNode;
+    if (typeof newVal === "object" && newVal !== null && fb.util.obj.contains(newVal, ".priority")) {
+      priorityForNode = fb.util.obj.get(newVal, ".priority");
+      fb.core.util.assert(fb.core.util.validation.isValidPriority(priorityForNode), "Invalid priority returned by transaction. " + "Priority must be a valid string, finite number, server value, or null.");
+    } else {
+      var currentNode = this.serverSyncTree_.calcCompleteEventCache(path) || fb.core.snap.EMPTY_NODE;
+      priorityForNode = currentNode.getPriority().val();
+    }
+    priorityForNode = (priorityForNode);
+    var serverValues = this.generateServerValues();
+    var newNodeUnresolved = fb.core.snap.NodeFromJSON(newVal, priorityForNode);
+    var newNode = fb.core.util.ServerValues.resolveDeferredValueSnapshot(newNodeUnresolved, serverValues);
+    transaction.currentOutputSnapshotRaw = newNodeUnresolved;
+    transaction.currentOutputSnapshotResolved = newNode;
+    transaction.currentWriteId = this.getNextWriteId_();
+    var events = this.serverSyncTree_.applyUserOverwrite(path, newNode, transaction.currentWriteId, transaction.applyLocally);
+    this.eventQueue_.raiseEventsForChangedPath(path, events);
+    this.sendReadyTransactions_();
+  }
+};
+fb.core.Repo.prototype.getLatestState_ = function(path, excludeSets) {
+  return this.serverSyncTree_.calcCompleteEventCache(path, excludeSets) || fb.core.snap.EMPTY_NODE;
+};
+fb.core.Repo.prototype.sendReadyTransactions_ = function(opt_node) {
+  var node = (opt_node || this.transactionQueueTree_);
+  if (!opt_node) {
+    this.pruneCompletedTransactionsBelowNode_(node);
+  }
+  if (node.getValue() !== null) {
+    var queue = this.buildTransactionQueue_(node);
+    fb.core.util.assert(queue.length > 0, "Sending zero length transaction queue");
+    var allRun = goog.array.every(queue, function(transaction) {
+      return transaction.status === fb.core.TransactionStatus.RUN;
+    });
+    if (allRun) {
+      this.sendTransactionQueue_(node.path(), queue);
+    }
+  } else {
+    if (node.hasChildren()) {
+      var self = this;
+      node.forEachChild(function(childNode) {
+        self.sendReadyTransactions_(childNode);
+      });
+    }
+  }
+};
+fb.core.Repo.prototype.sendTransactionQueue_ = function(path, queue) {
+  var setsToIgnore = goog.array.map(queue, function(txn) {
+    return txn.currentWriteId;
+  });
+  var latestState = this.getLatestState_(path, setsToIgnore);
+  var snapToSend = latestState;
+  var latestHash = latestState.hash();
+  for (var i = 0;i < queue.length;i++) {
+    var txn = queue[i];
+    fb.core.util.assert(txn.status === fb.core.TransactionStatus.RUN, "tryToSendTransactionQueue_: items in queue should all be run.");
+    txn.status = fb.core.TransactionStatus.SENT;
+    txn.retryCount++;
+    var relativePath = fb.core.util.Path.relativePath(path, txn.path);
+    snapToSend = snapToSend.updateChild(relativePath, (txn.currentOutputSnapshotRaw));
+  }
+  var dataToSend = snapToSend.val(true);
+  var pathToSend = path;
+  var self = this;
+  this.server_.put(pathToSend.toString(), dataToSend, function(status) {
+    self.log_("transaction put response", {path:pathToSend.toString(), status:status});
+    var events = [];
+    if (status === "ok") {
+      var callbacks = [];
+      for (i = 0;i < queue.length;i++) {
+        queue[i].status = fb.core.TransactionStatus.COMPLETED;
+        events = events.concat(self.serverSyncTree_.ackUserWrite(queue[i].currentWriteId));
+        if (queue[i].onComplete) {
+          var node = (queue[i].currentOutputSnapshotResolved);
+          var ref = new Firebase(self, queue[i].path);
+          var snapshot = new fb.api.DataSnapshot(node, ref, fb.core.snap.PriorityIndex);
+          callbacks.push(goog.bind(queue[i].onComplete, null, null, true, snapshot));
+        }
+        queue[i].unwatcher();
+      }
+      self.pruneCompletedTransactionsBelowNode_(self.transactionQueueTree_.subTree(path));
+      self.sendReadyTransactions_();
+      self.eventQueue_.raiseEventsForChangedPath(path, events);
+      for (i = 0;i < callbacks.length;i++) {
+        fb.core.util.exceptionGuard(callbacks[i]);
+      }
+    } else {
+      if (status === "datastale") {
+        for (i = 0;i < queue.length;i++) {
+          if (queue[i].status === fb.core.TransactionStatus.SENT_NEEDS_ABORT) {
+            queue[i].status = fb.core.TransactionStatus.NEEDS_ABORT;
+          } else {
+            queue[i].status = fb.core.TransactionStatus.RUN;
+          }
+        }
+      } else {
+        fb.core.util.warn("transaction at " + pathToSend.toString() + " failed: " + status);
+        for (i = 0;i < queue.length;i++) {
+          queue[i].status = fb.core.TransactionStatus.NEEDS_ABORT;
+          queue[i].abortReason = status;
+        }
+      }
+      self.rerunTransactions_(path);
+    }
+  }, latestHash);
+};
+fb.core.Repo.prototype.rerunTransactions_ = function(changedPath) {
+  var rootMostTransactionNode = this.getAncestorTransactionNode_(changedPath);
+  var path = rootMostTransactionNode.path();
+  var queue = this.buildTransactionQueue_(rootMostTransactionNode);
+  this.rerunTransactionQueue_(queue, path);
+  return path;
+};
+fb.core.Repo.prototype.rerunTransactionQueue_ = function(queue, path) {
+  if (queue.length === 0) {
+    return;
+  }
+  var callbacks = [];
+  var events = [];
+  var setsToIgnore = goog.array.map(queue, function(q) {
+    return q.currentWriteId;
+  });
+  for (var i = 0;i < queue.length;i++) {
+    var transaction = queue[i];
+    var relativePath = fb.core.util.Path.relativePath(path, transaction.path);
+    var abortTransaction = false, abortReason;
+    fb.core.util.assert(relativePath !== null, "rerunTransactionsUnderNode_: relativePath should not be null.");
+    if (transaction.status === fb.core.TransactionStatus.NEEDS_ABORT) {
+      abortTransaction = true;
+      abortReason = transaction.abortReason;
+      events = events.concat(this.serverSyncTree_.ackUserWrite(transaction.currentWriteId, true));
+    } else {
+      if (transaction.status === fb.core.TransactionStatus.RUN) {
+        if (transaction.retryCount >= fb.core.Repo.MAX_TRANSACTION_RETRIES_) {
+          abortTransaction = true;
+          abortReason = "maxretry";
+          events = events.concat(this.serverSyncTree_.ackUserWrite(transaction.currentWriteId, true));
+        } else {
+          var currentNode = this.getLatestState_(transaction.path, setsToIgnore);
+          transaction.currentInputSnapshot = currentNode;
+          var newData = queue[i].update(currentNode.val());
+          if (goog.isDef(newData)) {
+            fb.core.util.validation.validateFirebaseData("transaction failed: Data returned ", newData, transaction.path);
+            var newDataNode = fb.core.snap.NodeFromJSON(newData);
+            var hasExplicitPriority = typeof newData === "object" && newData != null && fb.util.obj.contains(newData, ".priority");
+            if (!hasExplicitPriority) {
+              newDataNode = newDataNode.updatePriority(currentNode.getPriority());
+            }
+            var oldWriteId = transaction.currentWriteId;
+            var serverValues = this.generateServerValues();
+            var newNodeResolved = fb.core.util.ServerValues.resolveDeferredValueSnapshot(newDataNode, serverValues);
+            transaction.currentOutputSnapshotRaw = newDataNode;
+            transaction.currentOutputSnapshotResolved = newNodeResolved;
+            transaction.currentWriteId = this.getNextWriteId_();
+            goog.array.remove(setsToIgnore, oldWriteId);
+            events = events.concat(this.serverSyncTree_.applyUserOverwrite(transaction.path, newNodeResolved, transaction.currentWriteId, transaction.applyLocally));
+            events = events.concat(this.serverSyncTree_.ackUserWrite(oldWriteId, true));
+          } else {
+            abortTransaction = true;
+            abortReason = "nodata";
+            events = events.concat(this.serverSyncTree_.ackUserWrite(transaction.currentWriteId, true));
+          }
+        }
+      }
+    }
+    this.eventQueue_.raiseEventsForChangedPath(path, events);
+    events = [];
+    if (abortTransaction) {
+      queue[i].status = fb.core.TransactionStatus.COMPLETED;
+      (function(unwatcher) {
+        setTimeout(unwatcher, Math.floor(0));
+      })(queue[i].unwatcher);
+      if (queue[i].onComplete) {
+        if (abortReason === "nodata") {
+          var ref = new Firebase(this, queue[i].path);
+          var lastInput = (queue[i].currentInputSnapshot);
+          var snapshot = new fb.api.DataSnapshot(lastInput, ref, fb.core.snap.PriorityIndex);
+          callbacks.push(goog.bind(queue[i].onComplete, null, null, false, snapshot));
+        } else {
+          callbacks.push(goog.bind(queue[i].onComplete, null, new Error(abortReason), false, null));
+        }
+      }
+    }
+  }
+  this.pruneCompletedTransactionsBelowNode_(this.transactionQueueTree_);
+  for (i = 0;i < callbacks.length;i++) {
+    fb.core.util.exceptionGuard(callbacks[i]);
+  }
+  this.sendReadyTransactions_();
+};
+fb.core.Repo.prototype.getAncestorTransactionNode_ = function(path) {
+  var front;
+  var transactionNode = this.transactionQueueTree_;
+  while ((front = path.getFront()) !== null && transactionNode.getValue() === null) {
+    transactionNode = transactionNode.subTree(front);
+    path = path.popFront();
+  }
+  return transactionNode;
+};
+fb.core.Repo.prototype.buildTransactionQueue_ = function(transactionNode) {
+  var transactionQueue = [];
+  this.aggregateTransactionQueuesForNode_(transactionNode, transactionQueue);
+  transactionQueue.sort(function(a, b) {
+    return a.order - b.order;
+  });
+  return transactionQueue;
+};
+fb.core.Repo.prototype.aggregateTransactionQueuesForNode_ = function(node, queue) {
+  var nodeQueue = node.getValue();
+  if (nodeQueue !== null) {
+    for (var i = 0;i < nodeQueue.length;i++) {
+      queue.push(nodeQueue[i]);
+    }
+  }
+  var self = this;
+  node.forEachChild(function(child) {
+    self.aggregateTransactionQueuesForNode_(child, queue);
+  });
+};
+fb.core.Repo.prototype.pruneCompletedTransactionsBelowNode_ = function(node) {
+  var queue = node.getValue();
+  if (queue) {
+    var to = 0;
+    for (var from = 0;from < queue.length;from++) {
+      if (queue[from].status !== fb.core.TransactionStatus.COMPLETED) {
+        queue[to] = queue[from];
+        to++;
+      }
+    }
+    queue.length = to;
+    node.setValue(queue.length > 0 ? queue : null);
+  }
+  var self = this;
+  node.forEachChild(function(childNode) {
+    self.pruneCompletedTransactionsBelowNode_(childNode);
+  });
+};
+fb.core.Repo.prototype.abortTransactions_ = function(path) {
+  var affectedPath = this.getAncestorTransactionNode_(path).path();
+  var transactionNode = this.transactionQueueTree_.subTree(path);
+  var self = this;
+  transactionNode.forEachAncestor(function(node) {
+    self.abortTransactionsOnNode_(node);
+  });
+  this.abortTransactionsOnNode_(transactionNode);
+  transactionNode.forEachDescendant(function(node) {
+    self.abortTransactionsOnNode_(node);
+  });
+  return affectedPath;
+};
+fb.core.Repo.prototype.abortTransactionsOnNode_ = function(node) {
+  var queue = node.getValue();
+  if (queue !== null) {
+    var callbacks = [];
+    var events = [];
+    var lastSent = -1;
+    for (var i = 0;i < queue.length;i++) {
+      if (queue[i].status === fb.core.TransactionStatus.SENT_NEEDS_ABORT) {
+      } else {
+        if (queue[i].status === fb.core.TransactionStatus.SENT) {
+          fb.core.util.assert(lastSent === i - 1, "All SENT items should be at beginning of queue.");
+          lastSent = i;
+          queue[i].status = fb.core.TransactionStatus.SENT_NEEDS_ABORT;
+          queue[i].abortReason = "set";
+        } else {
+          fb.core.util.assert(queue[i].status === fb.core.TransactionStatus.RUN, "Unexpected transaction status in abort");
+          queue[i].unwatcher();
+          events = events.concat(this.serverSyncTree_.ackUserWrite(queue[i].currentWriteId, true));
+          if (queue[i].onComplete) {
+            var snapshot = null;
+            callbacks.push(goog.bind(queue[i].onComplete, null, new Error("set"), false, snapshot));
+          }
+        }
+      }
+    }
+    if (lastSent === -1) {
+      node.setValue(null);
+    } else {
+      queue.length = lastSent + 1;
+    }
+    this.eventQueue_.raiseEventsForChangedPath(node.path(), events);
+    for (i = 0;i < callbacks.length;i++) {
+      fb.core.util.exceptionGuard(callbacks[i]);
+    }
+  }
+};
+goog.provide("fb.core.RepoManager");
+goog.require("fb.core.Repo");
+goog.require("fb.core.Repo_transaction");
+goog.require("fb.util.obj");
+fb.core.RepoManager = function() {
+  this.repos_ = {};
+  this.useRestClient_ = false;
+};
+goog.addSingletonGetter(fb.core.RepoManager);
+fb.core.RepoManager.prototype.interrupt = function() {
+  for (var repo in this.repos_) {
+    this.repos_[repo].interrupt();
+  }
+};
+goog.exportProperty(fb.core.RepoManager.prototype, "interrupt", fb.core.RepoManager.prototype.interrupt);
+fb.core.RepoManager.prototype.resume = function() {
+  for (var repo in this.repos_) {
+    this.repos_[repo].resume();
+  }
+};
+goog.exportProperty(fb.core.RepoManager.prototype, "resume", fb.core.RepoManager.prototype.resume);
+fb.core.RepoManager.prototype.getRepo = function(repoInfo) {
+  var repoHashString = repoInfo.toString();
+  var repo = fb.util.obj.get(this.repos_, repoHashString);
+  if (!repo) {
+    repo = new fb.core.Repo(repoInfo, this.useRestClient_);
+    this.repos_[repoHashString] = repo;
+  }
+  return repo;
+};
+fb.core.RepoManager.prototype.forceRestClient = function() {
+  this.useRestClient_ = true;
+};
+goog.provide("fb.api.OnDisconnect");
+goog.require("fb.constants");
+goog.require("fb.core.Repo");
+goog.require("fb.core.util.validation");
+goog.require("fb.util.validation");
+fb.api.OnDisconnect = function(repo, path) {
+  this.repo_ = repo;
+  this.path_ = path;
+};
+fb.api.OnDisconnect.prototype.cancel = function(opt_onComplete) {
+  fb.util.validation.validateArgCount("Firebase.onDisconnect().cancel", 0, 1, arguments.length);
+  fb.util.validation.validateCallback("Firebase.onDisconnect().cancel", 1, opt_onComplete, true);
+  this.repo_.onDisconnectCancel(this.path_, opt_onComplete || null);
+};
+goog.exportProperty(fb.api.OnDisconnect.prototype, "cancel", fb.api.OnDisconnect.prototype.cancel);
+fb.api.OnDisconnect.prototype.remove = function(opt_onComplete) {
+  fb.util.validation.validateArgCount("Firebase.onDisconnect().remove", 0, 1, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.onDisconnect().remove", this.path_);
+  fb.util.validation.validateCallback("Firebase.onDisconnect().remove", 1, opt_onComplete, true);
+  this.repo_.onDisconnectSet(this.path_, null, opt_onComplete);
+};
+goog.exportProperty(fb.api.OnDisconnect.prototype, "remove", fb.api.OnDisconnect.prototype.remove);
+fb.api.OnDisconnect.prototype.set = function(value, opt_onComplete) {
+  fb.util.validation.validateArgCount("Firebase.onDisconnect().set", 1, 2, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.onDisconnect().set", this.path_);
+  fb.core.util.validation.validateFirebaseDataArg("Firebase.onDisconnect().set", 1, value, this.path_, false);
+  fb.util.validation.validateCallback("Firebase.onDisconnect().set", 2, opt_onComplete, true);
+  this.repo_.onDisconnectSet(this.path_, value, opt_onComplete);
+};
+goog.exportProperty(fb.api.OnDisconnect.prototype, "set", fb.api.OnDisconnect.prototype.set);
+fb.api.OnDisconnect.prototype.setWithPriority = function(value, priority, opt_onComplete) {
+  fb.util.validation.validateArgCount("Firebase.onDisconnect().setWithPriority", 2, 3, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.onDisconnect().setWithPriority", this.path_);
+  fb.core.util.validation.validateFirebaseDataArg("Firebase.onDisconnect().setWithPriority", 1, value, this.path_, false);
+  fb.core.util.validation.validatePriority("Firebase.onDisconnect().setWithPriority", 2, priority, false);
+  fb.util.validation.validateCallback("Firebase.onDisconnect().setWithPriority", 3, opt_onComplete, true);
+  this.repo_.onDisconnectSetWithPriority(this.path_, value, priority, opt_onComplete);
+};
+goog.exportProperty(fb.api.OnDisconnect.prototype, "setWithPriority", fb.api.OnDisconnect.prototype.setWithPriority);
+fb.api.OnDisconnect.prototype.update = function(objectToMerge, opt_onComplete) {
+  fb.util.validation.validateArgCount("Firebase.onDisconnect().update", 1, 2, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.onDisconnect().update", this.path_);
+  if (goog.isArray(objectToMerge)) {
+    var newObjectToMerge = {};
+    for (var i = 0;i < objectToMerge.length;++i) {
+      newObjectToMerge["" + i] = objectToMerge[i];
+    }
+    objectToMerge = newObjectToMerge;
+    fb.core.util.warn("Passing an Array to Firebase.onDisconnect().update() is deprecated. Use set() if you want to overwrite the " + "existing data, or an Object with integer keys if you really do want to only update some of the children.");
+  }
+  fb.core.util.validation.validateFirebaseMergeDataArg("Firebase.onDisconnect().update", 1, objectToMerge, this.path_, false);
+  fb.util.validation.validateCallback("Firebase.onDisconnect().update", 2, opt_onComplete, true);
+  this.repo_.onDisconnectUpdate(this.path_, objectToMerge, opt_onComplete);
+};
+goog.exportProperty(fb.api.OnDisconnect.prototype, "update", fb.api.OnDisconnect.prototype.update);
+goog.provide("fb.api.Query");
+goog.require("fb.api.DataSnapshot");
+goog.require("fb.core.snap");
+goog.require("fb.core.util");
+goog.require("fb.core.util.validation");
+goog.require("fb.core.view.EventRegistration");
+goog.require("fb.core.view.QueryParams");
+goog.require("fb.util.json");
+goog.require("fb.util.validation");
+fb.api.Query = function(repo, path, queryParams, orderByCalled) {
+  this.repo = repo;
+  this.path = path;
+  this.queryParams_ = queryParams;
+  this.orderByCalled_ = orderByCalled;
+};
+fb.api.Query.prototype.validateQueryEndpoints_ = function(params) {
+  var startNode = null;
+  var endNode = null;
+  if (params.hasStart()) {
+    startNode = params.getIndexStartValue();
+  }
+  if (params.hasEnd()) {
+    endNode = params.getIndexEndValue();
+  }
+  if (params.getIndex() === fb.core.snap.KeyIndex) {
+    var tooManyArgsError = "Query: When ordering by key, you may only pass one argument to " + "startAt(), endAt(), or equalTo().";
+    var wrongArgTypeError = "Query: When ordering by key, the argument passed to startAt(), endAt()," + "or equalTo() must be a string.";
+    if (params.hasStart()) {
+      var startName = params.getIndexStartName();
+      if (startName != fb.core.util.MIN_NAME) {
+        throw new Error(tooManyArgsError);
+      } else {
+        if (typeof startNode !== "string") {
+          throw new Error(wrongArgTypeError);
+        }
+      }
+    }
+    if (params.hasEnd()) {
+      var endName = params.getIndexEndName();
+      if (endName != fb.core.util.MAX_NAME) {
+        throw new Error(tooManyArgsError);
+      } else {
+        if (typeof endNode !== "string") {
+          throw new Error(wrongArgTypeError);
+        }
+      }
+    }
+  } else {
+    if (params.getIndex() === fb.core.snap.PriorityIndex) {
+      if (startNode != null && !fb.core.util.validation.isValidPriority(startNode) || endNode != null && !fb.core.util.validation.isValidPriority(endNode)) {
+        throw new Error("Query: When ordering by priority, the first argument passed to startAt(), " + "endAt(), or equalTo() must be a valid priority value (null, a number, or a string).");
+      }
+    } else {
+      fb.core.util.assert(params.getIndex() instanceof fb.core.snap.SubKeyIndex || params.getIndex() === fb.core.snap.ValueIndex, "unknown index type.");
+      if (startNode != null && typeof startNode === "object" || endNode != null && typeof endNode === "object") {
+        throw new Error("Query: First argument passed to startAt(), endAt(), or equalTo() cannot be " + "an object.");
+      }
+    }
+  }
+};
+fb.api.Query.prototype.validateLimit_ = function(params) {
+  if (params.hasStart() && params.hasEnd() && params.hasLimit() && !params.hasAnchoredLimit()) {
+    throw new Error("Query: Can't combine startAt(), endAt(), and limit(). Use limitToFirst() or limitToLast() instead.");
+  }
+};
+fb.api.Query.prototype.validateNoPreviousOrderByCall_ = function(fnName) {
+  if (this.orderByCalled_ === true) {
+    throw new Error(fnName + ": You can't combine multiple orderBy calls.");
+  }
+};
+fb.api.Query.prototype.getQueryParams = function() {
+  return this.queryParams_;
+};
+fb.api.Query.prototype.ref = function() {
+  fb.util.validation.validateArgCount("Query.ref", 0, 0, arguments.length);
+  return new Firebase(this.repo, this.path);
+};
+goog.exportProperty(fb.api.Query.prototype, "ref", fb.api.Query.prototype.ref);
+fb.api.Query.prototype.on = function(eventType, callback, cancelCallbackOrContext, context) {
+  fb.util.validation.validateArgCount("Query.on", 2, 4, arguments.length);
+  fb.core.util.validation.validateEventType("Query.on", 1, eventType, false);
+  fb.util.validation.validateCallback("Query.on", 2, callback, false);
+  var ret = this.getCancelAndContextArgs_("Query.on", cancelCallbackOrContext, context);
+  if (eventType === "value") {
+    this.onValueEvent(callback, ret.cancel, ret.context);
+  } else {
+    var callbacks = {};
+    callbacks[eventType] = callback;
+    this.onChildEvent(callbacks, ret.cancel, ret.context);
+  }
+  return callback;
+};
+goog.exportProperty(fb.api.Query.prototype, "on", fb.api.Query.prototype.on);
+fb.api.Query.prototype.onValueEvent = function(callback, cancelCallback, context) {
+  var container = new fb.core.view.ValueEventRegistration(callback, cancelCallback || null, context || null);
+  this.repo.addEventCallbackForQuery(this, container);
+};
+fb.api.Query.prototype.onChildEvent = function(callbacks, cancelCallback, context) {
+  var container = new fb.core.view.ChildEventRegistration(callbacks, cancelCallback, context);
+  this.repo.addEventCallbackForQuery(this, container);
+};
+fb.api.Query.prototype.off = function(eventType, callback, opt_context) {
+  fb.util.validation.validateArgCount("Query.off", 0, 3, arguments.length);
+  fb.core.util.validation.validateEventType("Query.off", 1, eventType, true);
+  fb.util.validation.validateCallback("Query.off", 2, callback, true);
+  fb.util.validation.validateContextObject("Query.off", 3, opt_context, true);
+  var container = null;
+  var callbacks = null;
+  if (eventType === "value") {
+    var valueCallback = (callback) || null;
+    container = new fb.core.view.ValueEventRegistration(valueCallback, null, opt_context || null);
+  } else {
+    if (eventType) {
+      if (callback) {
+        callbacks = {};
+        callbacks[eventType] = callback;
+      }
+      container = new fb.core.view.ChildEventRegistration(callbacks, null, opt_context || null);
+    }
+  }
+  this.repo.removeEventCallbackForQuery(this, container);
+};
+goog.exportProperty(fb.api.Query.prototype, "off", fb.api.Query.prototype.off);
+fb.api.Query.prototype.once = function(eventType, userCallback) {
+  fb.util.validation.validateArgCount("Query.once", 2, 4, arguments.length);
+  fb.core.util.validation.validateEventType("Query.once", 1, eventType, false);
+  fb.util.validation.validateCallback("Query.once", 2, userCallback, false);
+  var ret = this.getCancelAndContextArgs_("Query.once", arguments[2], arguments[3]);
+  var self = this, firstCall = true;
+  var onceCallback = function(snapshot) {
+    if (firstCall) {
+      firstCall = false;
+      self.off(eventType, onceCallback);
+      goog.bind(userCallback, ret.context)(snapshot);
+    }
+  };
+  this.on(eventType, onceCallback, function(err) {
+    self.off(eventType, onceCallback);
+    if (ret.cancel) {
+      goog.bind(ret.cancel, ret.context)(err);
+    }
+  });
+};
+goog.exportProperty(fb.api.Query.prototype, "once", fb.api.Query.prototype.once);
+fb.api.Query.prototype.limit = function(limit) {
+  fb.core.util.warn("Query.limit() being deprecated. " + "Please use Query.limitToFirst() or Query.limitToLast() instead.");
+  fb.util.validation.validateArgCount("Query.limit", 1, 1, arguments.length);
+  if (!goog.isNumber(limit) || Math.floor(limit) !== limit || limit <= 0) {
+    throw new Error("Query.limit: First argument must be a positive integer.");
+  }
+  if (this.queryParams_.hasLimit()) {
+    throw new Error("Query.limit: Limit was already set (by another call to limit, limitToFirst, or" + "limitToLast.");
+  }
+  var newParams = this.queryParams_.limit(limit);
+  this.validateLimit_(newParams);
+  return new fb.api.Query(this.repo, this.path, newParams, this.orderByCalled_);
+};
+goog.exportProperty(fb.api.Query.prototype, "limit", fb.api.Query.prototype.limit);
+fb.api.Query.prototype.limitToFirst = function(limit) {
+  fb.util.validation.validateArgCount("Query.limitToFirst", 1, 1, arguments.length);
+  if (!goog.isNumber(limit) || Math.floor(limit) !== limit || limit <= 0) {
+    throw new Error("Query.limitToFirst: First argument must be a positive integer.");
+  }
+  if (this.queryParams_.hasLimit()) {
+    throw new Error("Query.limitToFirst: Limit was already set (by another call to limit, " + "limitToFirst, or limitToLast).");
+  }
+  return new fb.api.Query(this.repo, this.path, this.queryParams_.limitToFirst(limit), this.orderByCalled_);
+};
+goog.exportProperty(fb.api.Query.prototype, "limitToFirst", fb.api.Query.prototype.limitToFirst);
+fb.api.Query.prototype.limitToLast = function(limit) {
+  fb.util.validation.validateArgCount("Query.limitToLast", 1, 1, arguments.length);
+  if (!goog.isNumber(limit) || Math.floor(limit) !== limit || limit <= 0) {
+    throw new Error("Query.limitToLast: First argument must be a positive integer.");
+  }
+  if (this.queryParams_.hasLimit()) {
+    throw new Error("Query.limitToLast: Limit was already set (by another call to limit, " + "limitToFirst, or limitToLast).");
+  }
+  return new fb.api.Query(this.repo, this.path, this.queryParams_.limitToLast(limit), this.orderByCalled_);
+};
+goog.exportProperty(fb.api.Query.prototype, "limitToLast", fb.api.Query.prototype.limitToLast);
+fb.api.Query.prototype.orderByChild = function(key) {
+  fb.util.validation.validateArgCount("Query.orderByChild", 1, 1, arguments.length);
+  if (key === "$key") {
+    throw new Error('Query.orderByChild: "$key" is invalid.  Use Query.orderByKey() instead.');
+  } else {
+    if (key === "$priority") {
+      throw new Error('Query.orderByChild: "$priority" is invalid.  Use Query.orderByPriority() instead.');
+    } else {
+      if (key === "$value") {
+        throw new Error('Query.orderByChild: "$value" is invalid.  Use Query.orderByValue() instead.');
+      }
+    }
+  }
+  fb.core.util.validation.validateKey("Query.orderByChild", 1, key, false);
+  this.validateNoPreviousOrderByCall_("Query.orderByChild");
+  var index = new fb.core.snap.SubKeyIndex(key);
+  var newParams = this.queryParams_.orderBy(index);
+  this.validateQueryEndpoints_(newParams);
+  return new fb.api.Query(this.repo, this.path, newParams, true);
+};
+goog.exportProperty(fb.api.Query.prototype, "orderByChild", fb.api.Query.prototype.orderByChild);
+fb.api.Query.prototype.orderByKey = function() {
+  fb.util.validation.validateArgCount("Query.orderByKey", 0, 0, arguments.length);
+  this.validateNoPreviousOrderByCall_("Query.orderByKey");
+  var newParams = this.queryParams_.orderBy(fb.core.snap.KeyIndex);
+  this.validateQueryEndpoints_(newParams);
+  return new fb.api.Query(this.repo, this.path, newParams, true);
+};
+goog.exportProperty(fb.api.Query.prototype, "orderByKey", fb.api.Query.prototype.orderByKey);
+fb.api.Query.prototype.orderByPriority = function() {
+  fb.util.validation.validateArgCount("Query.orderByPriority", 0, 0, arguments.length);
+  this.validateNoPreviousOrderByCall_("Query.orderByPriority");
+  var newParams = this.queryParams_.orderBy(fb.core.snap.PriorityIndex);
+  this.validateQueryEndpoints_(newParams);
+  return new fb.api.Query(this.repo, this.path, newParams, true);
+};
+goog.exportProperty(fb.api.Query.prototype, "orderByPriority", fb.api.Query.prototype.orderByPriority);
+fb.api.Query.prototype.orderByValue = function() {
+  fb.util.validation.validateArgCount("Query.orderByValue", 0, 0, arguments.length);
+  this.validateNoPreviousOrderByCall_("Query.orderByValue");
+  var newParams = this.queryParams_.orderBy(fb.core.snap.ValueIndex);
+  this.validateQueryEndpoints_(newParams);
+  return new fb.api.Query(this.repo, this.path, newParams, true);
+};
+goog.exportProperty(fb.api.Query.prototype, "orderByValue", fb.api.Query.prototype.orderByValue);
+fb.api.Query.prototype.startAt = function(value, name) {
+  fb.util.validation.validateArgCount("Query.startAt", 0, 2, arguments.length);
+  fb.core.util.validation.validateFirebaseDataArg("Query.startAt", 1, value, this.path, true);
+  fb.core.util.validation.validateKey("Query.startAt", 2, name, true);
+  var newParams = this.queryParams_.startAt(value, name);
+  this.validateLimit_(newParams);
+  this.validateQueryEndpoints_(newParams);
+  if (this.queryParams_.hasStart()) {
+    throw new Error("Query.startAt: Starting point was already set (by another call to startAt " + "or equalTo).");
+  }
+  if (!goog.isDef(value)) {
+    value = null;
+    name = null;
+  }
+  return new fb.api.Query(this.repo, this.path, newParams, this.orderByCalled_);
+};
+goog.exportProperty(fb.api.Query.prototype, "startAt", fb.api.Query.prototype.startAt);
+fb.api.Query.prototype.endAt = function(value, name) {
+  fb.util.validation.validateArgCount("Query.endAt", 0, 2, arguments.length);
+  fb.core.util.validation.validateFirebaseDataArg("Query.endAt", 1, value, this.path, true);
+  fb.core.util.validation.validateKey("Query.endAt", 2, name, true);
+  var newParams = this.queryParams_.endAt(value, name);
+  this.validateLimit_(newParams);
+  this.validateQueryEndpoints_(newParams);
+  if (this.queryParams_.hasEnd()) {
+    throw new Error("Query.endAt: Ending point was already set (by another call to endAt or " + "equalTo).");
+  }
+  return new fb.api.Query(this.repo, this.path, newParams, this.orderByCalled_);
+};
+goog.exportProperty(fb.api.Query.prototype, "endAt", fb.api.Query.prototype.endAt);
+fb.api.Query.prototype.equalTo = function(value, name) {
+  fb.util.validation.validateArgCount("Query.equalTo", 1, 2, arguments.length);
+  fb.core.util.validation.validateFirebaseDataArg("Query.equalTo", 1, value, this.path, false);
+  fb.core.util.validation.validateKey("Query.equalTo", 2, name, true);
+  if (this.queryParams_.hasStart()) {
+    throw new Error("Query.equalTo: Starting point was already set (by another call to endAt or " + "equalTo).");
+  }
+  if (this.queryParams_.hasEnd()) {
+    throw new Error("Query.equalTo: Ending point was already set (by another call to endAt or " + "equalTo).");
+  }
+  return this.startAt(value, name).endAt(value, name);
+};
+goog.exportProperty(fb.api.Query.prototype, "equalTo", fb.api.Query.prototype.equalTo);
+fb.api.Query.prototype.toString = function() {
+  fb.util.validation.validateArgCount("Query.toString", 0, 0, arguments.length);
+  var url = this.repo.toString() + this.path.toUrlEncodedString();
+  var querystring = fb.util.querystring(this.queryParams_.toRestQueryStringParameters());
+  url += querystring.replace(/^&/, "");
+  return url;
+};
+goog.exportProperty(fb.api.Query.prototype, "toString", fb.api.Query.prototype.toString);
+fb.api.Query.prototype.queryObject = function() {
+  return this.queryParams_.getQueryObject();
+};
+fb.api.Query.prototype.queryIdentifier = function() {
+  var obj = this.queryObject();
+  var id = fb.core.util.ObjectToUniqueKey(obj);
+  return id === "{}" ? "default" : id;
+};
+fb.api.Query.prototype.getCancelAndContextArgs_ = function(fnName, cancelOrContext, context) {
+  var ret = {cancel:null, context:null};
+  if (cancelOrContext && context) {
+    ret.cancel = (cancelOrContext);
+    fb.util.validation.validateCallback(fnName, 3, ret.cancel, true);
+    ret.context = context;
+    fb.util.validation.validateContextObject(fnName, 4, ret.context, true);
+  } else {
+    if (cancelOrContext) {
+      if (typeof cancelOrContext === "object" && cancelOrContext !== null) {
+        ret.context = cancelOrContext;
+      } else {
+        if (typeof cancelOrContext === "function") {
+          ret.cancel = cancelOrContext;
+        } else {
+          throw new Error(fb.util.validation.errorPrefix(fnName, 3, true) + " must either be a cancel callback or a context object.");
+        }
+      }
+    }
+  }
+  return ret;
+};
+goog.provide("fb.api.TEST_ACCESS");
+goog.require("fb.core.PersistentConnection");
+fb.api.TEST_ACCESS.DataConnection = fb.core.PersistentConnection;
+goog.exportProperty(fb.api.TEST_ACCESS, "DataConnection", fb.api.TEST_ACCESS.DataConnection);
+fb.core.PersistentConnection.prototype.simpleListen = function(pathString, onComplete) {
+  this.sendRequest("q", {"p":pathString}, onComplete);
+};
+goog.exportProperty(fb.api.TEST_ACCESS.DataConnection.prototype, "simpleListen", fb.api.TEST_ACCESS.DataConnection.prototype.simpleListen);
+fb.core.PersistentConnection.prototype.echo = function(data, onEcho) {
+  this.sendRequest("echo", {"d":data}, onEcho);
+};
+goog.exportProperty(fb.api.TEST_ACCESS.DataConnection.prototype, "echo", fb.api.TEST_ACCESS.DataConnection.prototype.echo);
+goog.exportProperty(fb.core.PersistentConnection.prototype, "interrupt", fb.core.PersistentConnection.prototype.interrupt);
+fb.api.TEST_ACCESS.RealTimeConnection = fb.realtime.Connection;
+goog.exportProperty(fb.api.TEST_ACCESS, "RealTimeConnection", fb.api.TEST_ACCESS.RealTimeConnection);
+goog.exportProperty(fb.realtime.Connection.prototype, "sendRequest", fb.realtime.Connection.prototype.sendRequest);
+goog.exportProperty(fb.realtime.Connection.prototype, "close", fb.realtime.Connection.prototype.close);
+fb.api.TEST_ACCESS.hijackHash = function(newHash) {
+  var oldPut = fb.core.PersistentConnection.prototype.put;
+  fb.core.PersistentConnection.prototype.put = function(pathString, data, opt_onComplete, opt_hash) {
+    if (goog.isDef(opt_hash)) {
+      opt_hash = newHash();
+    }
+    oldPut.call(this, pathString, data, opt_onComplete, opt_hash);
+  };
+  return function() {
+    fb.core.PersistentConnection.prototype.put = oldPut;
+  };
+};
+goog.exportProperty(fb.api.TEST_ACCESS, "hijackHash", fb.api.TEST_ACCESS.hijackHash);
+fb.api.TEST_ACCESS.ConnectionTarget = fb.core.RepoInfo;
+goog.exportProperty(fb.api.TEST_ACCESS, "ConnectionTarget", fb.api.TEST_ACCESS.ConnectionTarget);
+fb.api.TEST_ACCESS.queryIdentifier = function(query) {
+  return query.queryIdentifier();
+};
+goog.exportProperty(fb.api.TEST_ACCESS, "queryIdentifier", fb.api.TEST_ACCESS.queryIdentifier);
+fb.api.TEST_ACCESS.listens = function(firebaseRef) {
+  return firebaseRef.repo.persistentConnection_.listens_;
+};
+goog.exportProperty(fb.api.TEST_ACCESS, "listens", fb.api.TEST_ACCESS.listens);
+fb.api.TEST_ACCESS.forceRestClient = function(repoManager) {
+  repoManager.forceRestClient();
+};
+goog.exportProperty(fb.api.TEST_ACCESS, "forceRestClient", fb.api.TEST_ACCESS.forceRestClient);
+goog.provide("Firebase");
+goog.require("fb.api.INTERNAL");
+goog.require("fb.api.OnDisconnect");
+goog.require("fb.api.Query");
+goog.require("fb.api.TEST_ACCESS");
+goog.require("fb.constants");
+goog.require("fb.core.Repo");
+goog.require("fb.core.RepoManager");
+goog.require("fb.core.storage");
+goog.require("fb.core.util");
+goog.require("fb.core.util.nextPushId");
+goog.require("fb.core.util.validation");
+goog.require("goog.string");
+Firebase = function(urlOrRepo, pathOrContext) {
+  var repo, path, repoManager;
+  if (urlOrRepo instanceof fb.core.Repo) {
+    repo = urlOrRepo;
+    path = (pathOrContext);
+  } else {
+    fb.util.validation.validateArgCount("new Firebase", 1, 2, arguments.length);
+    var parsedUrl = fb.core.util.parseRepoInfo(arguments[0]), repoInfo = parsedUrl.repoInfo;
+    fb.core.util.validation.validateUrl("new Firebase", 1, parsedUrl);
+    if (pathOrContext) {
+      if (pathOrContext instanceof fb.core.RepoManager) {
+        repoManager = (pathOrContext);
+      } else {
+        if (goog.isString(pathOrContext)) {
+          repoManager = fb.core.RepoManager.getInstance();
+          repoInfo.persistenceKey = pathOrContext;
+        } else {
+          throw new Error("Expected a valid Firebase.Context for second argument to new Firebase()");
+        }
+      }
+    } else {
+      repoManager = fb.core.RepoManager.getInstance();
+    }
+    repo = repoManager.getRepo(repoInfo);
+    path = parsedUrl.path;
+  }
+  fb.api.Query.call(this, repo, path, fb.core.view.QueryParams.DEFAULT, false);
+};
+goog.inherits(Firebase, fb.api.Query);
+if (NODE_CLIENT) {
+  module["exports"] = Firebase;
+}
+Firebase.prototype.name = function() {
+  fb.core.util.warn("Firebase.name() being deprecated. Please use Firebase.key() instead.");
+  fb.util.validation.validateArgCount("Firebase.name", 0, 0, arguments.length);
+  return this.key();
+};
+Firebase.prototype.key = function() {
+  fb.util.validation.validateArgCount("Firebase.key", 0, 0, arguments.length);
+  if (this.path.isEmpty()) {
+    return null;
+  } else {
+    return this.path.getBack();
+  }
+};
+Firebase.prototype.child = function(pathString) {
+  fb.util.validation.validateArgCount("Firebase.child", 1, 1, arguments.length);
+  if (goog.isNumber(pathString)) {
+    pathString = String(pathString);
+  } else {
+    if (!(pathString instanceof fb.core.util.Path)) {
+      if (this.path.getFront() === null) {
+        fb.core.util.validation.validateRootPathString("Firebase.child", 1, pathString, false);
+      } else {
+        fb.core.util.validation.validatePathString("Firebase.child", 1, pathString, false);
+      }
+    }
+  }
+  return new Firebase(this.repo, this.path.child(pathString));
+};
+Firebase.prototype.parent = function() {
+  fb.util.validation.validateArgCount("Firebase.parent", 0, 0, arguments.length);
+  var parentPath = this.path.parent();
+  return parentPath === null ? null : new Firebase(this.repo, parentPath);
+};
+Firebase.prototype.root = function() {
+  fb.util.validation.validateArgCount("Firebase.ref", 0, 0, arguments.length);
+  var ref = this;
+  while (ref.parent() !== null) {
+    ref = ref.parent();
+  }
+  return ref;
+};
+Firebase.prototype.set = function(newVal, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.set", 1, 2, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.set", this.path);
+  fb.core.util.validation.validateFirebaseDataArg("Firebase.set", 1, newVal, this.path, false);
+  fb.util.validation.validateCallback("Firebase.set", 2, onComplete, true);
+  this.repo.setWithPriority(this.path, newVal, null, onComplete || null);
+};
+Firebase.prototype.update = function(objectToMerge, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.update", 1, 2, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.update", this.path);
+  if (goog.isArray(objectToMerge)) {
+    var newObjectToMerge = {};
+    for (var i = 0;i < objectToMerge.length;++i) {
+      newObjectToMerge["" + i] = objectToMerge[i];
+    }
+    objectToMerge = newObjectToMerge;
+    fb.core.util.warn("Passing an Array to Firebase.update() is deprecated. Use set() if you want to overwrite the existing data, or " + "an Object with integer keys if you really do want to only update some of the children.");
+  }
+  fb.core.util.validation.validateFirebaseMergeDataArg("Firebase.update", 1, objectToMerge, this.path, false);
+  fb.util.validation.validateCallback("Firebase.update", 2, onComplete, true);
+  this.repo.update(this.path, objectToMerge, onComplete || null);
+};
+Firebase.prototype.setWithPriority = function(newVal, newPriority, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.setWithPriority", 2, 3, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.setWithPriority", this.path);
+  fb.core.util.validation.validateFirebaseDataArg("Firebase.setWithPriority", 1, newVal, this.path, false);
+  fb.core.util.validation.validatePriority("Firebase.setWithPriority", 2, newPriority, false);
+  fb.util.validation.validateCallback("Firebase.setWithPriority", 3, onComplete, true);
+  if (this.key() === ".length" || this.key() === ".keys") {
+    throw "Firebase.setWithPriority failed: " + this.key() + " is a read-only object.";
+  }
+  this.repo.setWithPriority(this.path, newVal, newPriority, onComplete || null);
+};
+Firebase.prototype.remove = function(onComplete) {
+  fb.util.validation.validateArgCount("Firebase.remove", 0, 1, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.remove", this.path);
+  fb.util.validation.validateCallback("Firebase.remove", 1, onComplete, true);
+  this.set(null, onComplete);
+};
+Firebase.prototype.transaction = function(transactionUpdate, onComplete, applyLocally) {
+  fb.util.validation.validateArgCount("Firebase.transaction", 1, 3, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.transaction", this.path);
+  fb.util.validation.validateCallback("Firebase.transaction", 1, transactionUpdate, false);
+  fb.util.validation.validateCallback("Firebase.transaction", 2, onComplete, true);
+  fb.core.util.validation.validateBoolean("Firebase.transaction", 3, applyLocally, true);
+  if (this.key() === ".length" || this.key() === ".keys") {
+    throw "Firebase.transaction failed: " + this.key() + " is a read-only object.";
+  }
+  if (typeof applyLocally === "undefined") {
+    applyLocally = true;
+  }
+  this.repo.startTransaction(this.path, transactionUpdate, onComplete || null, applyLocally);
+};
+Firebase.prototype.setPriority = function(priority, opt_onComplete) {
+  fb.util.validation.validateArgCount("Firebase.setPriority", 1, 2, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.setPriority", this.path);
+  fb.core.util.validation.validatePriority("Firebase.setPriority", 1, priority, false);
+  fb.util.validation.validateCallback("Firebase.setPriority", 2, opt_onComplete, true);
+  this.repo.setWithPriority(this.path.child(".priority"), priority, null, opt_onComplete);
+};
+Firebase.prototype.push = function(value, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.push", 0, 2, arguments.length);
+  fb.core.util.validation.validateWritablePath("Firebase.push", this.path);
+  fb.core.util.validation.validateFirebaseDataArg("Firebase.push", 1, value, this.path, true);
+  fb.util.validation.validateCallback("Firebase.push", 2, onComplete, true);
+  var now = this.repo.serverTime();
+  var name = fb.core.util.nextPushId(now);
+  var pushedRef = this.child(name);
+  if (typeof value !== "undefined" && value !== null) {
+    pushedRef.set(value, onComplete);
+  }
+  return pushedRef;
+};
+Firebase.prototype.onDisconnect = function() {
+  fb.core.util.validation.validateWritablePath("Firebase.onDisconnect", this.path);
+  return new fb.api.OnDisconnect(this.repo, this.path);
+};
+Firebase.prototype.auth = function(cred, opt_onComplete, opt_onCancel) {
+  fb.core.util.warn("FirebaseRef.auth() being deprecated. " + "Please use FirebaseRef.authWithCustomToken() instead.");
+  fb.util.validation.validateArgCount("Firebase.auth", 1, 3, arguments.length);
+  fb.core.util.validation.validateCredential("Firebase.auth", 1, cred, false);
+  fb.util.validation.validateCallback("Firebase.auth", 2, opt_onComplete, true);
+  fb.util.validation.validateCallback("Firebase.auth", 3, opt_onComplete, true);
+  var clientOptions = {};
+  clientOptions[fb.login.Constants.CLIENT_OPTION_SESSION_PERSISTENCE] = "none";
+  this.repo.auth.authenticate(cred, {}, clientOptions, opt_onComplete, opt_onCancel);
+};
+Firebase.prototype.unauth = function(opt_onComplete) {
+  fb.util.validation.validateArgCount("Firebase.unauth", 0, 1, arguments.length);
+  fb.util.validation.validateCallback("Firebase.unauth", 1, opt_onComplete, true);
+  this.repo.auth.unauthenticate(opt_onComplete);
+};
+Firebase.prototype.getAuth = function() {
+  fb.util.validation.validateArgCount("Firebase.getAuth", 0, 0, arguments.length);
+  return this.repo.auth.getAuth();
+};
+Firebase.prototype.onAuth = function(callback, opt_context) {
+  fb.util.validation.validateArgCount("Firebase.onAuth", 1, 2, arguments.length);
+  fb.util.validation.validateCallback("Firebase.onAuth", 1, callback, false);
+  fb.util.validation.validateContextObject("Firebase.onAuth", 2, opt_context, true);
+  this.repo.auth.on("auth_status", callback, opt_context);
+};
+Firebase.prototype.offAuth = function(callback, opt_context) {
+  fb.util.validation.validateArgCount("Firebase.offAuth", 1, 2, arguments.length);
+  fb.util.validation.validateCallback("Firebase.offAuth", 1, callback, false);
+  fb.util.validation.validateContextObject("Firebase.offAuth", 2, opt_context, true);
+  this.repo.auth.off("auth_status", callback, opt_context);
+};
+Firebase.prototype.authWithCustomToken = function(token, onComplete, opt_options) {
+  fb.util.validation.validateArgCount("Firebase.authWithCustomToken", 2, 3, arguments.length);
+  fb.core.util.validation.validateCredential("Firebase.authWithCustomToken", 1, token, false);
+  fb.util.validation.validateCallback("Firebase.authWithCustomToken", 2, onComplete, false);
+  fb.core.util.validation.validateObject("Firebase.authWithCustomToken", 3, opt_options, true);
+  this.repo.auth.authenticate(token, {}, opt_options || {}, onComplete);
+};
+Firebase.prototype.authWithOAuthPopup = function(provider, onComplete, opt_options) {
+  fb.util.validation.validateArgCount("Firebase.authWithOAuthPopup", 2, 3, arguments.length);
+  fb.core.util.validation.validateString("Firebase.authWithOAuthPopup", 1, provider, false);
+  fb.util.validation.validateCallback("Firebase.authWithOAuthPopup", 2, onComplete, false);
+  fb.core.util.validation.validateObject("Firebase.authWithOAuthPopup", 3, opt_options, true);
+  this.repo.auth.authWithPopup(provider, opt_options, onComplete);
+};
+Firebase.prototype.authWithOAuthRedirect = function(provider, onErr, opt_options) {
+  fb.util.validation.validateArgCount("Firebase.authWithOAuthRedirect", 2, 3, arguments.length);
+  fb.core.util.validation.validateString("Firebase.authWithOAuthRedirect", 1, provider, false);
+  fb.util.validation.validateCallback("Firebase.authWithOAuthRedirect", 2, onErr, false);
+  fb.core.util.validation.validateObject("Firebase.authWithOAuthRedirect", 3, opt_options, true);
+  this.repo.auth.authWithRedirect(provider, opt_options, onErr);
+};
+Firebase.prototype.authWithOAuthToken = function(provider, params, onComplete, opt_options) {
+  fb.util.validation.validateArgCount("Firebase.authWithOAuthToken", 3, 4, arguments.length);
+  fb.core.util.validation.validateString("Firebase.authWithOAuthToken", 1, provider, false);
+  fb.util.validation.validateCallback("Firebase.authWithOAuthToken", 3, onComplete, false);
+  fb.core.util.validation.validateObject("Firebase.authWithOAuthToken", 4, opt_options, true);
+  if (goog.isString(params)) {
+    fb.core.util.validation.validateString("Firebase.authWithOAuthToken", 2, params, false);
+    this.repo.auth.authWithCredential(provider + "/token", {"access_token":params}, opt_options, onComplete);
+  } else {
+    fb.core.util.validation.validateObject("Firebase.authWithOAuthToken", 2, params, false);
+    this.repo.auth.authWithCredential(provider + "/token", params, opt_options, onComplete);
+  }
+};
+Firebase.prototype.authAnonymously = function(onComplete, opt_options) {
+  fb.util.validation.validateArgCount("Firebase.authAnonymously", 1, 2, arguments.length);
+  fb.util.validation.validateCallback("Firebase.authAnonymously", 1, onComplete, false);
+  fb.core.util.validation.validateObject("Firebase.authAnonymously", 2, opt_options, true);
+  this.repo.auth.authWithCredential("anonymous", {}, opt_options, onComplete);
+};
+Firebase.prototype.authWithPassword = function(params, onComplete, opt_options) {
+  fb.util.validation.validateArgCount("Firebase.authWithPassword", 2, 3, arguments.length);
+  fb.core.util.validation.validateObject("Firebase.authWithPassword", 1, params, false);
+  fb.core.util.validation.validateObjectContainsKey("Firebase.authWithPassword", 1, params, "email", false, "string");
+  fb.core.util.validation.validateObjectContainsKey("Firebase.authWithPassword", 1, params, "password", false, "string");
+  fb.util.validation.validateCallback("Firebase.authAnonymously", 2, onComplete, false);
+  fb.core.util.validation.validateObject("Firebase.authAnonymously", 3, opt_options, true);
+  this.repo.auth.authWithCredential("password", params, opt_options, onComplete);
+};
+Firebase.prototype.createUser = function(params, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.createUser", 2, 2, arguments.length);
+  fb.core.util.validation.validateObject("Firebase.createUser", 1, params, false);
+  fb.core.util.validation.validateObjectContainsKey("Firebase.createUser", 1, params, "email", false, "string");
+  fb.core.util.validation.validateObjectContainsKey("Firebase.createUser", 1, params, "password", false, "string");
+  fb.util.validation.validateCallback("Firebase.createUser", 2, onComplete, false);
+  this.repo.auth.createUser(params, onComplete);
+};
+Firebase.prototype.removeUser = function(params, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.removeUser", 2, 2, arguments.length);
+  fb.core.util.validation.validateObject("Firebase.removeUser", 1, params, false);
+  fb.core.util.validation.validateObjectContainsKey("Firebase.removeUser", 1, params, "email", false, "string");
+  fb.core.util.validation.validateObjectContainsKey("Firebase.removeUser", 1, params, "password", false, "string");
+  fb.util.validation.validateCallback("Firebase.removeUser", 2, onComplete, false);
+  this.repo.auth.removeUser(params, onComplete);
+};
+Firebase.prototype.changePassword = function(params, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.changePassword", 2, 2, arguments.length);
+  fb.core.util.validation.validateObject("Firebase.changePassword", 1, params, false);
+  fb.core.util.validation.validateObjectContainsKey("Firebase.changePassword", 1, params, "email", false, "string");
+  fb.core.util.validation.validateObjectContainsKey("Firebase.changePassword", 1, params, "oldPassword", false, "string");
+  fb.core.util.validation.validateObjectContainsKey("Firebase.changePassword", 1, params, "newPassword", false, "string");
+  fb.util.validation.validateCallback("Firebase.changePassword", 2, onComplete, false);
+  this.repo.auth.changePassword(params, onComplete);
+};
+Firebase.prototype.changeEmail = function(params, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.changeEmail", 2, 2, arguments.length);
+  fb.core.util.validation.validateObject("Firebase.changeEmail", 1, params, false);
+  fb.core.util.validation.validateObjectContainsKey("Firebase.changeEmail", 1, params, "oldEmail", false, "string");
+  fb.core.util.validation.validateObjectContainsKey("Firebase.changeEmail", 1, params, "newEmail", false, "string");
+  fb.core.util.validation.validateObjectContainsKey("Firebase.changeEmail", 1, params, "password", false, "string");
+  fb.util.validation.validateCallback("Firebase.changeEmail", 2, onComplete, false);
+  this.repo.auth.changeEmail(params, onComplete);
+};
+Firebase.prototype.resetPassword = function(params, onComplete) {
+  fb.util.validation.validateArgCount("Firebase.resetPassword", 2, 2, arguments.length);
+  fb.core.util.validation.validateObject("Firebase.resetPassword", 1, params, false);
+  fb.core.util.validation.validateObjectContainsKey("Firebase.resetPassword", 1, params, "email", false, "string");
+  fb.util.validation.validateCallback("Firebase.resetPassword", 2, onComplete, false);
+  this.repo.auth.resetPassword(params, onComplete);
+};
+Firebase.goOffline = function() {
+  fb.util.validation.validateArgCount("Firebase.goOffline", 0, 0, arguments.length);
+  fb.core.RepoManager.getInstance().interrupt();
+};
+Firebase.goOnline = function() {
+  fb.util.validation.validateArgCount("Firebase.goOnline", 0, 0, arguments.length);
+  fb.core.RepoManager.getInstance().resume();
+};
+Firebase.enableLogging = function(logger, persistent) {
+  fb.core.util.assert(!persistent || (logger === true || logger === false), "Can't turn on custom loggers persistently.");
+  if (logger === true) {
+    if (typeof console !== "undefined") {
+      if (typeof console.log === "function") {
+        fb.core.util.logger = goog.bind(console.log, console);
+      } else {
+        if (typeof console.log === "object") {
+          fb.core.util.logger = function(message) {
+            console.log(message);
+          };
+        }
+      }
+    }
+    if (persistent) {
+      fb.core.storage.SessionStorage.set("logging_enabled", true);
+    }
+  } else {
+    if (logger) {
+      fb.core.util.logger = logger;
+    } else {
+      fb.core.util.logger = null;
+      fb.core.storage.SessionStorage.remove("logging_enabled");
+    }
+  }
+};
+Firebase.ServerValue = {"TIMESTAMP":{".sv":"timestamp"}};
+Firebase.SDK_VERSION = CLIENT_VERSION;
+Firebase.INTERNAL = fb.api.INTERNAL;
+Firebase.Context = fb.core.RepoManager;
+Firebase.TEST_ACCESS = fb.api.TEST_ACCESS;
+
+Firebase.SDK_VERSION = '2.2.4';
+
diff --git a/ionic/components/app/test/hn/firebase.js b/ionic/components/app/test/hn/firebase.js
new file mode 100644
index 0000000000..31bd0fdc16
--- /dev/null
+++ b/ionic/components/app/test/hn/firebase.js
@@ -0,0 +1,263 @@
+/*! @license Firebase v2.2.4
+    License: https://www.firebase.com/terms/terms-of-service.html */
+(function() {var h,aa=this;function n(a){return void 0!==a}function ba(){}function ca(a){a.ub=function(){return a.tf?a.tf:a.tf=new a}}
+function da(a){var b=typeof a;if("object"==b)if(a){if(a instanceof Array)return"array";if(a instanceof Object)return b;var c=Object.prototype.toString.call(a);if("[object Window]"==c)return"object";if("[object Array]"==c||"number"==typeof a.length&&"undefined"!=typeof a.splice&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("splice"))return"array";if("[object Function]"==c||"undefined"!=typeof a.call&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("call"))return"function"}else return"null";
+else if("function"==b&&"undefined"==typeof a.call)return"object";return b}function ea(a){return"array"==da(a)}function fa(a){var b=da(a);return"array"==b||"object"==b&&"number"==typeof a.length}function p(a){return"string"==typeof a}function ga(a){return"number"==typeof a}function ha(a){return"function"==da(a)}function ia(a){var b=typeof a;return"object"==b&&null!=a||"function"==b}function ja(a,b,c){return a.call.apply(a.bind,arguments)}
+function ka(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}}function q(a,b,c){q=Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?ja:ka;return q.apply(null,arguments)}var la=Date.now||function(){return+new Date};
+function ma(a,b){function c(){}c.prototype=b.prototype;a.Zg=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.Vg=function(a,c,f){for(var g=Array(arguments.length-2),k=2;k<arguments.length;k++)g[k-2]=arguments[k];return b.prototype[c].apply(a,g)}};function r(a,b){for(var c in a)b.call(void 0,a[c],c,a)}function na(a,b){var c={},d;for(d in a)c[d]=b.call(void 0,a[d],d,a);return c}function oa(a,b){for(var c in a)if(!b.call(void 0,a[c],c,a))return!1;return!0}function pa(a){var b=0,c;for(c in a)b++;return b}function qa(a){for(var b in a)return b}function ra(a){var b=[],c=0,d;for(d in a)b[c++]=a[d];return b}function sa(a){var b=[],c=0,d;for(d in a)b[c++]=d;return b}function ta(a,b){for(var c in a)if(a[c]==b)return!0;return!1}
+function ua(a,b,c){for(var d in a)if(b.call(c,a[d],d,a))return d}function va(a,b){var c=ua(a,b,void 0);return c&&a[c]}function wa(a){for(var b in a)return!1;return!0}function xa(a){var b={},c;for(c in a)b[c]=a[c];return b}var ya="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
+function za(a,b){for(var c,d,e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(var f=0;f<ya.length;f++)c=ya[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}};function Aa(a){a=String(a);if(/^\s*$/.test(a)?0:/^[\],:{}\s\u2028\u2029]*$/.test(a.replace(/\\["\\\/bfnrtu]/g,"@").replace(/"[^"\\\n\r\u2028\u2029\x00-\x08\x0a-\x1f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,"]").replace(/(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g,"")))try{return eval("("+a+")")}catch(b){}throw Error("Invalid JSON string: "+a);}function Ba(){this.Pd=void 0}
+function Ca(a,b,c){switch(typeof b){case "string":Da(b,c);break;case "number":c.push(isFinite(b)&&!isNaN(b)?b:"null");break;case "boolean":c.push(b);break;case "undefined":c.push("null");break;case "object":if(null==b){c.push("null");break}if(ea(b)){var d=b.length;c.push("[");for(var e="",f=0;f<d;f++)c.push(e),e=b[f],Ca(a,a.Pd?a.Pd.call(b,String(f),e):e,c),e=",";c.push("]");break}c.push("{");d="";for(f in b)Object.prototype.hasOwnProperty.call(b,f)&&(e=b[f],"function"!=typeof e&&(c.push(d),Da(f,c),
+c.push(":"),Ca(a,a.Pd?a.Pd.call(b,f,e):e,c),d=","));c.push("}");break;case "function":break;default:throw Error("Unknown type: "+typeof b);}}var Ea={'"':'\\"',"\\":"\\\\","/":"\\/","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\x0B":"\\u000b"},Fa=/\uffff/.test("\uffff")?/[\\\"\x00-\x1f\x7f-\uffff]/g:/[\\\"\x00-\x1f\x7f-\xff]/g;
+function Da(a,b){b.push('"',a.replace(Fa,function(a){if(a in Ea)return Ea[a];var b=a.charCodeAt(0),e="\\u";16>b?e+="000":256>b?e+="00":4096>b&&(e+="0");return Ea[a]=e+b.toString(16)}),'"')};function Ga(){return Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^la()).toString(36)};var Ha;a:{var Ia=aa.navigator;if(Ia){var Ja=Ia.userAgent;if(Ja){Ha=Ja;break a}}Ha=""};function Ka(){this.Wa=-1};function La(){this.Wa=-1;this.Wa=64;this.R=[];this.le=[];this.Tf=[];this.Id=[];this.Id[0]=128;for(var a=1;a<this.Wa;++a)this.Id[a]=0;this.be=this.$b=0;this.reset()}ma(La,Ka);La.prototype.reset=function(){this.R[0]=1732584193;this.R[1]=4023233417;this.R[2]=2562383102;this.R[3]=271733878;this.R[4]=3285377520;this.be=this.$b=0};
+function Ma(a,b,c){c||(c=0);var d=a.Tf;if(p(b))for(var e=0;16>e;e++)d[e]=b.charCodeAt(c)<<24|b.charCodeAt(c+1)<<16|b.charCodeAt(c+2)<<8|b.charCodeAt(c+3),c+=4;else for(e=0;16>e;e++)d[e]=b[c]<<24|b[c+1]<<16|b[c+2]<<8|b[c+3],c+=4;for(e=16;80>e;e++){var f=d[e-3]^d[e-8]^d[e-14]^d[e-16];d[e]=(f<<1|f>>>31)&4294967295}b=a.R[0];c=a.R[1];for(var g=a.R[2],k=a.R[3],l=a.R[4],m,e=0;80>e;e++)40>e?20>e?(f=k^c&(g^k),m=1518500249):(f=c^g^k,m=1859775393):60>e?(f=c&g|k&(c|g),m=2400959708):(f=c^g^k,m=3395469782),f=(b<<
+5|b>>>27)+f+l+m+d[e]&4294967295,l=k,k=g,g=(c<<30|c>>>2)&4294967295,c=b,b=f;a.R[0]=a.R[0]+b&4294967295;a.R[1]=a.R[1]+c&4294967295;a.R[2]=a.R[2]+g&4294967295;a.R[3]=a.R[3]+k&4294967295;a.R[4]=a.R[4]+l&4294967295}
+La.prototype.update=function(a,b){if(null!=a){n(b)||(b=a.length);for(var c=b-this.Wa,d=0,e=this.le,f=this.$b;d<b;){if(0==f)for(;d<=c;)Ma(this,a,d),d+=this.Wa;if(p(a))for(;d<b;){if(e[f]=a.charCodeAt(d),++f,++d,f==this.Wa){Ma(this,e);f=0;break}}else for(;d<b;)if(e[f]=a[d],++f,++d,f==this.Wa){Ma(this,e);f=0;break}}this.$b=f;this.be+=b}};var t=Array.prototype,Na=t.indexOf?function(a,b,c){return t.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if(p(a))return p(b)&&1==b.length?a.indexOf(b,c):-1;for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1},Oa=t.forEach?function(a,b,c){t.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=p(a)?a.split(""):a,f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)},Pa=t.filter?function(a,b,c){return t.filter.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=[],f=0,g=p(a)?
+a.split(""):a,k=0;k<d;k++)if(k in g){var l=g[k];b.call(c,l,k,a)&&(e[f++]=l)}return e},Qa=t.map?function(a,b,c){return t.map.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=Array(d),f=p(a)?a.split(""):a,g=0;g<d;g++)g in f&&(e[g]=b.call(c,f[g],g,a));return e},Ra=t.reduce?function(a,b,c,d){for(var e=[],f=1,g=arguments.length;f<g;f++)e.push(arguments[f]);d&&(e[0]=q(b,d));return t.reduce.apply(a,e)}:function(a,b,c,d){var e=c;Oa(a,function(c,g){e=b.call(d,e,c,g,a)});return e},Sa=t.every?function(a,b,
+c){return t.every.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=p(a)?a.split(""):a,f=0;f<d;f++)if(f in e&&!b.call(c,e[f],f,a))return!1;return!0};function Ta(a,b){var c=Ua(a,b,void 0);return 0>c?null:p(a)?a.charAt(c):a[c]}function Ua(a,b,c){for(var d=a.length,e=p(a)?a.split(""):a,f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return f;return-1}function Va(a,b){var c=Na(a,b);0<=c&&t.splice.call(a,c,1)}function Wa(a,b,c){return 2>=arguments.length?t.slice.call(a,b):t.slice.call(a,b,c)}
+function Xa(a,b){a.sort(b||Ya)}function Ya(a,b){return a>b?1:a<b?-1:0};var Za=-1!=Ha.indexOf("Opera")||-1!=Ha.indexOf("OPR"),$a=-1!=Ha.indexOf("Trident")||-1!=Ha.indexOf("MSIE"),ab=-1!=Ha.indexOf("Gecko")&&-1==Ha.toLowerCase().indexOf("webkit")&&!(-1!=Ha.indexOf("Trident")||-1!=Ha.indexOf("MSIE")),bb=-1!=Ha.toLowerCase().indexOf("webkit");
+(function(){var a="",b;if(Za&&aa.opera)return a=aa.opera.version,ha(a)?a():a;ab?b=/rv\:([^\);]+)(\)|;)/:$a?b=/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/:bb&&(b=/WebKit\/(\S+)/);b&&(a=(a=b.exec(Ha))?a[1]:"");return $a&&(b=(b=aa.document)?b.documentMode:void 0,b>parseFloat(a))?String(b):a})();var cb=null,db=null,eb=null;function fb(a,b){if(!fa(a))throw Error("encodeByteArray takes an array as a parameter");gb();for(var c=b?db:cb,d=[],e=0;e<a.length;e+=3){var f=a[e],g=e+1<a.length,k=g?a[e+1]:0,l=e+2<a.length,m=l?a[e+2]:0,v=f>>2,f=(f&3)<<4|k>>4,k=(k&15)<<2|m>>6,m=m&63;l||(m=64,g||(k=64));d.push(c[v],c[f],c[k],c[m])}return d.join("")}
+function gb(){if(!cb){cb={};db={};eb={};for(var a=0;65>a;a++)cb[a]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".charAt(a),db[a]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.".charAt(a),eb[db[a]]=a,62<=a&&(eb["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".charAt(a)]=a)}};function u(a,b){return Object.prototype.hasOwnProperty.call(a,b)}function w(a,b){if(Object.prototype.hasOwnProperty.call(a,b))return a[b]}function hb(a,b){for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&b(c,a[c])}function ib(a){var b={};hb(a,function(a,d){b[a]=d});return b};function jb(a){var b=[];hb(a,function(a,d){ea(d)?Oa(d,function(d){b.push(encodeURIComponent(a)+"="+encodeURIComponent(d))}):b.push(encodeURIComponent(a)+"="+encodeURIComponent(d))});return b.length?"&"+b.join("&"):""}function kb(a){var b={};a=a.replace(/^\?/,"").split("&");Oa(a,function(a){a&&(a=a.split("="),b[a[0]]=a[1])});return b};function x(a,b,c,d){var e;d<b?e="at least "+b:d>c&&(e=0===c?"none":"no more than "+c);if(e)throw Error(a+" failed: Was called with "+d+(1===d?" argument.":" arguments.")+" Expects "+e+".");}function z(a,b,c){var d="";switch(b){case 1:d=c?"first":"First";break;case 2:d=c?"second":"Second";break;case 3:d=c?"third":"Third";break;case 4:d=c?"fourth":"Fourth";break;default:throw Error("errorPrefix called with argumentNumber > 4.  Need to update it?");}return a=a+" failed: "+(d+" argument ")}
+function A(a,b,c,d){if((!d||n(c))&&!ha(c))throw Error(z(a,b,d)+"must be a valid function.");}function lb(a,b,c){if(n(c)&&(!ia(c)||null===c))throw Error(z(a,b,!0)+"must be a valid context object.");};function mb(a){return"undefined"!==typeof JSON&&n(JSON.parse)?JSON.parse(a):Aa(a)}function B(a){if("undefined"!==typeof JSON&&n(JSON.stringify))a=JSON.stringify(a);else{var b=[];Ca(new Ba,a,b);a=b.join("")}return a};function nb(){this.Sd=C}nb.prototype.j=function(a){return this.Sd.oa(a)};nb.prototype.toString=function(){return this.Sd.toString()};function ob(){}ob.prototype.pf=function(){return null};ob.prototype.xe=function(){return null};var pb=new ob;function qb(a,b,c){this.Qf=a;this.Ka=b;this.Hd=c}qb.prototype.pf=function(a){var b=this.Ka.D;if(rb(b,a))return b.j().M(a);b=null!=this.Hd?new sb(this.Hd,!0,!1):this.Ka.u();return this.Qf.Xa(a,b)};qb.prototype.xe=function(a,b,c){var d=null!=this.Hd?this.Hd:tb(this.Ka);a=this.Qf.me(d,b,1,c,a);return 0===a.length?null:a[0]};function ub(){this.tb=[]}function vb(a,b){for(var c=null,d=0;d<b.length;d++){var e=b[d],f=e.Yb();null===c||f.Z(c.Yb())||(a.tb.push(c),c=null);null===c&&(c=new wb(f));c.add(e)}c&&a.tb.push(c)}function xb(a,b,c){vb(a,c);yb(a,function(a){return a.Z(b)})}function zb(a,b,c){vb(a,c);yb(a,function(a){return a.contains(b)||b.contains(a)})}
+function yb(a,b){for(var c=!0,d=0;d<a.tb.length;d++){var e=a.tb[d];if(e)if(e=e.Yb(),b(e)){for(var e=a.tb[d],f=0;f<e.sd.length;f++){var g=e.sd[f];if(null!==g){e.sd[f]=null;var k=g.Ub();Ab&&Bb("event: "+g.toString());Cb(k)}}a.tb[d]=null}else c=!1}c&&(a.tb=[])}function wb(a){this.qa=a;this.sd=[]}wb.prototype.add=function(a){this.sd.push(a)};wb.prototype.Yb=function(){return this.qa};function D(a,b,c,d){this.type=a;this.Ja=b;this.Ya=c;this.Je=d;this.Nd=void 0}function Db(a){return new D(Eb,a)}var Eb="value";function Fb(a,b,c,d){this.te=b;this.Wd=c;this.Nd=d;this.rd=a}Fb.prototype.Yb=function(){var a=this.Wd.lc();return"value"===this.rd?a.path:a.parent().path};Fb.prototype.ye=function(){return this.rd};Fb.prototype.Ub=function(){return this.te.Ub(this)};Fb.prototype.toString=function(){return this.Yb().toString()+":"+this.rd+":"+B(this.Wd.lf())};function Gb(a,b,c){this.te=a;this.error=b;this.path=c}Gb.prototype.Yb=function(){return this.path};Gb.prototype.ye=function(){return"cancel"};
+Gb.prototype.Ub=function(){return this.te.Ub(this)};Gb.prototype.toString=function(){return this.path.toString()+":cancel"};function sb(a,b,c){this.B=a;this.$=b;this.Tb=c}function Hb(a){return a.$}function rb(a,b){return a.$&&!a.Tb||a.B.Ha(b)}sb.prototype.j=function(){return this.B};function Ib(a){this.dg=a;this.Ad=null}Ib.prototype.get=function(){var a=this.dg.get(),b=xa(a);if(this.Ad)for(var c in this.Ad)b[c]-=this.Ad[c];this.Ad=a;return b};function Jb(a,b){this.Mf={};this.Yd=new Ib(a);this.ca=b;var c=1E4+2E4*Math.random();setTimeout(q(this.Hf,this),Math.floor(c))}Jb.prototype.Hf=function(){var a=this.Yd.get(),b={},c=!1,d;for(d in a)0<a[d]&&u(this.Mf,d)&&(b[d]=a[d],c=!0);c&&this.ca.Te(b);setTimeout(q(this.Hf,this),Math.floor(6E5*Math.random()))};function Kb(){this.Dc={}}function Lb(a,b,c){n(c)||(c=1);u(a.Dc,b)||(a.Dc[b]=0);a.Dc[b]+=c}Kb.prototype.get=function(){return xa(this.Dc)};var Mb={},Nb={};function Ob(a){a=a.toString();Mb[a]||(Mb[a]=new Kb);return Mb[a]}function Pb(a,b){var c=a.toString();Nb[c]||(Nb[c]=b());return Nb[c]};function E(a,b){this.name=a;this.S=b}function Qb(a,b){return new E(a,b)};function Rb(a,b){return Sb(a.name,b.name)}function Tb(a,b){return Sb(a,b)};function Ub(a,b,c){this.type=Vb;this.source=a;this.path=b;this.Ia=c}Ub.prototype.Wc=function(a){return this.path.e()?new Ub(this.source,F,this.Ia.M(a)):new Ub(this.source,G(this.path),this.Ia)};Ub.prototype.toString=function(){return"Operation("+this.path+": "+this.source.toString()+" overwrite: "+this.Ia.toString()+")"};function Wb(a,b){this.type=Xb;this.source=Yb;this.path=a;this.Ve=b}Wb.prototype.Wc=function(){return this.path.e()?this:new Wb(G(this.path),this.Ve)};Wb.prototype.toString=function(){return"Operation("+this.path+": "+this.source.toString()+" ack write revert="+this.Ve+")"};function Zb(a,b){this.type=$b;this.source=a;this.path=b}Zb.prototype.Wc=function(){return this.path.e()?new Zb(this.source,F):new Zb(this.source,G(this.path))};Zb.prototype.toString=function(){return"Operation("+this.path+": "+this.source.toString()+" listen_complete)"};function ac(a,b){this.La=a;this.xa=b?b:bc}h=ac.prototype;h.Na=function(a,b){return new ac(this.La,this.xa.Na(a,b,this.La).X(null,null,!1,null,null))};h.remove=function(a){return new ac(this.La,this.xa.remove(a,this.La).X(null,null,!1,null,null))};h.get=function(a){for(var b,c=this.xa;!c.e();){b=this.La(a,c.key);if(0===b)return c.value;0>b?c=c.left:0<b&&(c=c.right)}return null};
+function cc(a,b){for(var c,d=a.xa,e=null;!d.e();){c=a.La(b,d.key);if(0===c){if(d.left.e())return e?e.key:null;for(d=d.left;!d.right.e();)d=d.right;return d.key}0>c?d=d.left:0<c&&(e=d,d=d.right)}throw Error("Attempted to find predecessor key for a nonexistent key.  What gives?");}h.e=function(){return this.xa.e()};h.count=function(){return this.xa.count()};h.Rc=function(){return this.xa.Rc()};h.ec=function(){return this.xa.ec()};h.ha=function(a){return this.xa.ha(a)};
+h.Wb=function(a){return new dc(this.xa,null,this.La,!1,a)};h.Xb=function(a,b){return new dc(this.xa,a,this.La,!1,b)};h.Zb=function(a,b){return new dc(this.xa,a,this.La,!0,b)};h.rf=function(a){return new dc(this.xa,null,this.La,!0,a)};function dc(a,b,c,d,e){this.Rd=e||null;this.Ee=d;this.Pa=[];for(e=1;!a.e();)if(e=b?c(a.key,b):1,d&&(e*=-1),0>e)a=this.Ee?a.left:a.right;else if(0===e){this.Pa.push(a);break}else this.Pa.push(a),a=this.Ee?a.right:a.left}
+function H(a){if(0===a.Pa.length)return null;var b=a.Pa.pop(),c;c=a.Rd?a.Rd(b.key,b.value):{key:b.key,value:b.value};if(a.Ee)for(b=b.left;!b.e();)a.Pa.push(b),b=b.right;else for(b=b.right;!b.e();)a.Pa.push(b),b=b.left;return c}function ec(a){if(0===a.Pa.length)return null;var b;b=a.Pa;b=b[b.length-1];return a.Rd?a.Rd(b.key,b.value):{key:b.key,value:b.value}}function fc(a,b,c,d,e){this.key=a;this.value=b;this.color=null!=c?c:!0;this.left=null!=d?d:bc;this.right=null!=e?e:bc}h=fc.prototype;
+h.X=function(a,b,c,d,e){return new fc(null!=a?a:this.key,null!=b?b:this.value,null!=c?c:this.color,null!=d?d:this.left,null!=e?e:this.right)};h.count=function(){return this.left.count()+1+this.right.count()};h.e=function(){return!1};h.ha=function(a){return this.left.ha(a)||a(this.key,this.value)||this.right.ha(a)};function gc(a){return a.left.e()?a:gc(a.left)}h.Rc=function(){return gc(this).key};h.ec=function(){return this.right.e()?this.key:this.right.ec()};
+h.Na=function(a,b,c){var d,e;e=this;d=c(a,e.key);e=0>d?e.X(null,null,null,e.left.Na(a,b,c),null):0===d?e.X(null,b,null,null,null):e.X(null,null,null,null,e.right.Na(a,b,c));return hc(e)};function ic(a){if(a.left.e())return bc;a.left.fa()||a.left.left.fa()||(a=jc(a));a=a.X(null,null,null,ic(a.left),null);return hc(a)}
+h.remove=function(a,b){var c,d;c=this;if(0>b(a,c.key))c.left.e()||c.left.fa()||c.left.left.fa()||(c=jc(c)),c=c.X(null,null,null,c.left.remove(a,b),null);else{c.left.fa()&&(c=kc(c));c.right.e()||c.right.fa()||c.right.left.fa()||(c=lc(c),c.left.left.fa()&&(c=kc(c),c=lc(c)));if(0===b(a,c.key)){if(c.right.e())return bc;d=gc(c.right);c=c.X(d.key,d.value,null,null,ic(c.right))}c=c.X(null,null,null,null,c.right.remove(a,b))}return hc(c)};h.fa=function(){return this.color};
+function hc(a){a.right.fa()&&!a.left.fa()&&(a=mc(a));a.left.fa()&&a.left.left.fa()&&(a=kc(a));a.left.fa()&&a.right.fa()&&(a=lc(a));return a}function jc(a){a=lc(a);a.right.left.fa()&&(a=a.X(null,null,null,null,kc(a.right)),a=mc(a),a=lc(a));return a}function mc(a){return a.right.X(null,null,a.color,a.X(null,null,!0,null,a.right.left),null)}function kc(a){return a.left.X(null,null,a.color,null,a.X(null,null,!0,a.left.right,null))}
+function lc(a){return a.X(null,null,!a.color,a.left.X(null,null,!a.left.color,null,null),a.right.X(null,null,!a.right.color,null,null))}function nc(){}h=nc.prototype;h.X=function(){return this};h.Na=function(a,b){return new fc(a,b,null)};h.remove=function(){return this};h.count=function(){return 0};h.e=function(){return!0};h.ha=function(){return!1};h.Rc=function(){return null};h.ec=function(){return null};h.fa=function(){return!1};var bc=new nc;function oc(a,b){return a&&"object"===typeof a?(J(".sv"in a,"Unexpected leaf node or priority contents"),b[a[".sv"]]):a}function pc(a,b){var c=new qc;rc(a,new K(""),function(a,e){c.mc(a,sc(e,b))});return c}function sc(a,b){var c=a.A().K(),c=oc(c,b),d;if(a.N()){var e=oc(a.Ba(),b);return e!==a.Ba()||c!==a.A().K()?new tc(e,L(c)):a}d=a;c!==a.A().K()&&(d=d.da(new tc(c)));a.U(M,function(a,c){var e=sc(c,b);e!==c&&(d=d.Q(a,e))});return d};function K(a,b){if(1==arguments.length){this.o=a.split("/");for(var c=0,d=0;d<this.o.length;d++)0<this.o[d].length&&(this.o[c]=this.o[d],c++);this.o.length=c;this.Y=0}else this.o=a,this.Y=b}function N(a,b){var c=O(a);if(null===c)return b;if(c===O(b))return N(G(a),G(b));throw Error("INTERNAL ERROR: innerPath ("+b+") is not within outerPath ("+a+")");}function O(a){return a.Y>=a.o.length?null:a.o[a.Y]}function uc(a){return a.o.length-a.Y}
+function G(a){var b=a.Y;b<a.o.length&&b++;return new K(a.o,b)}function vc(a){return a.Y<a.o.length?a.o[a.o.length-1]:null}h=K.prototype;h.toString=function(){for(var a="",b=this.Y;b<this.o.length;b++)""!==this.o[b]&&(a+="/"+this.o[b]);return a||"/"};h.slice=function(a){return this.o.slice(this.Y+(a||0))};h.parent=function(){if(this.Y>=this.o.length)return null;for(var a=[],b=this.Y;b<this.o.length-1;b++)a.push(this.o[b]);return new K(a,0)};
+h.w=function(a){for(var b=[],c=this.Y;c<this.o.length;c++)b.push(this.o[c]);if(a instanceof K)for(c=a.Y;c<a.o.length;c++)b.push(a.o[c]);else for(a=a.split("/"),c=0;c<a.length;c++)0<a[c].length&&b.push(a[c]);return new K(b,0)};h.e=function(){return this.Y>=this.o.length};h.Z=function(a){if(uc(this)!==uc(a))return!1;for(var b=this.Y,c=a.Y;b<=this.o.length;b++,c++)if(this.o[b]!==a.o[c])return!1;return!0};
+h.contains=function(a){var b=this.Y,c=a.Y;if(uc(this)>uc(a))return!1;for(;b<this.o.length;){if(this.o[b]!==a.o[c])return!1;++b;++c}return!0};var F=new K("");function wc(a,b){this.Qa=a.slice();this.Ea=Math.max(1,this.Qa.length);this.kf=b;for(var c=0;c<this.Qa.length;c++)this.Ea+=xc(this.Qa[c]);yc(this)}wc.prototype.push=function(a){0<this.Qa.length&&(this.Ea+=1);this.Qa.push(a);this.Ea+=xc(a);yc(this)};wc.prototype.pop=function(){var a=this.Qa.pop();this.Ea-=xc(a);0<this.Qa.length&&--this.Ea};
+function yc(a){if(768<a.Ea)throw Error(a.kf+"has a key path longer than 768 bytes ("+a.Ea+").");if(32<a.Qa.length)throw Error(a.kf+"path specified exceeds the maximum depth that can be written (32) or object contains a cycle "+zc(a));}function zc(a){return 0==a.Qa.length?"":"in property '"+a.Qa.join(".")+"'"};function Ac(){this.wc={}}Ac.prototype.set=function(a,b){null==b?delete this.wc[a]:this.wc[a]=b};Ac.prototype.get=function(a){return u(this.wc,a)?this.wc[a]:null};Ac.prototype.remove=function(a){delete this.wc[a]};Ac.prototype.uf=!0;function Bc(a){this.Ec=a;this.Md="firebase:"}h=Bc.prototype;h.set=function(a,b){null==b?this.Ec.removeItem(this.Md+a):this.Ec.setItem(this.Md+a,B(b))};h.get=function(a){a=this.Ec.getItem(this.Md+a);return null==a?null:mb(a)};h.remove=function(a){this.Ec.removeItem(this.Md+a)};h.uf=!1;h.toString=function(){return this.Ec.toString()};function Cc(a){try{if("undefined"!==typeof window&&"undefined"!==typeof window[a]){var b=window[a];b.setItem("firebase:sentinel","cache");b.removeItem("firebase:sentinel");return new Bc(b)}}catch(c){}return new Ac}var Dc=Cc("localStorage"),P=Cc("sessionStorage");function Ec(a,b,c,d,e){this.host=a.toLowerCase();this.domain=this.host.substr(this.host.indexOf(".")+1);this.lb=b;this.Cb=c;this.Tg=d;this.Ld=e||"";this.Oa=Dc.get("host:"+a)||this.host}function Fc(a,b){b!==a.Oa&&(a.Oa=b,"s-"===a.Oa.substr(0,2)&&Dc.set("host:"+a.host,a.Oa))}Ec.prototype.toString=function(){var a=(this.lb?"https://":"http://")+this.host;this.Ld&&(a+="<"+this.Ld+">");return a};var Gc=function(){var a=1;return function(){return a++}}();function J(a,b){if(!a)throw Hc(b);}function Hc(a){return Error("Firebase (2.2.4) INTERNAL ASSERT FAILED: "+a)}
+function Ic(a){try{var b;if("undefined"!==typeof atob)b=atob(a);else{gb();for(var c=eb,d=[],e=0;e<a.length;){var f=c[a.charAt(e++)],g=e<a.length?c[a.charAt(e)]:0;++e;var k=e<a.length?c[a.charAt(e)]:64;++e;var l=e<a.length?c[a.charAt(e)]:64;++e;if(null==f||null==g||null==k||null==l)throw Error();d.push(f<<2|g>>4);64!=k&&(d.push(g<<4&240|k>>2),64!=l&&d.push(k<<6&192|l))}if(8192>d.length)b=String.fromCharCode.apply(null,d);else{a="";for(c=0;c<d.length;c+=8192)a+=String.fromCharCode.apply(null,Wa(d,c,
+c+8192));b=a}}return b}catch(m){Bb("base64Decode failed: ",m)}return null}function Jc(a){var b=Kc(a);a=new La;a.update(b);var b=[],c=8*a.be;56>a.$b?a.update(a.Id,56-a.$b):a.update(a.Id,a.Wa-(a.$b-56));for(var d=a.Wa-1;56<=d;d--)a.le[d]=c&255,c/=256;Ma(a,a.le);for(d=c=0;5>d;d++)for(var e=24;0<=e;e-=8)b[c]=a.R[d]>>e&255,++c;return fb(b)}
+function Lc(a){for(var b="",c=0;c<arguments.length;c++)b=fa(arguments[c])?b+Lc.apply(null,arguments[c]):"object"===typeof arguments[c]?b+B(arguments[c]):b+arguments[c],b+=" ";return b}var Ab=null,Mc=!0;function Bb(a){!0===Mc&&(Mc=!1,null===Ab&&!0===P.get("logging_enabled")&&Nc(!0));if(Ab){var b=Lc.apply(null,arguments);Ab(b)}}function Oc(a){return function(){Bb(a,arguments)}}
+function Pc(a){if("undefined"!==typeof console){var b="FIREBASE INTERNAL ERROR: "+Lc.apply(null,arguments);"undefined"!==typeof console.error?console.error(b):console.log(b)}}function Qc(a){var b=Lc.apply(null,arguments);throw Error("FIREBASE FATAL ERROR: "+b);}function Q(a){if("undefined"!==typeof console){var b="FIREBASE WARNING: "+Lc.apply(null,arguments);"undefined"!==typeof console.warn?console.warn(b):console.log(b)}}
+function Rc(a){var b="",c="",d="",e="",f=!0,g="https",k=443;if(p(a)){var l=a.indexOf("//");0<=l&&(g=a.substring(0,l-1),a=a.substring(l+2));l=a.indexOf("/");-1===l&&(l=a.length);b=a.substring(0,l);e="";a=a.substring(l).split("/");for(l=0;l<a.length;l++)if(0<a[l].length){var m=a[l];try{m=decodeURIComponent(m.replace(/\+/g," "))}catch(v){}e+="/"+m}a=b.split(".");3===a.length?(c=a[1],d=a[0].toLowerCase()):2===a.length&&(c=a[0]);l=b.indexOf(":");0<=l&&(f="https"===g||"wss"===g,k=b.substring(l+1),isFinite(k)&&
+(k=String(k)),k=p(k)?/^\s*-?0x/i.test(k)?parseInt(k,16):parseInt(k,10):NaN)}return{host:b,port:k,domain:c,Qg:d,lb:f,scheme:g,Zc:e}}function Sc(a){return ga(a)&&(a!=a||a==Number.POSITIVE_INFINITY||a==Number.NEGATIVE_INFINITY)}
+function Tc(a){if("complete"===document.readyState)a();else{var b=!1,c=function(){document.body?b||(b=!0,a()):setTimeout(c,Math.floor(10))};document.addEventListener?(document.addEventListener("DOMContentLoaded",c,!1),window.addEventListener("load",c,!1)):document.attachEvent&&(document.attachEvent("onreadystatechange",function(){"complete"===document.readyState&&c()}),window.attachEvent("onload",c))}}
+function Sb(a,b){if(a===b)return 0;if("[MIN_NAME]"===a||"[MAX_NAME]"===b)return-1;if("[MIN_NAME]"===b||"[MAX_NAME]"===a)return 1;var c=Uc(a),d=Uc(b);return null!==c?null!==d?0==c-d?a.length-b.length:c-d:-1:null!==d?1:a<b?-1:1}function Vc(a,b){if(b&&a in b)return b[a];throw Error("Missing required key ("+a+") in object: "+B(b));}
+function Wc(a){if("object"!==typeof a||null===a)return B(a);var b=[],c;for(c in a)b.push(c);b.sort();c="{";for(var d=0;d<b.length;d++)0!==d&&(c+=","),c+=B(b[d]),c+=":",c+=Wc(a[b[d]]);return c+"}"}function Xc(a,b){if(a.length<=b)return[a];for(var c=[],d=0;d<a.length;d+=b)d+b>a?c.push(a.substring(d,a.length)):c.push(a.substring(d,d+b));return c}function Yc(a,b){if(ea(a))for(var c=0;c<a.length;++c)b(c,a[c]);else r(a,b)}
+function Zc(a){J(!Sc(a),"Invalid JSON number");var b,c,d,e;0===a?(d=c=0,b=-Infinity===1/a?1:0):(b=0>a,a=Math.abs(a),a>=Math.pow(2,-1022)?(d=Math.min(Math.floor(Math.log(a)/Math.LN2),1023),c=d+1023,d=Math.round(a*Math.pow(2,52-d)-Math.pow(2,52))):(c=0,d=Math.round(a/Math.pow(2,-1074))));e=[];for(a=52;a;--a)e.push(d%2?1:0),d=Math.floor(d/2);for(a=11;a;--a)e.push(c%2?1:0),c=Math.floor(c/2);e.push(b?1:0);e.reverse();b=e.join("");c="";for(a=0;64>a;a+=8)d=parseInt(b.substr(a,8),2).toString(16),1===d.length&&
+(d="0"+d),c+=d;return c.toLowerCase()}var $c=/^-?\d{1,10}$/;function Uc(a){return $c.test(a)&&(a=Number(a),-2147483648<=a&&2147483647>=a)?a:null}function Cb(a){try{a()}catch(b){setTimeout(function(){Q("Exception was thrown by user callback.",b.stack||"");throw b;},Math.floor(0))}}function R(a,b){if(ha(a)){var c=Array.prototype.slice.call(arguments,1).slice();Cb(function(){a.apply(null,c)})}};function Kc(a){for(var b=[],c=0,d=0;d<a.length;d++){var e=a.charCodeAt(d);55296<=e&&56319>=e&&(e-=55296,d++,J(d<a.length,"Surrogate pair missing trail surrogate."),e=65536+(e<<10)+(a.charCodeAt(d)-56320));128>e?b[c++]=e:(2048>e?b[c++]=e>>6|192:(65536>e?b[c++]=e>>12|224:(b[c++]=e>>18|240,b[c++]=e>>12&63|128),b[c++]=e>>6&63|128),b[c++]=e&63|128)}return b}function xc(a){for(var b=0,c=0;c<a.length;c++){var d=a.charCodeAt(c);128>d?b++:2048>d?b+=2:55296<=d&&56319>=d?(b+=4,c++):b+=3}return b};function ad(a){var b={},c={},d={},e="";try{var f=a.split("."),b=mb(Ic(f[0])||""),c=mb(Ic(f[1])||""),e=f[2],d=c.d||{};delete c.d}catch(g){}return{Wg:b,Ac:c,data:d,Ng:e}}function bd(a){a=ad(a).Ac;return"object"===typeof a&&a.hasOwnProperty("iat")?w(a,"iat"):null}function cd(a){a=ad(a);var b=a.Ac;return!!a.Ng&&!!b&&"object"===typeof b&&b.hasOwnProperty("iat")};function dd(a){this.V=a;this.g=a.n.g}function ed(a,b,c,d){var e=[],f=[];Oa(b,function(b){"child_changed"===b.type&&a.g.xd(b.Je,b.Ja)&&f.push(new D("child_moved",b.Ja,b.Ya))});fd(a,e,"child_removed",b,d,c);fd(a,e,"child_added",b,d,c);fd(a,e,"child_moved",f,d,c);fd(a,e,"child_changed",b,d,c);fd(a,e,Eb,b,d,c);return e}function fd(a,b,c,d,e,f){d=Pa(d,function(a){return a.type===c});Xa(d,q(a.eg,a));Oa(d,function(c){var d=gd(a,c,f);Oa(e,function(e){e.Jf(c.type)&&b.push(e.createEvent(d,a.V))})})}
+function gd(a,b,c){"value"!==b.type&&"child_removed"!==b.type&&(b.Nd=c.qf(b.Ya,b.Ja,a.g));return b}dd.prototype.eg=function(a,b){if(null==a.Ya||null==b.Ya)throw Hc("Should only compare child_ events.");return this.g.compare(new E(a.Ya,a.Ja),new E(b.Ya,b.Ja))};function hd(){this.eb={}}
+function id(a,b){var c=b.type,d=b.Ya;J("child_added"==c||"child_changed"==c||"child_removed"==c,"Only child changes supported for tracking");J(".priority"!==d,"Only non-priority child changes can be tracked.");var e=w(a.eb,d);if(e){var f=e.type;if("child_added"==c&&"child_removed"==f)a.eb[d]=new D("child_changed",b.Ja,d,e.Ja);else if("child_removed"==c&&"child_added"==f)delete a.eb[d];else if("child_removed"==c&&"child_changed"==f)a.eb[d]=new D("child_removed",e.Je,d);else if("child_changed"==c&&
+"child_added"==f)a.eb[d]=new D("child_added",b.Ja,d);else if("child_changed"==c&&"child_changed"==f)a.eb[d]=new D("child_changed",b.Ja,d,e.Je);else throw Hc("Illegal combination of changes: "+b+" occurred after "+e);}else a.eb[d]=b};function jd(a,b,c){this.Pb=a;this.qb=b;this.sb=c||null}h=jd.prototype;h.Jf=function(a){return"value"===a};h.createEvent=function(a,b){var c=b.n.g;return new Fb("value",this,new S(a.Ja,b.lc(),c))};h.Ub=function(a){var b=this.sb;if("cancel"===a.ye()){J(this.qb,"Raising a cancel event on a listener with no cancel callback");var c=this.qb;return function(){c.call(b,a.error)}}var d=this.Pb;return function(){d.call(b,a.Wd)}};h.ff=function(a,b){return this.qb?new Gb(this,a,b):null};
+h.matches=function(a){return a instanceof jd?a.Pb&&this.Pb?a.Pb===this.Pb&&a.sb===this.sb:!0:!1};h.sf=function(){return null!==this.Pb};function kd(a,b,c){this.ga=a;this.qb=b;this.sb=c}h=kd.prototype;h.Jf=function(a){a="children_added"===a?"child_added":a;return("children_removed"===a?"child_removed":a)in this.ga};h.ff=function(a,b){return this.qb?new Gb(this,a,b):null};
+h.createEvent=function(a,b){J(null!=a.Ya,"Child events should have a childName.");var c=b.lc().w(a.Ya);return new Fb(a.type,this,new S(a.Ja,c,b.n.g),a.Nd)};h.Ub=function(a){var b=this.sb;if("cancel"===a.ye()){J(this.qb,"Raising a cancel event on a listener with no cancel callback");var c=this.qb;return function(){c.call(b,a.error)}}var d=this.ga[a.rd];return function(){d.call(b,a.Wd,a.Nd)}};
+h.matches=function(a){if(a instanceof kd){if(!this.ga||!a.ga)return!0;if(this.sb===a.sb){var b=pa(a.ga);if(b===pa(this.ga)){if(1===b){var b=qa(a.ga),c=qa(this.ga);return c===b&&(!a.ga[b]||!this.ga[c]||a.ga[b]===this.ga[c])}return oa(this.ga,function(b,c){return a.ga[c]===b})}}}return!1};h.sf=function(){return null!==this.ga};function ld(a){this.g=a}h=ld.prototype;h.G=function(a,b,c,d,e){J(a.Ic(this.g),"A node must be indexed if only a child is updated");d=a.M(b);if(d.Z(c))return a;null!=e&&(c.e()?a.Ha(b)?id(e,new D("child_removed",d,b)):J(a.N(),"A child remove without an old child only makes sense on a leaf node"):d.e()?id(e,new D("child_added",c,b)):id(e,new D("child_changed",c,b,d)));return a.N()&&c.e()?a:a.Q(b,c).mb(this.g)};
+h.ta=function(a,b,c){null!=c&&(a.N()||a.U(M,function(a,e){b.Ha(a)||id(c,new D("child_removed",e,a))}),b.N()||b.U(M,function(b,e){if(a.Ha(b)){var f=a.M(b);f.Z(e)||id(c,new D("child_changed",e,b,f))}else id(c,new D("child_added",e,b))}));return b.mb(this.g)};h.da=function(a,b){return a.e()?C:a.da(b)};h.Ga=function(){return!1};h.Vb=function(){return this};function md(a){this.Ae=new ld(a.g);this.g=a.g;var b;a.la?(b=nd(a),b=a.g.Oc(od(a),b)):b=a.g.Sc();this.dd=b;a.na?(b=pd(a),a=a.g.Oc(qd(a),b)):a=a.g.Pc();this.Fc=a}h=md.prototype;h.matches=function(a){return 0>=this.g.compare(this.dd,a)&&0>=this.g.compare(a,this.Fc)};h.G=function(a,b,c,d,e){this.matches(new E(b,c))||(c=C);return this.Ae.G(a,b,c,d,e)};h.ta=function(a,b,c){b.N()&&(b=C);var d=b.mb(this.g),d=d.da(C),e=this;b.U(M,function(a,b){e.matches(new E(a,b))||(d=d.Q(a,C))});return this.Ae.ta(a,d,c)};
+h.da=function(a){return a};h.Ga=function(){return!0};h.Vb=function(){return this.Ae};function rd(a){this.ra=new md(a);this.g=a.g;J(a.ia,"Only valid if limit has been set");this.ja=a.ja;this.Jb=!sd(a)}h=rd.prototype;h.G=function(a,b,c,d,e){this.ra.matches(new E(b,c))||(c=C);return a.M(b).Z(c)?a:a.Db()<this.ja?this.ra.Vb().G(a,b,c,d,e):td(this,a,b,c,d,e)};
+h.ta=function(a,b,c){var d;if(b.N()||b.e())d=C.mb(this.g);else if(2*this.ja<b.Db()&&b.Ic(this.g)){d=C.mb(this.g);b=this.Jb?b.Zb(this.ra.Fc,this.g):b.Xb(this.ra.dd,this.g);for(var e=0;0<b.Pa.length&&e<this.ja;){var f=H(b),g;if(g=this.Jb?0>=this.g.compare(this.ra.dd,f):0>=this.g.compare(f,this.ra.Fc))d=d.Q(f.name,f.S),e++;else break}}else{d=b.mb(this.g);d=d.da(C);var k,l,m;if(this.Jb){b=d.rf(this.g);k=this.ra.Fc;l=this.ra.dd;var v=ud(this.g);m=function(a,b){return v(b,a)}}else b=d.Wb(this.g),k=this.ra.dd,
+l=this.ra.Fc,m=ud(this.g);for(var e=0,y=!1;0<b.Pa.length;)f=H(b),!y&&0>=m(k,f)&&(y=!0),(g=y&&e<this.ja&&0>=m(f,l))?e++:d=d.Q(f.name,C)}return this.ra.Vb().ta(a,d,c)};h.da=function(a){return a};h.Ga=function(){return!0};h.Vb=function(){return this.ra.Vb()};
+function td(a,b,c,d,e,f){var g;if(a.Jb){var k=ud(a.g);g=function(a,b){return k(b,a)}}else g=ud(a.g);J(b.Db()==a.ja,"");var l=new E(c,d),m=a.Jb?wd(b,a.g):xd(b,a.g),v=a.ra.matches(l);if(b.Ha(c)){var y=b.M(c),m=e.xe(a.g,m,a.Jb);null!=m&&m.name==c&&(m=e.xe(a.g,m,a.Jb));e=null==m?1:g(m,l);if(v&&!d.e()&&0<=e)return null!=f&&id(f,new D("child_changed",d,c,y)),b.Q(c,d);null!=f&&id(f,new D("child_removed",y,c));b=b.Q(c,C);return null!=m&&a.ra.matches(m)?(null!=f&&id(f,new D("child_added",m.S,m.name)),b.Q(m.name,
+m.S)):b}return d.e()?b:v&&0<=g(m,l)?(null!=f&&(id(f,new D("child_removed",m.S,m.name)),id(f,new D("child_added",d,c))),b.Q(c,d).Q(m.name,C)):b};function yd(a,b){this.he=a;this.cg=b}function zd(a){this.I=a}
+zd.prototype.bb=function(a,b,c,d){var e=new hd,f;if(b.type===Vb)b.source.ve?c=Ad(this,a,b.path,b.Ia,c,d,e):(J(b.source.of,"Unknown source."),f=b.source.af,c=Bd(this,a,b.path,b.Ia,c,d,f,e));else if(b.type===Cd)b.source.ve?c=Dd(this,a,b.path,b.children,c,d,e):(J(b.source.of,"Unknown source."),f=b.source.af,c=Ed(this,a,b.path,b.children,c,d,f,e));else if(b.type===Xb)if(b.Ve)if(f=b.path,null!=c.sc(f))c=a;else{b=new qb(c,a,d);d=a.D.j();if(f.e()||".priority"===O(f))Hb(a.u())?b=c.ua(tb(a)):(b=a.u().j(),
+J(b instanceof T,"serverChildren would be complete if leaf node"),b=c.xc(b)),b=this.I.ta(d,b,e);else{f=O(f);var g=c.Xa(f,a.u());null==g&&rb(a.u(),f)&&(g=d.M(f));b=null!=g?this.I.G(d,f,g,b,e):a.D.j().Ha(f)?this.I.G(d,f,C,b,e):d;b.e()&&Hb(a.u())&&(d=c.ua(tb(a)),d.N()&&(b=this.I.ta(b,d,e)))}d=Hb(a.u())||null!=c.sc(F);c=Fd(a,b,d,this.I.Ga())}else c=Gd(this,a,b.path,c,d,e);else if(b.type===$b)d=b.path,b=a.u(),f=b.j(),g=b.$||d.e(),c=Hd(this,new Id(a.D,new sb(f,g,b.Tb)),d,c,pb,e);else throw Hc("Unknown operation type: "+
+b.type);e=ra(e.eb);d=c;b=d.D;b.$&&(f=b.j().N()||b.j().e(),g=Jd(a),(0<e.length||!a.D.$||f&&!b.j().Z(g)||!b.j().A().Z(g.A()))&&e.push(Db(Jd(d))));return new yd(c,e)};
+function Hd(a,b,c,d,e,f){var g=b.D;if(null!=d.sc(c))return b;var k;if(c.e())J(Hb(b.u()),"If change path is empty, we must have complete server data"),b.u().Tb?(e=tb(b),d=d.xc(e instanceof T?e:C)):d=d.ua(tb(b)),f=a.I.ta(b.D.j(),d,f);else{var l=O(c);if(".priority"==l)J(1==uc(c),"Can't have a priority with additional path components"),f=g.j(),k=b.u().j(),d=d.hd(c,f,k),f=null!=d?a.I.da(f,d):g.j();else{var m=G(c);rb(g,l)?(k=b.u().j(),d=d.hd(c,g.j(),k),d=null!=d?g.j().M(l).G(m,d):g.j().M(l)):d=d.Xa(l,b.u());
+f=null!=d?a.I.G(g.j(),l,d,e,f):g.j()}}return Fd(b,f,g.$||c.e(),a.I.Ga())}function Bd(a,b,c,d,e,f,g,k){var l=b.u();g=g?a.I:a.I.Vb();if(c.e())d=g.ta(l.j(),d,null);else if(g.Ga()&&!l.Tb)d=l.j().G(c,d),d=g.ta(l.j(),d,null);else{var m=O(c);if((c.e()?!l.$||l.Tb:!rb(l,O(c)))&&1<uc(c))return b;d=l.j().M(m).G(G(c),d);d=".priority"==m?g.da(l.j(),d):g.G(l.j(),m,d,pb,null)}l=l.$||c.e();b=new Id(b.D,new sb(d,l,g.Ga()));return Hd(a,b,c,e,new qb(e,b,f),k)}
+function Ad(a,b,c,d,e,f,g){var k=b.D;e=new qb(e,b,f);if(c.e())g=a.I.ta(b.D.j(),d,g),a=Fd(b,g,!0,a.I.Ga());else if(f=O(c),".priority"===f)g=a.I.da(b.D.j(),d),a=Fd(b,g,k.$,k.Tb);else{var l=G(c);c=k.j().M(f);if(!l.e()){var m=e.pf(f);d=null!=m?".priority"===vc(l)&&m.oa(l.parent()).e()?m:m.G(l,d):C}c.Z(d)?a=b:(g=a.I.G(k.j(),f,d,e,g),a=Fd(b,g,k.$,a.I.Ga()))}return a}
+function Dd(a,b,c,d,e,f,g){var k=b;Kd(d,function(d,m){var v=c.w(d);rb(b.D,O(v))&&(k=Ad(a,k,v,m,e,f,g))});Kd(d,function(d,m){var v=c.w(d);rb(b.D,O(v))||(k=Ad(a,k,v,m,e,f,g))});return k}function Ld(a,b){Kd(b,function(b,d){a=a.G(b,d)});return a}
+function Ed(a,b,c,d,e,f,g,k){if(b.u().j().e()&&!Hb(b.u()))return b;var l=b;c=c.e()?d:Md(Nd,c,d);var m=b.u().j();c.children.ha(function(c,d){if(m.Ha(c)){var I=b.u().j().M(c),I=Ld(I,d);l=Bd(a,l,new K(c),I,e,f,g,k)}});c.children.ha(function(c,d){var I=!Hb(b.u())&&null==d.value;m.Ha(c)||I||(I=b.u().j().M(c),I=Ld(I,d),l=Bd(a,l,new K(c),I,e,f,g,k))});return l}
+function Gd(a,b,c,d,e,f){if(null!=d.sc(c))return b;var g=new qb(d,b,e),k=e=b.D.j();if(Hb(b.u())){if(c.e())e=d.ua(tb(b)),k=a.I.ta(b.D.j(),e,f);else if(".priority"===O(c)){var l=d.Xa(O(c),b.u());null==l||e.e()||e.A().Z(l)||(k=a.I.da(e,l))}else l=O(c),e=d.Xa(l,b.u()),null!=e&&(k=a.I.G(b.D.j(),l,e,g,f));e=!0}else if(b.D.$||c.e())k=e,e=b.D.j(),e.N()||e.U(M,function(c){var e=d.Xa(c,b.u());null!=e&&(k=a.I.G(k,c,e,g,f))}),e=b.D.$;else{l=O(c);if(1==uc(c)||rb(b.D,l))c=d.Xa(l,b.u()),null!=c&&(k=a.I.G(e,l,c,
+g,f));e=!1}return Fd(b,k,e,a.I.Ga())};function Od(){}var Pd={};function ud(a){return q(a.compare,a)}Od.prototype.xd=function(a,b){return 0!==this.compare(new E("[MIN_NAME]",a),new E("[MIN_NAME]",b))};Od.prototype.Sc=function(){return Qd};function Rd(a){this.bc=a}ma(Rd,Od);h=Rd.prototype;h.Hc=function(a){return!a.M(this.bc).e()};h.compare=function(a,b){var c=a.S.M(this.bc),d=b.S.M(this.bc),c=c.Cc(d);return 0===c?Sb(a.name,b.name):c};h.Oc=function(a,b){var c=L(a),c=C.Q(this.bc,c);return new E(b,c)};
+h.Pc=function(){var a=C.Q(this.bc,Sd);return new E("[MAX_NAME]",a)};h.toString=function(){return this.bc};function Td(){}ma(Td,Od);h=Td.prototype;h.compare=function(a,b){var c=a.S.A(),d=b.S.A(),c=c.Cc(d);return 0===c?Sb(a.name,b.name):c};h.Hc=function(a){return!a.A().e()};h.xd=function(a,b){return!a.A().Z(b.A())};h.Sc=function(){return Qd};h.Pc=function(){return new E("[MAX_NAME]",new tc("[PRIORITY-POST]",Sd))};h.Oc=function(a,b){var c=L(a);return new E(b,new tc("[PRIORITY-POST]",c))};
+h.toString=function(){return".priority"};var M=new Td;function Ud(){}ma(Ud,Od);h=Ud.prototype;h.compare=function(a,b){return Sb(a.name,b.name)};h.Hc=function(){throw Hc("KeyIndex.isDefinedOn not expected to be called.");};h.xd=function(){return!1};h.Sc=function(){return Qd};h.Pc=function(){return new E("[MAX_NAME]",C)};h.Oc=function(a){J(p(a),"KeyIndex indexValue must always be a string.");return new E(a,C)};h.toString=function(){return".key"};var Vd=new Ud;function Wd(){}ma(Wd,Od);h=Wd.prototype;
+h.compare=function(a,b){var c=a.S.Cc(b.S);return 0===c?Sb(a.name,b.name):c};h.Hc=function(){return!0};h.xd=function(a,b){return!a.Z(b)};h.Sc=function(){return Qd};h.Pc=function(){return Xd};h.Oc=function(a,b){var c=L(a);return new E(b,c)};h.toString=function(){return".value"};var Yd=new Wd;function Zd(){this.Rb=this.na=this.Lb=this.la=this.ia=!1;this.ja=0;this.Nb="";this.dc=null;this.xb="";this.ac=null;this.vb="";this.g=M}var $d=new Zd;function sd(a){return""===a.Nb?a.la:"l"===a.Nb}function od(a){J(a.la,"Only valid if start has been set");return a.dc}function nd(a){J(a.la,"Only valid if start has been set");return a.Lb?a.xb:"[MIN_NAME]"}function qd(a){J(a.na,"Only valid if end has been set");return a.ac}
+function pd(a){J(a.na,"Only valid if end has been set");return a.Rb?a.vb:"[MAX_NAME]"}function ae(a){var b=new Zd;b.ia=a.ia;b.ja=a.ja;b.la=a.la;b.dc=a.dc;b.Lb=a.Lb;b.xb=a.xb;b.na=a.na;b.ac=a.ac;b.Rb=a.Rb;b.vb=a.vb;b.g=a.g;return b}h=Zd.prototype;h.Ge=function(a){var b=ae(this);b.ia=!0;b.ja=a;b.Nb="";return b};h.He=function(a){var b=ae(this);b.ia=!0;b.ja=a;b.Nb="l";return b};h.Ie=function(a){var b=ae(this);b.ia=!0;b.ja=a;b.Nb="r";return b};
+h.Xd=function(a,b){var c=ae(this);c.la=!0;n(a)||(a=null);c.dc=a;null!=b?(c.Lb=!0,c.xb=b):(c.Lb=!1,c.xb="");return c};h.qd=function(a,b){var c=ae(this);c.na=!0;n(a)||(a=null);c.ac=a;n(b)?(c.Rb=!0,c.vb=b):(c.Yg=!1,c.vb="");return c};function be(a,b){var c=ae(a);c.g=b;return c}function ce(a){var b={};a.la&&(b.sp=a.dc,a.Lb&&(b.sn=a.xb));a.na&&(b.ep=a.ac,a.Rb&&(b.en=a.vb));if(a.ia){b.l=a.ja;var c=a.Nb;""===c&&(c=sd(a)?"l":"r");b.vf=c}a.g!==M&&(b.i=a.g.toString());return b}
+function de(a){return!(a.la||a.na||a.ia)}function ee(a){var b={};if(de(a)&&a.g==M)return b;var c;a.g===M?c="$priority":a.g===Yd?c="$value":(J(a.g instanceof Rd,"Unrecognized index type!"),c=a.g.toString());b.orderBy=B(c);a.la&&(b.startAt=B(a.dc),a.Lb&&(b.startAt+=","+B(a.xb)));a.na&&(b.endAt=B(a.ac),a.Rb&&(b.endAt+=","+B(a.vb)));a.ia&&(sd(a)?b.limitToFirst=a.ja:b.limitToLast=a.ja);return b}h.toString=function(){return B(ce(this))};function fe(a,b){this.yd=a;this.cc=b}fe.prototype.get=function(a){var b=w(this.yd,a);if(!b)throw Error("No index defined for "+a);return b===Pd?null:b};function ge(a,b,c){var d=na(a.yd,function(d,f){var g=w(a.cc,f);J(g,"Missing index implementation for "+f);if(d===Pd){if(g.Hc(b.S)){for(var k=[],l=c.Wb(Qb),m=H(l);m;)m.name!=b.name&&k.push(m),m=H(l);k.push(b);return he(k,ud(g))}return Pd}g=c.get(b.name);k=d;g&&(k=k.remove(new E(b.name,g)));return k.Na(b,b.S)});return new fe(d,a.cc)}
+function ie(a,b,c){var d=na(a.yd,function(a){if(a===Pd)return a;var d=c.get(b.name);return d?a.remove(new E(b.name,d)):a});return new fe(d,a.cc)}var je=new fe({".priority":Pd},{".priority":M});function tc(a,b){this.C=a;J(n(this.C)&&null!==this.C,"LeafNode shouldn't be created with null/undefined value.");this.ba=b||C;ke(this.ba);this.Bb=null}h=tc.prototype;h.N=function(){return!0};h.A=function(){return this.ba};h.da=function(a){return new tc(this.C,a)};h.M=function(a){return".priority"===a?this.ba:C};h.oa=function(a){return a.e()?this:".priority"===O(a)?this.ba:C};h.Ha=function(){return!1};h.qf=function(){return null};
+h.Q=function(a,b){return".priority"===a?this.da(b):b.e()&&".priority"!==a?this:C.Q(a,b).da(this.ba)};h.G=function(a,b){var c=O(a);if(null===c)return b;if(b.e()&&".priority"!==c)return this;J(".priority"!==c||1===uc(a),".priority must be the last token in a path");return this.Q(c,C.G(G(a),b))};h.e=function(){return!1};h.Db=function(){return 0};h.K=function(a){return a&&!this.A().e()?{".value":this.Ba(),".priority":this.A().K()}:this.Ba()};
+h.hash=function(){if(null===this.Bb){var a="";this.ba.e()||(a+="priority:"+le(this.ba.K())+":");var b=typeof this.C,a=a+(b+":"),a="number"===b?a+Zc(this.C):a+this.C;this.Bb=Jc(a)}return this.Bb};h.Ba=function(){return this.C};h.Cc=function(a){if(a===C)return 1;if(a instanceof T)return-1;J(a.N(),"Unknown node type");var b=typeof a.C,c=typeof this.C,d=Na(me,b),e=Na(me,c);J(0<=d,"Unknown leaf type: "+b);J(0<=e,"Unknown leaf type: "+c);return d===e?"object"===c?0:this.C<a.C?-1:this.C===a.C?0:1:e-d};
+var me=["object","boolean","number","string"];tc.prototype.mb=function(){return this};tc.prototype.Ic=function(){return!0};tc.prototype.Z=function(a){return a===this?!0:a.N()?this.C===a.C&&this.ba.Z(a.ba):!1};tc.prototype.toString=function(){return B(this.K(!0))};function T(a,b,c){this.m=a;(this.ba=b)&&ke(this.ba);a.e()&&J(!this.ba||this.ba.e(),"An empty node cannot have a priority");this.wb=c;this.Bb=null}h=T.prototype;h.N=function(){return!1};h.A=function(){return this.ba||C};h.da=function(a){return this.m.e()?this:new T(this.m,a,this.wb)};h.M=function(a){if(".priority"===a)return this.A();a=this.m.get(a);return null===a?C:a};h.oa=function(a){var b=O(a);return null===b?this:this.M(b).oa(G(a))};h.Ha=function(a){return null!==this.m.get(a)};
+h.Q=function(a,b){J(b,"We should always be passing snapshot nodes");if(".priority"===a)return this.da(b);var c=new E(a,b),d,e;b.e()?(d=this.m.remove(a),c=ie(this.wb,c,this.m)):(d=this.m.Na(a,b),c=ge(this.wb,c,this.m));e=d.e()?C:this.ba;return new T(d,e,c)};h.G=function(a,b){var c=O(a);if(null===c)return b;J(".priority"!==O(a)||1===uc(a),".priority must be the last token in a path");var d=this.M(c).G(G(a),b);return this.Q(c,d)};h.e=function(){return this.m.e()};h.Db=function(){return this.m.count()};
+var ne=/^(0|[1-9]\d*)$/;h=T.prototype;h.K=function(a){if(this.e())return null;var b={},c=0,d=0,e=!0;this.U(M,function(f,g){b[f]=g.K(a);c++;e&&ne.test(f)?d=Math.max(d,Number(f)):e=!1});if(!a&&e&&d<2*c){var f=[],g;for(g in b)f[g]=b[g];return f}a&&!this.A().e()&&(b[".priority"]=this.A().K());return b};h.hash=function(){if(null===this.Bb){var a="";this.A().e()||(a+="priority:"+le(this.A().K())+":");this.U(M,function(b,c){var d=c.hash();""!==d&&(a+=":"+b+":"+d)});this.Bb=""===a?"":Jc(a)}return this.Bb};
+h.qf=function(a,b,c){return(c=oe(this,c))?(a=cc(c,new E(a,b)))?a.name:null:cc(this.m,a)};function wd(a,b){var c;c=(c=oe(a,b))?(c=c.Rc())&&c.name:a.m.Rc();return c?new E(c,a.m.get(c)):null}function xd(a,b){var c;c=(c=oe(a,b))?(c=c.ec())&&c.name:a.m.ec();return c?new E(c,a.m.get(c)):null}h.U=function(a,b){var c=oe(this,a);return c?c.ha(function(a){return b(a.name,a.S)}):this.m.ha(b)};h.Wb=function(a){return this.Xb(a.Sc(),a)};
+h.Xb=function(a,b){var c=oe(this,b);if(c)return c.Xb(a,function(a){return a});for(var c=this.m.Xb(a.name,Qb),d=ec(c);null!=d&&0>b.compare(d,a);)H(c),d=ec(c);return c};h.rf=function(a){return this.Zb(a.Pc(),a)};h.Zb=function(a,b){var c=oe(this,b);if(c)return c.Zb(a,function(a){return a});for(var c=this.m.Zb(a.name,Qb),d=ec(c);null!=d&&0<b.compare(d,a);)H(c),d=ec(c);return c};h.Cc=function(a){return this.e()?a.e()?0:-1:a.N()||a.e()?1:a===Sd?-1:0};
+h.mb=function(a){if(a===Vd||ta(this.wb.cc,a.toString()))return this;var b=this.wb,c=this.m;J(a!==Vd,"KeyIndex always exists and isn't meant to be added to the IndexMap.");for(var d=[],e=!1,c=c.Wb(Qb),f=H(c);f;)e=e||a.Hc(f.S),d.push(f),f=H(c);d=e?he(d,ud(a)):Pd;e=a.toString();c=xa(b.cc);c[e]=a;a=xa(b.yd);a[e]=d;return new T(this.m,this.ba,new fe(a,c))};h.Ic=function(a){return a===Vd||ta(this.wb.cc,a.toString())};
+h.Z=function(a){if(a===this)return!0;if(a.N())return!1;if(this.A().Z(a.A())&&this.m.count()===a.m.count()){var b=this.Wb(M);a=a.Wb(M);for(var c=H(b),d=H(a);c&&d;){if(c.name!==d.name||!c.S.Z(d.S))return!1;c=H(b);d=H(a)}return null===c&&null===d}return!1};function oe(a,b){return b===Vd?null:a.wb.get(b.toString())}h.toString=function(){return B(this.K(!0))};function L(a,b){if(null===a)return C;var c=null;"object"===typeof a&&".priority"in a?c=a[".priority"]:"undefined"!==typeof b&&(c=b);J(null===c||"string"===typeof c||"number"===typeof c||"object"===typeof c&&".sv"in c,"Invalid priority type found: "+typeof c);"object"===typeof a&&".value"in a&&null!==a[".value"]&&(a=a[".value"]);if("object"!==typeof a||".sv"in a)return new tc(a,L(c));if(a instanceof Array){var d=C,e=a;r(e,function(a,b){if(u(e,b)&&"."!==b.substring(0,1)){var c=L(a);if(c.N()||!c.e())d=
+d.Q(b,c)}});return d.da(L(c))}var f=[],g=!1,k=a;hb(k,function(a){if("string"!==typeof a||"."!==a.substring(0,1)){var b=L(k[a]);b.e()||(g=g||!b.A().e(),f.push(new E(a,b)))}});if(0==f.length)return C;var l=he(f,Rb,function(a){return a.name},Tb);if(g){var m=he(f,ud(M));return new T(l,L(c),new fe({".priority":m},{".priority":M}))}return new T(l,L(c),je)}var pe=Math.log(2);
+function qe(a){this.count=parseInt(Math.log(a+1)/pe,10);this.hf=this.count-1;this.bg=a+1&parseInt(Array(this.count+1).join("1"),2)}function re(a){var b=!(a.bg&1<<a.hf);a.hf--;return b}
+function he(a,b,c,d){function e(b,d){var f=d-b;if(0==f)return null;if(1==f){var m=a[b],v=c?c(m):m;return new fc(v,m.S,!1,null,null)}var m=parseInt(f/2,10)+b,f=e(b,m),y=e(m+1,d),m=a[m],v=c?c(m):m;return new fc(v,m.S,!1,f,y)}a.sort(b);var f=function(b){function d(b,g){var k=v-b,y=v;v-=b;var y=e(k+1,y),k=a[k],I=c?c(k):k,y=new fc(I,k.S,g,null,y);f?f.left=y:m=y;f=y}for(var f=null,m=null,v=a.length,y=0;y<b.count;++y){var I=re(b),vd=Math.pow(2,b.count-(y+1));I?d(vd,!1):(d(vd,!1),d(vd,!0))}return m}(new qe(a.length));
+return null!==f?new ac(d||b,f):new ac(d||b)}function le(a){return"number"===typeof a?"number:"+Zc(a):"string:"+a}function ke(a){if(a.N()){var b=a.K();J("string"===typeof b||"number"===typeof b||"object"===typeof b&&u(b,".sv"),"Priority must be a string or number.")}else J(a===Sd||a.e(),"priority of unexpected type.");J(a===Sd||a.A().e(),"Priority nodes can't have a priority of their own.")}var C=new T(new ac(Tb),null,je);function se(){T.call(this,new ac(Tb),C,je)}ma(se,T);h=se.prototype;
+h.Cc=function(a){return a===this?0:1};h.Z=function(a){return a===this};h.A=function(){return this};h.M=function(){return C};h.e=function(){return!1};var Sd=new se,Qd=new E("[MIN_NAME]",C),Xd=new E("[MAX_NAME]",Sd);function Id(a,b){this.D=a;this.Ud=b}function Fd(a,b,c,d){return new Id(new sb(b,c,d),a.Ud)}function Jd(a){return a.D.$?a.D.j():null}Id.prototype.u=function(){return this.Ud};function tb(a){return a.Ud.$?a.Ud.j():null};function te(a,b){this.V=a;var c=a.n,d=new ld(c.g),c=de(c)?new ld(c.g):c.ia?new rd(c):new md(c);this.Gf=new zd(c);var e=b.u(),f=b.D,g=d.ta(C,e.j(),null),k=c.ta(C,f.j(),null);this.Ka=new Id(new sb(k,f.$,c.Ga()),new sb(g,e.$,d.Ga()));this.Za=[];this.ig=new dd(a)}function ue(a){return a.V}h=te.prototype;h.u=function(){return this.Ka.u().j()};h.hb=function(a){var b=tb(this.Ka);return b&&(de(this.V.n)||!a.e()&&!b.M(O(a)).e())?b.oa(a):null};h.e=function(){return 0===this.Za.length};h.Ob=function(a){this.Za.push(a)};
+h.kb=function(a,b){var c=[];if(b){J(null==a,"A cancel should cancel all event registrations.");var d=this.V.path;Oa(this.Za,function(a){(a=a.ff(b,d))&&c.push(a)})}if(a){for(var e=[],f=0;f<this.Za.length;++f){var g=this.Za[f];if(!g.matches(a))e.push(g);else if(a.sf()){e=e.concat(this.Za.slice(f+1));break}}this.Za=e}else this.Za=[];return c};
+h.bb=function(a,b,c){a.type===Cd&&null!==a.source.Ib&&(J(tb(this.Ka),"We should always have a full cache before handling merges"),J(Jd(this.Ka),"Missing event cache, even though we have a server cache"));var d=this.Ka;a=this.Gf.bb(d,a,b,c);b=this.Gf;c=a.he;J(c.D.j().Ic(b.I.g),"Event snap not indexed");J(c.u().j().Ic(b.I.g),"Server snap not indexed");J(Hb(a.he.u())||!Hb(d.u()),"Once a server snap is complete, it should never go back");this.Ka=a.he;return ve(this,a.cg,a.he.D.j(),null)};
+function we(a,b){var c=a.Ka.D,d=[];c.j().N()||c.j().U(M,function(a,b){d.push(new D("child_added",b,a))});c.$&&d.push(Db(c.j()));return ve(a,d,c.j(),b)}function ve(a,b,c,d){return ed(a.ig,b,c,d?[d]:a.Za)};function xe(a,b,c){this.type=Cd;this.source=a;this.path=b;this.children=c}xe.prototype.Wc=function(a){if(this.path.e())return a=this.children.subtree(new K(a)),a.e()?null:a.value?new Ub(this.source,F,a.value):new xe(this.source,F,a);J(O(this.path)===a,"Can't get a merge for a child not on the path of the operation");return new xe(this.source,G(this.path),this.children)};xe.prototype.toString=function(){return"Operation("+this.path+": "+this.source.toString()+" merge: "+this.children.toString()+")"};var Vb=0,Cd=1,Xb=2,$b=3;function ye(a,b,c,d){this.ve=a;this.of=b;this.Ib=c;this.af=d;J(!d||b,"Tagged queries must be from server.")}var Yb=new ye(!0,!1,null,!1),ze=new ye(!1,!0,null,!1);ye.prototype.toString=function(){return this.ve?"user":this.af?"server(queryID="+this.Ib+")":"server"};function Ae(a,b){this.f=Oc("p:rest:");this.H=a;this.Gb=b;this.Fa=null;this.aa={}}function Be(a,b){if(n(b))return"tag$"+b;var c=a.n;J(de(c)&&c.g==M,"should have a tag if it's not a default query.");return a.path.toString()}h=Ae.prototype;
+h.xf=function(a,b,c,d){var e=a.path.toString();this.f("Listen called for "+e+" "+a.wa());var f=Be(a,c),g={};this.aa[f]=g;a=ee(a.n);var k=this;Ce(this,e+".json",a,function(a,b){var v=b;404===a&&(a=v=null);null===a&&k.Gb(e,v,!1,c);w(k.aa,f)===g&&d(a?401==a?"permission_denied":"rest_error:"+a:"ok",null)})};h.Of=function(a,b){var c=Be(a,b);delete this.aa[c]};h.P=function(a,b){this.Fa=a;var c=ad(a),d=c.data,c=c.Ac&&c.Ac.exp;b&&b("ok",{auth:d,expires:c})};h.ee=function(a){this.Fa=null;a("ok",null)};
+h.Le=function(){};h.Bf=function(){};h.Gd=function(){};h.put=function(){};h.yf=function(){};h.Te=function(){};
+function Ce(a,b,c,d){c=c||{};c.format="export";a.Fa&&(c.auth=a.Fa);var e=(a.H.lb?"https://":"http://")+a.H.host+b+"?"+jb(c);a.f("Sending REST request for "+e);var f=new XMLHttpRequest;f.onreadystatechange=function(){if(d&&4===f.readyState){a.f("REST Response for "+e+" received. status:",f.status,"response:",f.responseText);var b=null;if(200<=f.status&&300>f.status){try{b=mb(f.responseText)}catch(c){Q("Failed to parse JSON response for "+e+": "+f.responseText)}d(null,b)}else 401!==f.status&&404!==
+f.status&&Q("Got unsuccessful REST response for "+e+" Status: "+f.status),d(f.status);d=null}};f.open("GET",e,!0);f.send()};function De(a,b){this.value=a;this.children=b||Ee}var Ee=new ac(function(a,b){return a===b?0:a<b?-1:1});function Fe(a){var b=Nd;r(a,function(a,d){b=b.set(new K(d),a)});return b}h=De.prototype;h.e=function(){return null===this.value&&this.children.e()};function Ge(a,b,c){if(null!=a.value&&c(a.value))return{path:F,value:a.value};if(b.e())return null;var d=O(b);a=a.children.get(d);return null!==a?(b=Ge(a,G(b),c),null!=b?{path:(new K(d)).w(b.path),value:b.value}:null):null}
+function He(a,b){return Ge(a,b,function(){return!0})}h.subtree=function(a){if(a.e())return this;var b=this.children.get(O(a));return null!==b?b.subtree(G(a)):Nd};h.set=function(a,b){if(a.e())return new De(b,this.children);var c=O(a),d=(this.children.get(c)||Nd).set(G(a),b),c=this.children.Na(c,d);return new De(this.value,c)};
+h.remove=function(a){if(a.e())return this.children.e()?Nd:new De(null,this.children);var b=O(a),c=this.children.get(b);return c?(a=c.remove(G(a)),b=a.e()?this.children.remove(b):this.children.Na(b,a),null===this.value&&b.e()?Nd:new De(this.value,b)):this};h.get=function(a){if(a.e())return this.value;var b=this.children.get(O(a));return b?b.get(G(a)):null};
+function Md(a,b,c){if(b.e())return c;var d=O(b);b=Md(a.children.get(d)||Nd,G(b),c);d=b.e()?a.children.remove(d):a.children.Na(d,b);return new De(a.value,d)}function Ie(a,b){return Je(a,F,b)}function Je(a,b,c){var d={};a.children.ha(function(a,f){d[a]=Je(f,b.w(a),c)});return c(b,a.value,d)}function Ke(a,b,c){return Le(a,b,F,c)}function Le(a,b,c,d){var e=a.value?d(c,a.value):!1;if(e)return e;if(b.e())return null;e=O(b);return(a=a.children.get(e))?Le(a,G(b),c.w(e),d):null}
+function Me(a,b,c){var d=F;if(!b.e()){var e=!0;a.value&&(e=c(d,a.value));!0===e&&(e=O(b),(a=a.children.get(e))&&Ne(a,G(b),d.w(e),c))}}function Ne(a,b,c,d){if(b.e())return a;a.value&&d(c,a.value);var e=O(b);return(a=a.children.get(e))?Ne(a,G(b),c.w(e),d):Nd}function Kd(a,b){Oe(a,F,b)}function Oe(a,b,c){a.children.ha(function(a,e){Oe(e,b.w(a),c)});a.value&&c(b,a.value)}function Pe(a,b){a.children.ha(function(a,d){d.value&&b(a,d.value)})}var Nd=new De(null);
+De.prototype.toString=function(){var a={};Kd(this,function(b,c){a[b.toString()]=c.toString()});return B(a)};function Qe(a){this.W=a}var Re=new Qe(new De(null));function Se(a,b,c){if(b.e())return new Qe(new De(c));var d=He(a.W,b);if(null!=d){var e=d.path,d=d.value;b=N(e,b);d=d.G(b,c);return new Qe(a.W.set(e,d))}a=Md(a.W,b,new De(c));return new Qe(a)}function Te(a,b,c){var d=a;hb(c,function(a,c){d=Se(d,b.w(a),c)});return d}Qe.prototype.Od=function(a){if(a.e())return Re;a=Md(this.W,a,Nd);return new Qe(a)};function Ue(a,b){var c=He(a.W,b);return null!=c?a.W.get(c.path).oa(N(c.path,b)):null}
+function Ve(a){var b=[],c=a.W.value;null!=c?c.N()||c.U(M,function(a,c){b.push(new E(a,c))}):a.W.children.ha(function(a,c){null!=c.value&&b.push(new E(a,c.value))});return b}function We(a,b){if(b.e())return a;var c=Ue(a,b);return null!=c?new Qe(new De(c)):new Qe(a.W.subtree(b))}Qe.prototype.e=function(){return this.W.e()};Qe.prototype.apply=function(a){return Xe(F,this.W,a)};
+function Xe(a,b,c){if(null!=b.value)return c.G(a,b.value);var d=null;b.children.ha(function(b,f){".priority"===b?(J(null!==f.value,"Priority writes must always be leaf nodes"),d=f.value):c=Xe(a.w(b),f,c)});c.oa(a).e()||null===d||(c=c.G(a.w(".priority"),d));return c};function Ye(){this.T=Re;this.za=[];this.Lc=-1}h=Ye.prototype;
+h.Od=function(a){var b=Ua(this.za,function(b){return b.ie===a});J(0<=b,"removeWrite called with nonexistent writeId.");var c=this.za[b];this.za.splice(b,1);for(var d=c.visible,e=!1,f=this.za.length-1;d&&0<=f;){var g=this.za[f];g.visible&&(f>=b&&Ze(g,c.path)?d=!1:c.path.contains(g.path)&&(e=!0));f--}if(d){if(e)this.T=$e(this.za,af,F),this.Lc=0<this.za.length?this.za[this.za.length-1].ie:-1;else if(c.Ia)this.T=this.T.Od(c.path);else{var k=this;r(c.children,function(a,b){k.T=k.T.Od(c.path.w(b))})}return c.path}return null};
+h.ua=function(a,b,c,d){if(c||d){var e=We(this.T,a);return!d&&e.e()?b:d||null!=b||null!=Ue(e,F)?(e=$e(this.za,function(b){return(b.visible||d)&&(!c||!(0<=Na(c,b.ie)))&&(b.path.contains(a)||a.contains(b.path))},a),b=b||C,e.apply(b)):null}e=Ue(this.T,a);if(null!=e)return e;e=We(this.T,a);return e.e()?b:null!=b||null!=Ue(e,F)?(b=b||C,e.apply(b)):null};
+h.xc=function(a,b){var c=C,d=Ue(this.T,a);if(d)d.N()||d.U(M,function(a,b){c=c.Q(a,b)});else if(b){var e=We(this.T,a);b.U(M,function(a,b){var d=We(e,new K(a)).apply(b);c=c.Q(a,d)});Oa(Ve(e),function(a){c=c.Q(a.name,a.S)})}else e=We(this.T,a),Oa(Ve(e),function(a){c=c.Q(a.name,a.S)});return c};h.hd=function(a,b,c,d){J(c||d,"Either existingEventSnap or existingServerSnap must exist");a=a.w(b);if(null!=Ue(this.T,a))return null;a=We(this.T,a);return a.e()?d.oa(b):a.apply(d.oa(b))};
+h.Xa=function(a,b,c){a=a.w(b);var d=Ue(this.T,a);return null!=d?d:rb(c,b)?We(this.T,a).apply(c.j().M(b)):null};h.sc=function(a){return Ue(this.T,a)};h.me=function(a,b,c,d,e,f){var g;a=We(this.T,a);g=Ue(a,F);if(null==g)if(null!=b)g=a.apply(b);else return[];g=g.mb(f);if(g.e()||g.N())return[];b=[];a=ud(f);e=e?g.Zb(c,f):g.Xb(c,f);for(f=H(e);f&&b.length<d;)0!==a(f,c)&&b.push(f),f=H(e);return b};
+function Ze(a,b){return a.Ia?a.path.contains(b):!!ua(a.children,function(c,d){return a.path.w(d).contains(b)})}function af(a){return a.visible}
+function $e(a,b,c){for(var d=Re,e=0;e<a.length;++e){var f=a[e];if(b(f)){var g=f.path;if(f.Ia)c.contains(g)?(g=N(c,g),d=Se(d,g,f.Ia)):g.contains(c)&&(g=N(g,c),d=Se(d,F,f.Ia.oa(g)));else if(f.children)if(c.contains(g))g=N(c,g),d=Te(d,g,f.children);else{if(g.contains(c))if(g=N(g,c),g.e())d=Te(d,F,f.children);else if(f=w(f.children,O(g)))f=f.oa(G(g)),d=Se(d,F,f)}else throw Hc("WriteRecord should have .snap or .children");}}return d}function bf(a,b){this.Mb=a;this.W=b}h=bf.prototype;
+h.ua=function(a,b,c){return this.W.ua(this.Mb,a,b,c)};h.xc=function(a){return this.W.xc(this.Mb,a)};h.hd=function(a,b,c){return this.W.hd(this.Mb,a,b,c)};h.sc=function(a){return this.W.sc(this.Mb.w(a))};h.me=function(a,b,c,d,e){return this.W.me(this.Mb,a,b,c,d,e)};h.Xa=function(a,b){return this.W.Xa(this.Mb,a,b)};h.w=function(a){return new bf(this.Mb.w(a),this.W)};function cf(){this.ya={}}h=cf.prototype;h.e=function(){return wa(this.ya)};h.bb=function(a,b,c){var d=a.source.Ib;if(null!==d)return d=w(this.ya,d),J(null!=d,"SyncTree gave us an op for an invalid query."),d.bb(a,b,c);var e=[];r(this.ya,function(d){e=e.concat(d.bb(a,b,c))});return e};h.Ob=function(a,b,c,d,e){var f=a.wa(),g=w(this.ya,f);if(!g){var g=c.ua(e?d:null),k=!1;g?k=!0:(g=d instanceof T?c.xc(d):C,k=!1);g=new te(a,new Id(new sb(g,k,!1),new sb(d,e,!1)));this.ya[f]=g}g.Ob(b);return we(g,b)};
+h.kb=function(a,b,c){var d=a.wa(),e=[],f=[],g=null!=df(this);if("default"===d){var k=this;r(this.ya,function(a,d){f=f.concat(a.kb(b,c));a.e()&&(delete k.ya[d],de(a.V.n)||e.push(a.V))})}else{var l=w(this.ya,d);l&&(f=f.concat(l.kb(b,c)),l.e()&&(delete this.ya[d],de(l.V.n)||e.push(l.V)))}g&&null==df(this)&&e.push(new U(a.k,a.path));return{Hg:e,jg:f}};function ef(a){return Pa(ra(a.ya),function(a){return!de(a.V.n)})}h.hb=function(a){var b=null;r(this.ya,function(c){b=b||c.hb(a)});return b};
+function ff(a,b){if(de(b.n))return df(a);var c=b.wa();return w(a.ya,c)}function df(a){return va(a.ya,function(a){return de(a.V.n)})||null};function gf(a){this.sa=Nd;this.Hb=new Ye;this.$e={};this.kc={};this.Mc=a}function hf(a,b,c,d,e){var f=a.Hb,g=e;J(d>f.Lc,"Stacking an older write on top of newer ones");n(g)||(g=!0);f.za.push({path:b,Ia:c,ie:d,visible:g});g&&(f.T=Se(f.T,b,c));f.Lc=d;return e?jf(a,new Ub(Yb,b,c)):[]}function kf(a,b,c,d){var e=a.Hb;J(d>e.Lc,"Stacking an older merge on top of newer ones");e.za.push({path:b,children:c,ie:d,visible:!0});e.T=Te(e.T,b,c);e.Lc=d;c=Fe(c);return jf(a,new xe(Yb,b,c))}
+function lf(a,b,c){c=c||!1;b=a.Hb.Od(b);return null==b?[]:jf(a,new Wb(b,c))}function mf(a,b,c){c=Fe(c);return jf(a,new xe(ze,b,c))}function nf(a,b,c,d){d=of(a,d);if(null!=d){var e=pf(d);d=e.path;e=e.Ib;b=N(d,b);c=new Ub(new ye(!1,!0,e,!0),b,c);return qf(a,d,c)}return[]}function rf(a,b,c,d){if(d=of(a,d)){var e=pf(d);d=e.path;e=e.Ib;b=N(d,b);c=Fe(c);c=new xe(new ye(!1,!0,e,!0),b,c);return qf(a,d,c)}return[]}
+gf.prototype.Ob=function(a,b){var c=a.path,d=null,e=!1;Me(this.sa,c,function(a,b){var f=N(a,c);d=b.hb(f);e=e||null!=df(b);return!d});var f=this.sa.get(c);f?(e=e||null!=df(f),d=d||f.hb(F)):(f=new cf,this.sa=this.sa.set(c,f));var g;null!=d?g=!0:(g=!1,d=C,Pe(this.sa.subtree(c),function(a,b){var c=b.hb(F);c&&(d=d.Q(a,c))}));var k=null!=ff(f,a);if(!k&&!de(a.n)){var l=sf(a);J(!(l in this.kc),"View does not exist, but we have a tag");var m=tf++;this.kc[l]=m;this.$e["_"+m]=l}g=f.Ob(a,b,new bf(c,this.Hb),
+d,g);k||e||(f=ff(f,a),g=g.concat(uf(this,a,f)));return g};
+gf.prototype.kb=function(a,b,c){var d=a.path,e=this.sa.get(d),f=[];if(e&&("default"===a.wa()||null!=ff(e,a))){f=e.kb(a,b,c);e.e()&&(this.sa=this.sa.remove(d));e=f.Hg;f=f.jg;b=-1!==Ua(e,function(a){return de(a.n)});var g=Ke(this.sa,d,function(a,b){return null!=df(b)});if(b&&!g&&(d=this.sa.subtree(d),!d.e()))for(var d=vf(d),k=0;k<d.length;++k){var l=d[k],m=l.V,l=wf(this,l);this.Mc.Xe(m,xf(this,m),l.ud,l.J)}if(!g&&0<e.length&&!c)if(b)this.Mc.Zd(a,null);else{var v=this;Oa(e,function(a){a.wa();var b=v.kc[sf(a)];
+v.Mc.Zd(a,b)})}yf(this,e)}return f};gf.prototype.ua=function(a,b){var c=this.Hb,d=Ke(this.sa,a,function(b,c){var d=N(b,a);if(d=c.hb(d))return d});return c.ua(a,d,b,!0)};function vf(a){return Ie(a,function(a,c,d){if(c&&null!=df(c))return[df(c)];var e=[];c&&(e=ef(c));r(d,function(a){e=e.concat(a)});return e})}function yf(a,b){for(var c=0;c<b.length;++c){var d=b[c];if(!de(d.n)){var d=sf(d),e=a.kc[d];delete a.kc[d];delete a.$e["_"+e]}}}
+function uf(a,b,c){var d=b.path,e=xf(a,b);c=wf(a,c);b=a.Mc.Xe(b,e,c.ud,c.J);d=a.sa.subtree(d);if(e)J(null==df(d.value),"If we're adding a query, it shouldn't be shadowed");else for(e=Ie(d,function(a,b,c){if(!a.e()&&b&&null!=df(b))return[ue(df(b))];var d=[];b&&(d=d.concat(Qa(ef(b),function(a){return a.V})));r(c,function(a){d=d.concat(a)});return d}),d=0;d<e.length;++d)c=e[d],a.Mc.Zd(c,xf(a,c));return b}
+function wf(a,b){var c=b.V,d=xf(a,c);return{ud:function(){return(b.u()||C).hash()},J:function(b){if("ok"===b){if(d){var f=c.path;if(b=of(a,d)){var g=pf(b);b=g.path;g=g.Ib;f=N(b,f);f=new Zb(new ye(!1,!0,g,!0),f);b=qf(a,b,f)}else b=[]}else b=jf(a,new Zb(ze,c.path));return b}f="Unknown Error";"too_big"===b?f="The data requested exceeds the maximum size that can be accessed with a single request.":"permission_denied"==b?f="Client doesn't have permission to access the desired data.":"unavailable"==b&&
+(f="The service is unavailable");f=Error(b+": "+f);f.code=b.toUpperCase();return a.kb(c,null,f)}}}function sf(a){return a.path.toString()+"$"+a.wa()}function pf(a){var b=a.indexOf("$");J(-1!==b&&b<a.length-1,"Bad queryKey.");return{Ib:a.substr(b+1),path:new K(a.substr(0,b))}}function of(a,b){var c=a.$e,d="_"+b;return d in c?c[d]:void 0}function xf(a,b){var c=sf(b);return w(a.kc,c)}var tf=1;
+function qf(a,b,c){var d=a.sa.get(b);J(d,"Missing sync point for query tag that we're tracking");return d.bb(c,new bf(b,a.Hb),null)}function jf(a,b){return zf(a,b,a.sa,null,new bf(F,a.Hb))}function zf(a,b,c,d,e){if(b.path.e())return Af(a,b,c,d,e);var f=c.get(F);null==d&&null!=f&&(d=f.hb(F));var g=[],k=O(b.path),l=b.Wc(k);if((c=c.children.get(k))&&l)var m=d?d.M(k):null,k=e.w(k),g=g.concat(zf(a,l,c,m,k));f&&(g=g.concat(f.bb(b,e,d)));return g}
+function Af(a,b,c,d,e){var f=c.get(F);null==d&&null!=f&&(d=f.hb(F));var g=[];c.children.ha(function(c,f){var m=d?d.M(c):null,v=e.w(c),y=b.Wc(c);y&&(g=g.concat(Af(a,y,f,m,v)))});f&&(g=g.concat(f.bb(b,e,d)));return g};function Bf(){this.children={};this.kd=0;this.value=null}function Cf(a,b,c){this.Dd=a?a:"";this.Yc=b?b:null;this.B=c?c:new Bf}function Df(a,b){for(var c=b instanceof K?b:new K(b),d=a,e;null!==(e=O(c));)d=new Cf(e,d,w(d.B.children,e)||new Bf),c=G(c);return d}h=Cf.prototype;h.Ba=function(){return this.B.value};function Ef(a,b){J("undefined"!==typeof b,"Cannot set value to undefined");a.B.value=b;Ff(a)}h.clear=function(){this.B.value=null;this.B.children={};this.B.kd=0;Ff(this)};
+h.td=function(){return 0<this.B.kd};h.e=function(){return null===this.Ba()&&!this.td()};h.U=function(a){var b=this;r(this.B.children,function(c,d){a(new Cf(d,b,c))})};function Gf(a,b,c,d){c&&!d&&b(a);a.U(function(a){Gf(a,b,!0,d)});c&&d&&b(a)}function Hf(a,b){for(var c=a.parent();null!==c&&!b(c);)c=c.parent()}h.path=function(){return new K(null===this.Yc?this.Dd:this.Yc.path()+"/"+this.Dd)};h.name=function(){return this.Dd};h.parent=function(){return this.Yc};
+function Ff(a){if(null!==a.Yc){var b=a.Yc,c=a.Dd,d=a.e(),e=u(b.B.children,c);d&&e?(delete b.B.children[c],b.B.kd--,Ff(b)):d||e||(b.B.children[c]=a.B,b.B.kd++,Ff(b))}};function If(a){J(ea(a)&&0<a.length,"Requires a non-empty array");this.Uf=a;this.Nc={}}If.prototype.de=function(a,b){for(var c=this.Nc[a]||[],d=0;d<c.length;d++)c[d].yc.apply(c[d].Ma,Array.prototype.slice.call(arguments,1))};If.prototype.Eb=function(a,b,c){Jf(this,a);this.Nc[a]=this.Nc[a]||[];this.Nc[a].push({yc:b,Ma:c});(a=this.ze(a))&&b.apply(c,a)};If.prototype.gc=function(a,b,c){Jf(this,a);a=this.Nc[a]||[];for(var d=0;d<a.length;d++)if(a[d].yc===b&&(!c||c===a[d].Ma)){a.splice(d,1);break}};
+function Jf(a,b){J(Ta(a.Uf,function(a){return a===b}),"Unknown event: "+b)};var Kf=function(){var a=0,b=[];return function(c){var d=c===a;a=c;for(var e=Array(8),f=7;0<=f;f--)e[f]="-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".charAt(c%64),c=Math.floor(c/64);J(0===c,"Cannot push at time == 0");c=e.join("");if(d){for(f=11;0<=f&&63===b[f];f--)b[f]=0;b[f]++}else for(f=0;12>f;f++)b[f]=Math.floor(64*Math.random());for(f=0;12>f;f++)c+="-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".charAt(b[f]);J(20===c.length,"nextPushId: Length should be 20.");
+return c}}();function Lf(){If.call(this,["online"]);this.ic=!0;if("undefined"!==typeof window&&"undefined"!==typeof window.addEventListener){var a=this;window.addEventListener("online",function(){a.ic||(a.ic=!0,a.de("online",!0))},!1);window.addEventListener("offline",function(){a.ic&&(a.ic=!1,a.de("online",!1))},!1)}}ma(Lf,If);Lf.prototype.ze=function(a){J("online"===a,"Unknown event type: "+a);return[this.ic]};ca(Lf);function Mf(){If.call(this,["visible"]);var a,b;"undefined"!==typeof document&&"undefined"!==typeof document.addEventListener&&("undefined"!==typeof document.hidden?(b="visibilitychange",a="hidden"):"undefined"!==typeof document.mozHidden?(b="mozvisibilitychange",a="mozHidden"):"undefined"!==typeof document.msHidden?(b="msvisibilitychange",a="msHidden"):"undefined"!==typeof document.webkitHidden&&(b="webkitvisibilitychange",a="webkitHidden"));this.uc=!0;if(b){var c=this;document.addEventListener(b,
+function(){var b=!document[a];b!==c.uc&&(c.uc=b,c.de("visible",b))},!1)}}ma(Mf,If);Mf.prototype.ze=function(a){J("visible"===a,"Unknown event type: "+a);return[this.uc]};ca(Mf);var Nf=/[\[\].#$\/\u0000-\u001F\u007F]/,Of=/[\[\].#$\u0000-\u001F\u007F]/;function Pf(a){return p(a)&&0!==a.length&&!Nf.test(a)}function Qf(a){return null===a||p(a)||ga(a)&&!Sc(a)||ia(a)&&u(a,".sv")}function Rf(a,b,c,d){d&&!n(b)||Sf(z(a,1,d),b,c)}
+function Sf(a,b,c){c instanceof K&&(c=new wc(c,a));if(!n(b))throw Error(a+"contains undefined "+zc(c));if(ha(b))throw Error(a+"contains a function "+zc(c)+" with contents: "+b.toString());if(Sc(b))throw Error(a+"contains "+b.toString()+" "+zc(c));if(p(b)&&b.length>10485760/3&&10485760<xc(b))throw Error(a+"contains a string greater than 10485760 utf8 bytes "+zc(c)+" ('"+b.substring(0,50)+"...')");if(ia(b)){var d=!1,e=!1;hb(b,function(b,g){if(".value"===b)d=!0;else if(".priority"!==b&&".sv"!==b&&(e=
+!0,!Pf(b)))throw Error(a+" contains an invalid key ("+b+") "+zc(c)+'.  Keys must be non-empty strings and can\'t contain ".", "#", "$", "/", "[", or "]"');c.push(b);Sf(a,g,c);c.pop()});if(d&&e)throw Error(a+' contains ".value" child '+zc(c)+" in addition to actual children.");}}
+function Tf(a,b,c){if(!ia(b)||ea(b))throw Error(z(a,1,!1)+" must be an Object containing the children to replace.");if(u(b,".value"))throw Error(z(a,1,!1)+' must not contain ".value".  To overwrite with a leaf value, just use .set() instead.');Rf(a,b,c,!1)}
+function Uf(a,b,c){if(Sc(c))throw Error(z(a,b,!1)+"is "+c.toString()+", but must be a valid Firebase priority (a string, finite number, server value, or null).");if(!Qf(c))throw Error(z(a,b,!1)+"must be a valid Firebase priority (a string, finite number, server value, or null).");}
+function Vf(a,b,c){if(!c||n(b))switch(b){case "value":case "child_added":case "child_removed":case "child_changed":case "child_moved":break;default:throw Error(z(a,1,c)+'must be a valid event type: "value", "child_added", "child_removed", "child_changed", or "child_moved".');}}function Wf(a,b,c,d){if((!d||n(c))&&!Pf(c))throw Error(z(a,b,d)+'was an invalid key: "'+c+'".  Firebase keys must be non-empty strings and can\'t contain ".", "#", "$", "/", "[", or "]").');}
+function Xf(a,b){if(!p(b)||0===b.length||Of.test(b))throw Error(z(a,1,!1)+'was an invalid path: "'+b+'". Paths must be non-empty strings and can\'t contain ".", "#", "$", "[", or "]"');}function Yf(a,b){if(".info"===O(b))throw Error(a+" failed: Can't modify data under /.info/");}function Zf(a,b){if(!p(b))throw Error(z(a,1,!1)+"must be a valid credential (a string).");}function $f(a,b,c){if(!p(c))throw Error(z(a,b,!1)+"must be a valid string.");}
+function ag(a,b,c,d){if(!d||n(c))if(!ia(c)||null===c)throw Error(z(a,b,d)+"must be a valid object.");}function bg(a,b,c){if(!ia(b)||null===b||!u(b,c))throw Error(z(a,1,!1)+'must contain the key "'+c+'"');if(!p(w(b,c)))throw Error(z(a,1,!1)+'must contain the key "'+c+'" with type "string"');};function cg(){this.set={}}h=cg.prototype;h.add=function(a,b){this.set[a]=null!==b?b:!0};h.contains=function(a){return u(this.set,a)};h.get=function(a){return this.contains(a)?this.set[a]:void 0};h.remove=function(a){delete this.set[a]};h.clear=function(){this.set={}};h.e=function(){return wa(this.set)};h.count=function(){return pa(this.set)};function dg(a,b){r(a.set,function(a,d){b(d,a)})}h.keys=function(){var a=[];r(this.set,function(b,c){a.push(c)});return a};function qc(){this.m=this.C=null}qc.prototype.find=function(a){if(null!=this.C)return this.C.oa(a);if(a.e()||null==this.m)return null;var b=O(a);a=G(a);return this.m.contains(b)?this.m.get(b).find(a):null};qc.prototype.mc=function(a,b){if(a.e())this.C=b,this.m=null;else if(null!==this.C)this.C=this.C.G(a,b);else{null==this.m&&(this.m=new cg);var c=O(a);this.m.contains(c)||this.m.add(c,new qc);c=this.m.get(c);a=G(a);c.mc(a,b)}};
+function eg(a,b){if(b.e())return a.C=null,a.m=null,!0;if(null!==a.C){if(a.C.N())return!1;var c=a.C;a.C=null;c.U(M,function(b,c){a.mc(new K(b),c)});return eg(a,b)}return null!==a.m?(c=O(b),b=G(b),a.m.contains(c)&&eg(a.m.get(c),b)&&a.m.remove(c),a.m.e()?(a.m=null,!0):!1):!0}function rc(a,b,c){null!==a.C?c(b,a.C):a.U(function(a,e){var f=new K(b.toString()+"/"+a);rc(e,f,c)})}qc.prototype.U=function(a){null!==this.m&&dg(this.m,function(b,c){a(b,c)})};var fg="auth.firebase.com";function gg(a,b,c){this.ld=a||{};this.ce=b||{};this.ab=c||{};this.ld.remember||(this.ld.remember="default")}var hg=["remember","redirectTo"];function ig(a){var b={},c={};hb(a||{},function(a,e){0<=Na(hg,a)?b[a]=e:c[a]=e});return new gg(b,{},c)};function jg(a,b){this.Pe=["session",a.Ld,a.Cb].join(":");this.$d=b}jg.prototype.set=function(a,b){if(!b)if(this.$d.length)b=this.$d[0];else throw Error("fb.login.SessionManager : No storage options available!");b.set(this.Pe,a)};jg.prototype.get=function(){var a=Qa(this.$d,q(this.ng,this)),a=Pa(a,function(a){return null!==a});Xa(a,function(a,c){return bd(c.token)-bd(a.token)});return 0<a.length?a.shift():null};jg.prototype.ng=function(a){try{var b=a.get(this.Pe);if(b&&b.token)return b}catch(c){}return null};
+jg.prototype.clear=function(){var a=this;Oa(this.$d,function(b){b.remove(a.Pe)})};function kg(){return"undefined"!==typeof window&&!!(window.cordova||window.phonegap||window.PhoneGap)&&/ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(navigator.userAgent)}function lg(){return"undefined"!==typeof location&&/^file:\//.test(location.href)}
+function mg(){if("undefined"===typeof navigator)return!1;var a=navigator.userAgent;if("Microsoft Internet Explorer"===navigator.appName){if((a=a.match(/MSIE ([0-9]{1,}[\.0-9]{0,})/))&&1<a.length)return 8<=parseFloat(a[1])}else if(-1<a.indexOf("Trident")&&(a=a.match(/rv:([0-9]{2,2}[\.0-9]{0,})/))&&1<a.length)return 8<=parseFloat(a[1]);return!1};function ng(){var a=window.opener.frames,b;for(b=a.length-1;0<=b;b--)try{if(a[b].location.protocol===window.location.protocol&&a[b].location.host===window.location.host&&"__winchan_relay_frame"===a[b].name)return a[b]}catch(c){}return null}function og(a,b,c){a.attachEvent?a.attachEvent("on"+b,c):a.addEventListener&&a.addEventListener(b,c,!1)}function pg(a,b,c){a.detachEvent?a.detachEvent("on"+b,c):a.removeEventListener&&a.removeEventListener(b,c,!1)}
+function qg(a){/^https?:\/\//.test(a)||(a=window.location.href);var b=/^(https?:\/\/[\-_a-zA-Z\.0-9:]+)/.exec(a);return b?b[1]:a}function rg(a){var b="";try{a=a.replace("#","");var c=kb(a);c&&u(c,"__firebase_request_key")&&(b=w(c,"__firebase_request_key"))}catch(d){}return b}function sg(){var a=Rc(fg);return a.scheme+"://"+a.host+"/v2"}function tg(a){return sg()+"/"+a+"/auth/channel"};function ug(a){var b=this;this.zc=a;this.ae="*";mg()?this.Qc=this.wd=ng():(this.Qc=window.opener,this.wd=window);if(!b.Qc)throw"Unable to find relay frame";og(this.wd,"message",q(this.hc,this));og(this.wd,"message",q(this.Af,this));try{vg(this,{a:"ready"})}catch(c){og(this.Qc,"load",function(){vg(b,{a:"ready"})})}og(window,"unload",q(this.yg,this))}function vg(a,b){b=B(b);mg()?a.Qc.doPost(b,a.ae):a.Qc.postMessage(b,a.ae)}
+ug.prototype.hc=function(a){var b=this,c;try{c=mb(a.data)}catch(d){}c&&"request"===c.a&&(pg(window,"message",this.hc),this.ae=a.origin,this.zc&&setTimeout(function(){b.zc(b.ae,c.d,function(a,c){b.ag=!c;b.zc=void 0;vg(b,{a:"response",d:a,forceKeepWindowOpen:c})})},0))};ug.prototype.yg=function(){try{pg(this.wd,"message",this.Af)}catch(a){}this.zc&&(vg(this,{a:"error",d:"unknown closed window"}),this.zc=void 0);try{window.close()}catch(b){}};ug.prototype.Af=function(a){if(this.ag&&"die"===a.data)try{window.close()}catch(b){}};function wg(a){this.oc=Ga()+Ga()+Ga();this.Df=a}wg.prototype.open=function(a,b){P.set("redirect_request_id",this.oc);P.set("redirect_request_id",this.oc);b.requestId=this.oc;b.redirectTo=b.redirectTo||window.location.href;a+=(/\?/.test(a)?"":"?")+jb(b);window.location=a};wg.isAvailable=function(){return!lg()&&!kg()};wg.prototype.Bc=function(){return"redirect"};var xg={NETWORK_ERROR:"Unable to contact the Firebase server.",SERVER_ERROR:"An unknown server error occurred.",TRANSPORT_UNAVAILABLE:"There are no login transports available for the requested method.",REQUEST_INTERRUPTED:"The browser redirected the page before the login request could complete.",USER_CANCELLED:"The user cancelled authentication."};function yg(a){var b=Error(w(xg,a),a);b.code=a;return b};function zg(a){if(!a.window_features||"undefined"!==typeof navigator&&(-1!==navigator.userAgent.indexOf("Fennec/")||-1!==navigator.userAgent.indexOf("Firefox/")&&-1!==navigator.userAgent.indexOf("Android")))a.window_features=void 0;a.window_name||(a.window_name="_blank");this.options=a}
+zg.prototype.open=function(a,b,c){function d(a){g&&(document.body.removeChild(g),g=void 0);v&&(v=clearInterval(v));pg(window,"message",e);pg(window,"unload",d);if(m&&!a)try{m.close()}catch(b){k.postMessage("die",l)}m=k=void 0}function e(a){if(a.origin===l)try{var b=mb(a.data);"ready"===b.a?k.postMessage(y,l):"error"===b.a?(d(!1),c&&(c(b.d),c=null)):"response"===b.a&&(d(b.forceKeepWindowOpen),c&&(c(null,b.d),c=null))}catch(e){}}var f=mg(),g,k;if(!this.options.relay_url)return c(Error("invalid arguments: origin of url and relay_url must match"));
+var l=qg(a);if(l!==qg(this.options.relay_url))c&&setTimeout(function(){c(Error("invalid arguments: origin of url and relay_url must match"))},0);else{f&&(g=document.createElement("iframe"),g.setAttribute("src",this.options.relay_url),g.style.display="none",g.setAttribute("name","__winchan_relay_frame"),document.body.appendChild(g),k=g.contentWindow);a+=(/\?/.test(a)?"":"?")+jb(b);var m=window.open(a,this.options.window_name,this.options.window_features);k||(k=m);var v=setInterval(function(){m&&m.closed&&
+(d(!1),c&&(c(yg("USER_CANCELLED")),c=null))},500),y=B({a:"request",d:b});og(window,"unload",d);og(window,"message",e)}};
+zg.isAvailable=function(){return"postMessage"in window&&!lg()&&!(kg()||"undefined"!==typeof navigator&&(navigator.userAgent.match(/Windows Phone/)||window.Windows&&/^ms-appx:/.test(location.href))||"undefined"!==typeof navigator&&"undefined"!==typeof window&&(navigator.userAgent.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i)||navigator.userAgent.match(/CriOS/)||navigator.userAgent.match(/Twitter for iPhone/)||navigator.userAgent.match(/FBAN\/FBIOS/)||window.navigator.standalone))&&!("undefined"!==
+typeof navigator&&navigator.userAgent.match(/PhantomJS/))};zg.prototype.Bc=function(){return"popup"};function Ag(a){a.method||(a.method="GET");a.headers||(a.headers={});a.headers.content_type||(a.headers.content_type="application/json");a.headers.content_type=a.headers.content_type.toLowerCase();this.options=a}
+Ag.prototype.open=function(a,b,c){function d(){c&&(c(yg("REQUEST_INTERRUPTED")),c=null)}var e=new XMLHttpRequest,f=this.options.method.toUpperCase(),g;og(window,"beforeunload",d);e.onreadystatechange=function(){if(c&&4===e.readyState){var a;if(200<=e.status&&300>e.status){try{a=mb(e.responseText)}catch(b){}c(null,a)}else 500<=e.status&&600>e.status?c(yg("SERVER_ERROR")):c(yg("NETWORK_ERROR"));c=null;pg(window,"beforeunload",d)}};if("GET"===f)a+=(/\?/.test(a)?"":"?")+jb(b),g=null;else{var k=this.options.headers.content_type;
+"application/json"===k&&(g=B(b));"application/x-www-form-urlencoded"===k&&(g=jb(b))}e.open(f,a,!0);a={"X-Requested-With":"XMLHttpRequest",Accept:"application/json;text/plain"};za(a,this.options.headers);for(var l in a)e.setRequestHeader(l,a[l]);e.send(g)};Ag.isAvailable=function(){return!!window.XMLHttpRequest&&"string"===typeof(new XMLHttpRequest).responseType&&(!("undefined"!==typeof navigator&&(navigator.userAgent.match(/MSIE/)||navigator.userAgent.match(/Trident/)))||mg())};Ag.prototype.Bc=function(){return"json"};function Bg(a){this.oc=Ga()+Ga()+Ga();this.Df=a}
+Bg.prototype.open=function(a,b,c){function d(){c&&(c(yg("USER_CANCELLED")),c=null)}var e=this,f=Rc(fg),g;b.requestId=this.oc;b.redirectTo=f.scheme+"://"+f.host+"/blank/page.html";a+=/\?/.test(a)?"":"?";a+=jb(b);(g=window.open(a,"_blank","location=no"))&&ha(g.addEventListener)?(g.addEventListener("loadstart",function(a){var b;if(b=a&&a.url)a:{try{var m=document.createElement("a");m.href=a.url;b=m.host===f.host&&"/blank/page.html"===m.pathname;break a}catch(v){}b=!1}b&&(a=rg(a.url),g.removeEventListener("exit",
+d),g.close(),a=new gg(null,null,{requestId:e.oc,requestKey:a}),e.Df.requestWithCredential("/auth/session",a,c),c=null)}),g.addEventListener("exit",d)):c(yg("TRANSPORT_UNAVAILABLE"))};Bg.isAvailable=function(){return kg()};Bg.prototype.Bc=function(){return"redirect"};function Cg(a){a.callback_parameter||(a.callback_parameter="callback");this.options=a;window.__firebase_auth_jsonp=window.__firebase_auth_jsonp||{}}
+Cg.prototype.open=function(a,b,c){function d(){c&&(c(yg("REQUEST_INTERRUPTED")),c=null)}function e(){setTimeout(function(){window.__firebase_auth_jsonp[f]=void 0;wa(window.__firebase_auth_jsonp)&&(window.__firebase_auth_jsonp=void 0);try{var a=document.getElementById(f);a&&a.parentNode.removeChild(a)}catch(b){}},1);pg(window,"beforeunload",d)}var f="fn"+(new Date).getTime()+Math.floor(99999*Math.random());b[this.options.callback_parameter]="__firebase_auth_jsonp."+f;a+=(/\?/.test(a)?"":"?")+jb(b);
+og(window,"beforeunload",d);window.__firebase_auth_jsonp[f]=function(a){c&&(c(null,a),c=null);e()};Dg(f,a,c)};
+function Dg(a,b,c){setTimeout(function(){try{var d=document.createElement("script");d.type="text/javascript";d.id=a;d.async=!0;d.src=b;d.onerror=function(){var b=document.getElementById(a);null!==b&&b.parentNode.removeChild(b);c&&c(yg("NETWORK_ERROR"))};var e=document.getElementsByTagName("head");(e&&0!=e.length?e[0]:document.documentElement).appendChild(d)}catch(f){c&&c(yg("NETWORK_ERROR"))}},0)}Cg.isAvailable=function(){return!0};Cg.prototype.Bc=function(){return"json"};function Eg(a,b,c,d){If.call(this,["auth_status"]);this.H=a;this.df=b;this.Sg=c;this.Ke=d;this.rc=new jg(a,[Dc,P]);this.nb=null;this.Re=!1;Fg(this)}ma(Eg,If);h=Eg.prototype;h.we=function(){return this.nb||null};function Fg(a){P.get("redirect_request_id")&&Gg(a);var b=a.rc.get();b&&b.token?(Hg(a,b),a.df(b.token,function(c,d){Ig(a,c,d,!1,b.token,b)},function(b,d){Jg(a,"resumeSession()",b,d)})):Hg(a,null)}
+function Kg(a,b,c,d,e,f){"firebaseio-demo.com"===a.H.domain&&Q("Firebase authentication is not supported on demo Firebases (*.firebaseio-demo.com). To secure your Firebase, create a production Firebase at https://www.firebase.com.");a.df(b,function(f,k){Ig(a,f,k,!0,b,c,d||{},e)},function(b,c){Jg(a,"auth()",b,c,f)})}function Lg(a,b){a.rc.clear();Hg(a,null);a.Sg(function(a,d){if("ok"===a)R(b,null);else{var e=(a||"error").toUpperCase(),f=e;d&&(f+=": "+d);f=Error(f);f.code=e;R(b,f)}})}
+function Ig(a,b,c,d,e,f,g,k){"ok"===b?(d&&(b=c.auth,f.auth=b,f.expires=c.expires,f.token=cd(e)?e:"",c=null,b&&u(b,"uid")?c=w(b,"uid"):u(f,"uid")&&(c=w(f,"uid")),f.uid=c,c="custom",b&&u(b,"provider")?c=w(b,"provider"):u(f,"provider")&&(c=w(f,"provider")),f.provider=c,a.rc.clear(),cd(e)&&(g=g||{},c=Dc,"sessionOnly"===g.remember&&(c=P),"none"!==g.remember&&a.rc.set(f,c)),Hg(a,f)),R(k,null,f)):(a.rc.clear(),Hg(a,null),f=a=(b||"error").toUpperCase(),c&&(f+=": "+c),f=Error(f),f.code=a,R(k,f))}
+function Jg(a,b,c,d,e){Q(b+" was canceled: "+d);a.rc.clear();Hg(a,null);a=Error(d);a.code=c.toUpperCase();R(e,a)}function Mg(a,b,c,d,e){Ng(a);c=new gg(d||{},{},c||{});Og(a,[Ag,Cg],"/auth/"+b,c,e)}
+function Pg(a,b,c,d){Ng(a);var e=[zg,Bg];c=ig(c);"anonymous"===b||"password"===b?setTimeout(function(){R(d,yg("TRANSPORT_UNAVAILABLE"))},0):(c.ce.window_features="menubar=yes,modal=yes,alwaysRaised=yeslocation=yes,resizable=yes,scrollbars=yes,status=yes,height=625,width=625,top="+("object"===typeof screen?.5*(screen.height-625):0)+",left="+("object"===typeof screen?.5*(screen.width-625):0),c.ce.relay_url=tg(a.H.Cb),c.ce.requestWithCredential=q(a.pc,a),Og(a,e,"/auth/"+b,c,d))}
+function Gg(a){var b=P.get("redirect_request_id");if(b){var c=P.get("redirect_client_options");P.remove("redirect_request_id");P.remove("redirect_client_options");var d=[Ag,Cg],b={requestId:b,requestKey:rg(document.location.hash)},c=new gg(c,{},b);a.Re=!0;try{document.location.hash=document.location.hash.replace(/&__firebase_request_key=([a-zA-z0-9]*)/,"")}catch(e){}Og(a,d,"/auth/session",c,function(){this.Re=!1}.bind(a))}}
+h.re=function(a,b){Ng(this);var c=ig(a);c.ab._method="POST";this.pc("/users",c,function(a,c){a?R(b,a):R(b,a,c)})};h.Se=function(a,b){var c=this;Ng(this);var d="/users/"+encodeURIComponent(a.email),e=ig(a);e.ab._method="DELETE";this.pc(d,e,function(a,d){!a&&d&&d.uid&&c.nb&&c.nb.uid&&c.nb.uid===d.uid&&Lg(c);R(b,a)})};h.oe=function(a,b){Ng(this);var c="/users/"+encodeURIComponent(a.email)+"/password",d=ig(a);d.ab._method="PUT";d.ab.password=a.newPassword;this.pc(c,d,function(a){R(b,a)})};
+h.ne=function(a,b){Ng(this);var c="/users/"+encodeURIComponent(a.oldEmail)+"/email",d=ig(a);d.ab._method="PUT";d.ab.email=a.newEmail;d.ab.password=a.password;this.pc(c,d,function(a){R(b,a)})};h.Ue=function(a,b){Ng(this);var c="/users/"+encodeURIComponent(a.email)+"/password",d=ig(a);d.ab._method="POST";this.pc(c,d,function(a){R(b,a)})};h.pc=function(a,b,c){Qg(this,[Ag,Cg],a,b,c)};
+function Og(a,b,c,d,e){Qg(a,b,c,d,function(b,c){!b&&c&&c.token&&c.uid?Kg(a,c.token,c,d.ld,function(a,b){a?R(e,a):R(e,null,b)}):R(e,b||yg("UNKNOWN_ERROR"))})}
+function Qg(a,b,c,d,e){b=Pa(b,function(a){return"function"===typeof a.isAvailable&&a.isAvailable()});0===b.length?setTimeout(function(){R(e,yg("TRANSPORT_UNAVAILABLE"))},0):(b=new (b.shift())(d.ce),d=ib(d.ab),d.v="js-2.2.4",d.transport=b.Bc(),d.suppress_status_codes=!0,a=sg()+"/"+a.H.Cb+c,b.open(a,d,function(a,b){if(a)R(e,a);else if(b&&b.error){var c=Error(b.error.message);c.code=b.error.code;c.details=b.error.details;R(e,c)}else R(e,null,b)}))}
+function Hg(a,b){var c=null!==a.nb||null!==b;a.nb=b;c&&a.de("auth_status",b);a.Ke(null!==b)}h.ze=function(a){J("auth_status"===a,'initial event must be of type "auth_status"');return this.Re?null:[this.nb]};function Ng(a){var b=a.H;if("firebaseio.com"!==b.domain&&"firebaseio-demo.com"!==b.domain&&"auth.firebase.com"===fg)throw Error("This custom Firebase server ('"+a.H.domain+"') does not support delegated login.");};function Rg(a){this.hc=a;this.Kd=[];this.Qb=0;this.pe=-1;this.Fb=null}function Sg(a,b,c){a.pe=b;a.Fb=c;a.pe<a.Qb&&(a.Fb(),a.Fb=null)}function Tg(a,b,c){for(a.Kd[b]=c;a.Kd[a.Qb];){var d=a.Kd[a.Qb];delete a.Kd[a.Qb];for(var e=0;e<d.length;++e)if(d[e]){var f=a;Cb(function(){f.hc(d[e])})}if(a.Qb===a.pe){a.Fb&&(clearTimeout(a.Fb),a.Fb(),a.Fb=null);break}a.Qb++}};function Ug(a,b,c){this.qe=a;this.f=Oc(a);this.ob=this.pb=0;this.Va=Ob(b);this.Vd=c;this.Gc=!1;this.gd=function(a){b.host!==b.Oa&&(a.ns=b.Cb);var c=[],f;for(f in a)a.hasOwnProperty(f)&&c.push(f+"="+a[f]);return(b.lb?"https://":"http://")+b.Oa+"/.lp?"+c.join("&")}}var Vg,Wg;
+Ug.prototype.open=function(a,b){this.gf=0;this.ka=b;this.zf=new Rg(a);this.zb=!1;var c=this;this.rb=setTimeout(function(){c.f("Timed out trying to connect.");c.ib();c.rb=null},Math.floor(3E4));Tc(function(){if(!c.zb){c.Ta=new Xg(function(a,b,d,k,l){Yg(c,arguments);if(c.Ta)if(c.rb&&(clearTimeout(c.rb),c.rb=null),c.Gc=!0,"start"==a)c.id=b,c.Ff=d;else if("close"===a)b?(c.Ta.Td=!1,Sg(c.zf,b,function(){c.ib()})):c.ib();else throw Error("Unrecognized command received: "+a);},function(a,b){Yg(c,arguments);
+Tg(c.zf,a,b)},function(){c.ib()},c.gd);var a={start:"t"};a.ser=Math.floor(1E8*Math.random());c.Ta.fe&&(a.cb=c.Ta.fe);a.v="5";c.Vd&&(a.s=c.Vd);"undefined"!==typeof location&&location.href&&-1!==location.href.indexOf("firebaseio.com")&&(a.r="f");a=c.gd(a);c.f("Connecting via long-poll to "+a);Zg(c.Ta,a,function(){})}})};
+Ug.prototype.start=function(){var a=this.Ta,b=this.Ff;a.rg=this.id;a.sg=b;for(a.ke=!0;$g(a););a=this.id;b=this.Ff;this.fc=document.createElement("iframe");var c={dframe:"t"};c.id=a;c.pw=b;this.fc.src=this.gd(c);this.fc.style.display="none";document.body.appendChild(this.fc)};Ug.isAvailable=function(){return!Wg&&!("object"===typeof window&&window.chrome&&window.chrome.extension&&!/^chrome/.test(window.location.href))&&!("object"===typeof Windows&&"object"===typeof Windows.Ug)&&(Vg||!0)};h=Ug.prototype;
+h.Bd=function(){};h.cd=function(){this.zb=!0;this.Ta&&(this.Ta.close(),this.Ta=null);this.fc&&(document.body.removeChild(this.fc),this.fc=null);this.rb&&(clearTimeout(this.rb),this.rb=null)};h.ib=function(){this.zb||(this.f("Longpoll is closing itself"),this.cd(),this.ka&&(this.ka(this.Gc),this.ka=null))};h.close=function(){this.zb||(this.f("Longpoll is being closed."),this.cd())};
+h.send=function(a){a=B(a);this.pb+=a.length;Lb(this.Va,"bytes_sent",a.length);a=Kc(a);a=fb(a,!0);a=Xc(a,1840);for(var b=0;b<a.length;b++){var c=this.Ta;c.$c.push({Jg:this.gf,Rg:a.length,jf:a[b]});c.ke&&$g(c);this.gf++}};function Yg(a,b){var c=B(b).length;a.ob+=c;Lb(a.Va,"bytes_received",c)}
+function Xg(a,b,c,d){this.gd=d;this.jb=c;this.Oe=new cg;this.$c=[];this.se=Math.floor(1E8*Math.random());this.Td=!0;this.fe=Gc();window["pLPCommand"+this.fe]=a;window["pRTLPCB"+this.fe]=b;a=document.createElement("iframe");a.style.display="none";if(document.body){document.body.appendChild(a);try{a.contentWindow.document||Bb("No IE domain setting required")}catch(e){a.src="javascript:void((function(){document.open();document.domain='"+document.domain+"';document.close();})())"}}else throw"Document body has not initialized. Wait to initialize Firebase until after the document is ready.";
+a.contentDocument?a.gb=a.contentDocument:a.contentWindow?a.gb=a.contentWindow.document:a.document&&(a.gb=a.document);this.Ca=a;a="";this.Ca.src&&"javascript:"===this.Ca.src.substr(0,11)&&(a='<script>document.domain="'+document.domain+'";\x3c/script>');a="<html><body>"+a+"</body></html>";try{this.Ca.gb.open(),this.Ca.gb.write(a),this.Ca.gb.close()}catch(f){Bb("frame writing exception"),f.stack&&Bb(f.stack),Bb(f)}}
+Xg.prototype.close=function(){this.ke=!1;if(this.Ca){this.Ca.gb.body.innerHTML="";var a=this;setTimeout(function(){null!==a.Ca&&(document.body.removeChild(a.Ca),a.Ca=null)},Math.floor(0))}var b=this.jb;b&&(this.jb=null,b())};
+function $g(a){if(a.ke&&a.Td&&a.Oe.count()<(0<a.$c.length?2:1)){a.se++;var b={};b.id=a.rg;b.pw=a.sg;b.ser=a.se;for(var b=a.gd(b),c="",d=0;0<a.$c.length;)if(1870>=a.$c[0].jf.length+30+c.length){var e=a.$c.shift(),c=c+"&seg"+d+"="+e.Jg+"&ts"+d+"="+e.Rg+"&d"+d+"="+e.jf;d++}else break;ah(a,b+c,a.se);return!0}return!1}function ah(a,b,c){function d(){a.Oe.remove(c);$g(a)}a.Oe.add(c,1);var e=setTimeout(d,Math.floor(25E3));Zg(a,b,function(){clearTimeout(e);d()})}
+function Zg(a,b,c){setTimeout(function(){try{if(a.Td){var d=a.Ca.gb.createElement("script");d.type="text/javascript";d.async=!0;d.src=b;d.onload=d.onreadystatechange=function(){var a=d.readyState;a&&"loaded"!==a&&"complete"!==a||(d.onload=d.onreadystatechange=null,d.parentNode&&d.parentNode.removeChild(d),c())};d.onerror=function(){Bb("Long-poll script failed to load: "+b);a.Td=!1;a.close()};a.Ca.gb.body.appendChild(d)}}catch(e){}},Math.floor(1))};var bh=null;"undefined"!==typeof MozWebSocket?bh=MozWebSocket:"undefined"!==typeof WebSocket&&(bh=WebSocket);function ch(a,b,c){this.qe=a;this.f=Oc(this.qe);this.frames=this.Jc=null;this.ob=this.pb=this.bf=0;this.Va=Ob(b);this.fb=(b.lb?"wss://":"ws://")+b.Oa+"/.ws?v=5";"undefined"!==typeof location&&location.href&&-1!==location.href.indexOf("firebaseio.com")&&(this.fb+="&r=f");b.host!==b.Oa&&(this.fb=this.fb+"&ns="+b.Cb);c&&(this.fb=this.fb+"&s="+c)}var dh;
+ch.prototype.open=function(a,b){this.jb=b;this.wg=a;this.f("Websocket connecting to "+this.fb);this.Gc=!1;Dc.set("previous_websocket_failure",!0);try{this.va=new bh(this.fb)}catch(c){this.f("Error instantiating WebSocket.");var d=c.message||c.data;d&&this.f(d);this.ib();return}var e=this;this.va.onopen=function(){e.f("Websocket connected.");e.Gc=!0};this.va.onclose=function(){e.f("Websocket connection was disconnected.");e.va=null;e.ib()};this.va.onmessage=function(a){if(null!==e.va)if(a=a.data,e.ob+=
+a.length,Lb(e.Va,"bytes_received",a.length),eh(e),null!==e.frames)fh(e,a);else{a:{J(null===e.frames,"We already have a frame buffer");if(6>=a.length){var b=Number(a);if(!isNaN(b)){e.bf=b;e.frames=[];a=null;break a}}e.bf=1;e.frames=[]}null!==a&&fh(e,a)}};this.va.onerror=function(a){e.f("WebSocket error.  Closing connection.");(a=a.message||a.data)&&e.f(a);e.ib()}};ch.prototype.start=function(){};
+ch.isAvailable=function(){var a=!1;if("undefined"!==typeof navigator&&navigator.userAgent){var b=navigator.userAgent.match(/Android ([0-9]{0,}\.[0-9]{0,})/);b&&1<b.length&&4.4>parseFloat(b[1])&&(a=!0)}return!a&&null!==bh&&!dh};ch.responsesRequiredToBeHealthy=2;ch.healthyTimeout=3E4;h=ch.prototype;h.Bd=function(){Dc.remove("previous_websocket_failure")};function fh(a,b){a.frames.push(b);if(a.frames.length==a.bf){var c=a.frames.join("");a.frames=null;c=mb(c);a.wg(c)}}
+h.send=function(a){eh(this);a=B(a);this.pb+=a.length;Lb(this.Va,"bytes_sent",a.length);a=Xc(a,16384);1<a.length&&this.va.send(String(a.length));for(var b=0;b<a.length;b++)this.va.send(a[b])};h.cd=function(){this.zb=!0;this.Jc&&(clearInterval(this.Jc),this.Jc=null);this.va&&(this.va.close(),this.va=null)};h.ib=function(){this.zb||(this.f("WebSocket is closing itself"),this.cd(),this.jb&&(this.jb(this.Gc),this.jb=null))};h.close=function(){this.zb||(this.f("WebSocket is being closed"),this.cd())};
+function eh(a){clearInterval(a.Jc);a.Jc=setInterval(function(){a.va&&a.va.send("0");eh(a)},Math.floor(45E3))};function gh(a){hh(this,a)}var ih=[Ug,ch];function hh(a,b){var c=ch&&ch.isAvailable(),d=c&&!(Dc.uf||!0===Dc.get("previous_websocket_failure"));b.Tg&&(c||Q("wss:// URL used, but browser isn't known to support websockets.  Trying anyway."),d=!0);if(d)a.ed=[ch];else{var e=a.ed=[];Yc(ih,function(a,b){b&&b.isAvailable()&&e.push(b)})}}function jh(a){if(0<a.ed.length)return a.ed[0];throw Error("No transports available");};function kh(a,b,c,d,e,f){this.id=a;this.f=Oc("c:"+this.id+":");this.hc=c;this.Vc=d;this.ka=e;this.Me=f;this.H=b;this.Jd=[];this.ef=0;this.Nf=new gh(b);this.Ua=0;this.f("Connection created");lh(this)}
+function lh(a){var b=jh(a.Nf);a.L=new b("c:"+a.id+":"+a.ef++,a.H);a.Qe=b.responsesRequiredToBeHealthy||0;var c=mh(a,a.L),d=nh(a,a.L);a.fd=a.L;a.bd=a.L;a.F=null;a.Ab=!1;setTimeout(function(){a.L&&a.L.open(c,d)},Math.floor(0));b=b.healthyTimeout||0;0<b&&(a.vd=setTimeout(function(){a.vd=null;a.Ab||(a.L&&102400<a.L.ob?(a.f("Connection exceeded healthy timeout but has received "+a.L.ob+" bytes.  Marking connection healthy."),a.Ab=!0,a.L.Bd()):a.L&&10240<a.L.pb?a.f("Connection exceeded healthy timeout but has sent "+
+a.L.pb+" bytes.  Leaving connection alive."):(a.f("Closing unhealthy connection after timeout."),a.close()))},Math.floor(b)))}function nh(a,b){return function(c){b===a.L?(a.L=null,c||0!==a.Ua?1===a.Ua&&a.f("Realtime connection lost."):(a.f("Realtime connection failed."),"s-"===a.H.Oa.substr(0,2)&&(Dc.remove("host:"+a.H.host),a.H.Oa=a.H.host)),a.close()):b===a.F?(a.f("Secondary connection lost."),c=a.F,a.F=null,a.fd!==c&&a.bd!==c||a.close()):a.f("closing an old connection")}}
+function mh(a,b){return function(c){if(2!=a.Ua)if(b===a.bd){var d=Vc("t",c);c=Vc("d",c);if("c"==d){if(d=Vc("t",c),"d"in c)if(c=c.d,"h"===d){var d=c.ts,e=c.v,f=c.h;a.Vd=c.s;Fc(a.H,f);0==a.Ua&&(a.L.start(),oh(a,a.L,d),"5"!==e&&Q("Protocol version mismatch detected"),c=a.Nf,(c=1<c.ed.length?c.ed[1]:null)&&ph(a,c))}else if("n"===d){a.f("recvd end transmission on primary");a.bd=a.F;for(c=0;c<a.Jd.length;++c)a.Fd(a.Jd[c]);a.Jd=[];qh(a)}else"s"===d?(a.f("Connection shutdown command received. Shutting down..."),
+a.Me&&(a.Me(c),a.Me=null),a.ka=null,a.close()):"r"===d?(a.f("Reset packet received.  New host: "+c),Fc(a.H,c),1===a.Ua?a.close():(rh(a),lh(a))):"e"===d?Pc("Server Error: "+c):"o"===d?(a.f("got pong on primary."),sh(a),th(a)):Pc("Unknown control packet command: "+d)}else"d"==d&&a.Fd(c)}else if(b===a.F)if(d=Vc("t",c),c=Vc("d",c),"c"==d)"t"in c&&(c=c.t,"a"===c?uh(a):"r"===c?(a.f("Got a reset on secondary, closing it"),a.F.close(),a.fd!==a.F&&a.bd!==a.F||a.close()):"o"===c&&(a.f("got pong on secondary."),
+a.Lf--,uh(a)));else if("d"==d)a.Jd.push(c);else throw Error("Unknown protocol layer: "+d);else a.f("message on old connection")}}kh.prototype.Da=function(a){vh(this,{t:"d",d:a})};function qh(a){a.fd===a.F&&a.bd===a.F&&(a.f("cleaning up and promoting a connection: "+a.F.qe),a.L=a.F,a.F=null)}
+function uh(a){0>=a.Lf?(a.f("Secondary connection is healthy."),a.Ab=!0,a.F.Bd(),a.F.start(),a.f("sending client ack on secondary"),a.F.send({t:"c",d:{t:"a",d:{}}}),a.f("Ending transmission on primary"),a.L.send({t:"c",d:{t:"n",d:{}}}),a.fd=a.F,qh(a)):(a.f("sending ping on secondary."),a.F.send({t:"c",d:{t:"p",d:{}}}))}kh.prototype.Fd=function(a){sh(this);this.hc(a)};function sh(a){a.Ab||(a.Qe--,0>=a.Qe&&(a.f("Primary connection is healthy."),a.Ab=!0,a.L.Bd()))}
+function ph(a,b){a.F=new b("c:"+a.id+":"+a.ef++,a.H,a.Vd);a.Lf=b.responsesRequiredToBeHealthy||0;a.F.open(mh(a,a.F),nh(a,a.F));setTimeout(function(){a.F&&(a.f("Timed out trying to upgrade."),a.F.close())},Math.floor(6E4))}function oh(a,b,c){a.f("Realtime connection established.");a.L=b;a.Ua=1;a.Vc&&(a.Vc(c),a.Vc=null);0===a.Qe?(a.f("Primary connection is healthy."),a.Ab=!0):setTimeout(function(){th(a)},Math.floor(5E3))}
+function th(a){a.Ab||1!==a.Ua||(a.f("sending ping on primary."),vh(a,{t:"c",d:{t:"p",d:{}}}))}function vh(a,b){if(1!==a.Ua)throw"Connection is not connected";a.fd.send(b)}kh.prototype.close=function(){2!==this.Ua&&(this.f("Closing realtime connection."),this.Ua=2,rh(this),this.ka&&(this.ka(),this.ka=null))};function rh(a){a.f("Shutting down all connections");a.L&&(a.L.close(),a.L=null);a.F&&(a.F.close(),a.F=null);a.vd&&(clearTimeout(a.vd),a.vd=null)};function wh(a,b,c,d){this.id=xh++;this.f=Oc("p:"+this.id+":");this.wf=this.De=!1;this.aa={};this.pa=[];this.Xc=0;this.Uc=[];this.ma=!1;this.$a=1E3;this.Cd=3E5;this.Gb=b;this.Tc=c;this.Ne=d;this.H=a;this.We=null;this.Qd={};this.Ig=0;this.mf=!0;this.Kc=this.Fe=null;yh(this,0);Mf.ub().Eb("visible",this.zg,this);-1===a.host.indexOf("fblocal")&&Lf.ub().Eb("online",this.xg,this)}var xh=0,zh=0;h=wh.prototype;
+h.Da=function(a,b,c){var d=++this.Ig;a={r:d,a:a,b:b};this.f(B(a));J(this.ma,"sendRequest call when we're not connected not allowed.");this.Sa.Da(a);c&&(this.Qd[d]=c)};h.xf=function(a,b,c,d){var e=a.wa(),f=a.path.toString();this.f("Listen called for "+f+" "+e);this.aa[f]=this.aa[f]||{};J(!this.aa[f][e],"listen() called twice for same path/queryId.");a={J:d,ud:b,Fg:a,tag:c};this.aa[f][e]=a;this.ma&&Ah(this,a)};
+function Ah(a,b){var c=b.Fg,d=c.path.toString(),e=c.wa();a.f("Listen on "+d+" for "+e);var f={p:d};b.tag&&(f.q=ce(c.n),f.t=b.tag);f.h=b.ud();a.Da("q",f,function(f){var k=f.d,l=f.s;if(k&&"object"===typeof k&&u(k,"w")){var m=w(k,"w");ea(m)&&0<=Na(m,"no_index")&&Q("Using an unspecified index. Consider adding "+('".indexOn": "'+c.n.g.toString()+'"')+" at "+c.path.toString()+" to your security rules for better performance")}(a.aa[d]&&a.aa[d][e])===b&&(a.f("listen response",f),"ok"!==l&&Bh(a,d,e),b.J&&
+b.J(l,k))})}h.P=function(a,b,c){this.Fa={fg:a,nf:!1,yc:b,jd:c};this.f("Authenticating using credential: "+a);Ch(this);(b=40==a.length)||(a=ad(a).Ac,b="object"===typeof a&&!0===w(a,"admin"));b&&(this.f("Admin auth credential detected.  Reducing max reconnect time."),this.Cd=3E4)};h.ee=function(a){delete this.Fa;this.ma&&this.Da("unauth",{},function(b){a(b.s,b.d)})};
+function Ch(a){var b=a.Fa;a.ma&&b&&a.Da("auth",{cred:b.fg},function(c){var d=c.s;c=c.d||"error";"ok"!==d&&a.Fa===b&&delete a.Fa;b.nf?"ok"!==d&&b.jd&&b.jd(d,c):(b.nf=!0,b.yc&&b.yc(d,c))})}h.Of=function(a,b){var c=a.path.toString(),d=a.wa();this.f("Unlisten called for "+c+" "+d);if(Bh(this,c,d)&&this.ma){var e=ce(a.n);this.f("Unlisten on "+c+" for "+d);c={p:c};b&&(c.q=e,c.t=b);this.Da("n",c)}};h.Le=function(a,b,c){this.ma?Dh(this,"o",a,b,c):this.Uc.push({Zc:a,action:"o",data:b,J:c})};
+h.Bf=function(a,b,c){this.ma?Dh(this,"om",a,b,c):this.Uc.push({Zc:a,action:"om",data:b,J:c})};h.Gd=function(a,b){this.ma?Dh(this,"oc",a,null,b):this.Uc.push({Zc:a,action:"oc",data:null,J:b})};function Dh(a,b,c,d,e){c={p:c,d:d};a.f("onDisconnect "+b,c);a.Da(b,c,function(a){e&&setTimeout(function(){e(a.s,a.d)},Math.floor(0))})}h.put=function(a,b,c,d){Eh(this,"p",a,b,c,d)};h.yf=function(a,b,c,d){Eh(this,"m",a,b,c,d)};
+function Eh(a,b,c,d,e,f){d={p:c,d:d};n(f)&&(d.h=f);a.pa.push({action:b,If:d,J:e});a.Xc++;b=a.pa.length-1;a.ma?Fh(a,b):a.f("Buffering put: "+c)}function Fh(a,b){var c=a.pa[b].action,d=a.pa[b].If,e=a.pa[b].J;a.pa[b].Gg=a.ma;a.Da(c,d,function(d){a.f(c+" response",d);delete a.pa[b];a.Xc--;0===a.Xc&&(a.pa=[]);e&&e(d.s,d.d)})}h.Te=function(a){this.ma&&(a={c:a},this.f("reportStats",a),this.Da("s",a,function(a){"ok"!==a.s&&this.f("reportStats","Error sending stats: "+a.d)}))};
+h.Fd=function(a){if("r"in a){this.f("from server: "+B(a));var b=a.r,c=this.Qd[b];c&&(delete this.Qd[b],c(a.b))}else{if("error"in a)throw"A server-side error has occurred: "+a.error;"a"in a&&(b=a.a,c=a.b,this.f("handleServerMessage",b,c),"d"===b?this.Gb(c.p,c.d,!1,c.t):"m"===b?this.Gb(c.p,c.d,!0,c.t):"c"===b?Gh(this,c.p,c.q):"ac"===b?(a=c.s,b=c.d,c=this.Fa,delete this.Fa,c&&c.jd&&c.jd(a,b)):"sd"===b?this.We?this.We(c):"msg"in c&&"undefined"!==typeof console&&console.log("FIREBASE: "+c.msg.replace("\n",
+"\nFIREBASE: ")):Pc("Unrecognized action received from server: "+B(b)+"\nAre you using the latest client?"))}};h.Vc=function(a){this.f("connection ready");this.ma=!0;this.Kc=(new Date).getTime();this.Ne({serverTimeOffset:a-(new Date).getTime()});this.mf&&(a={},a["sdk.js."+"2.2.4".replace(/\./g,"-")]=1,kg()&&(a["framework.cordova"]=1),this.Te(a));Hh(this);this.mf=!1;this.Tc(!0)};
+function yh(a,b){J(!a.Sa,"Scheduling a connect when we're already connected/ing?");a.Sb&&clearTimeout(a.Sb);a.Sb=setTimeout(function(){a.Sb=null;Ih(a)},Math.floor(b))}h.zg=function(a){a&&!this.uc&&this.$a===this.Cd&&(this.f("Window became visible.  Reducing delay."),this.$a=1E3,this.Sa||yh(this,0));this.uc=a};h.xg=function(a){a?(this.f("Browser went online."),this.$a=1E3,this.Sa||yh(this,0)):(this.f("Browser went offline.  Killing connection."),this.Sa&&this.Sa.close())};
+h.Cf=function(){this.f("data client disconnected");this.ma=!1;this.Sa=null;for(var a=0;a<this.pa.length;a++){var b=this.pa[a];b&&"h"in b.If&&b.Gg&&(b.J&&b.J("disconnect"),delete this.pa[a],this.Xc--)}0===this.Xc&&(this.pa=[]);this.Qd={};Jh(this)&&(this.uc?this.Kc&&(3E4<(new Date).getTime()-this.Kc&&(this.$a=1E3),this.Kc=null):(this.f("Window isn't visible.  Delaying reconnect."),this.$a=this.Cd,this.Fe=(new Date).getTime()),a=Math.max(0,this.$a-((new Date).getTime()-this.Fe)),a*=Math.random(),this.f("Trying to reconnect in "+
+a+"ms"),yh(this,a),this.$a=Math.min(this.Cd,1.3*this.$a));this.Tc(!1)};function Ih(a){if(Jh(a)){a.f("Making a connection attempt");a.Fe=(new Date).getTime();a.Kc=null;var b=q(a.Fd,a),c=q(a.Vc,a),d=q(a.Cf,a),e=a.id+":"+zh++;a.Sa=new kh(e,a.H,b,c,d,function(b){Q(b+" ("+a.H.toString()+")");a.wf=!0})}}h.yb=function(){this.De=!0;this.Sa?this.Sa.close():(this.Sb&&(clearTimeout(this.Sb),this.Sb=null),this.ma&&this.Cf())};h.qc=function(){this.De=!1;this.$a=1E3;this.Sa||yh(this,0)};
+function Gh(a,b,c){c=c?Qa(c,function(a){return Wc(a)}).join("$"):"default";(a=Bh(a,b,c))&&a.J&&a.J("permission_denied")}function Bh(a,b,c){b=(new K(b)).toString();var d;n(a.aa[b])?(d=a.aa[b][c],delete a.aa[b][c],0===pa(a.aa[b])&&delete a.aa[b]):d=void 0;return d}function Hh(a){Ch(a);r(a.aa,function(b){r(b,function(b){Ah(a,b)})});for(var b=0;b<a.pa.length;b++)a.pa[b]&&Fh(a,b);for(;a.Uc.length;)b=a.Uc.shift(),Dh(a,b.action,b.Zc,b.data,b.J)}function Jh(a){var b;b=Lf.ub().ic;return!a.wf&&!a.De&&b};var V={lg:function(){Vg=dh=!0}};V.forceLongPolling=V.lg;V.mg=function(){Wg=!0};V.forceWebSockets=V.mg;V.Mg=function(a,b){a.k.Ra.We=b};V.setSecurityDebugCallback=V.Mg;V.Ye=function(a,b){a.k.Ye(b)};V.stats=V.Ye;V.Ze=function(a,b){a.k.Ze(b)};V.statsIncrementCounter=V.Ze;V.pd=function(a){return a.k.pd};V.dataUpdateCount=V.pd;V.pg=function(a,b){a.k.Ce=b};V.interceptServerData=V.pg;V.vg=function(a){new ug(a)};V.onPopupOpen=V.vg;V.Kg=function(a){fg=a};V.setAuthenticationServer=V.Kg;function S(a,b,c){this.B=a;this.V=b;this.g=c}S.prototype.K=function(){x("Firebase.DataSnapshot.val",0,0,arguments.length);return this.B.K()};S.prototype.val=S.prototype.K;S.prototype.lf=function(){x("Firebase.DataSnapshot.exportVal",0,0,arguments.length);return this.B.K(!0)};S.prototype.exportVal=S.prototype.lf;S.prototype.kg=function(){x("Firebase.DataSnapshot.exists",0,0,arguments.length);return!this.B.e()};S.prototype.exists=S.prototype.kg;
+S.prototype.w=function(a){x("Firebase.DataSnapshot.child",0,1,arguments.length);ga(a)&&(a=String(a));Xf("Firebase.DataSnapshot.child",a);var b=new K(a),c=this.V.w(b);return new S(this.B.oa(b),c,M)};S.prototype.child=S.prototype.w;S.prototype.Ha=function(a){x("Firebase.DataSnapshot.hasChild",1,1,arguments.length);Xf("Firebase.DataSnapshot.hasChild",a);var b=new K(a);return!this.B.oa(b).e()};S.prototype.hasChild=S.prototype.Ha;
+S.prototype.A=function(){x("Firebase.DataSnapshot.getPriority",0,0,arguments.length);return this.B.A().K()};S.prototype.getPriority=S.prototype.A;S.prototype.forEach=function(a){x("Firebase.DataSnapshot.forEach",1,1,arguments.length);A("Firebase.DataSnapshot.forEach",1,a,!1);if(this.B.N())return!1;var b=this;return!!this.B.U(this.g,function(c,d){return a(new S(d,b.V.w(c),M))})};S.prototype.forEach=S.prototype.forEach;
+S.prototype.td=function(){x("Firebase.DataSnapshot.hasChildren",0,0,arguments.length);return this.B.N()?!1:!this.B.e()};S.prototype.hasChildren=S.prototype.td;S.prototype.name=function(){Q("Firebase.DataSnapshot.name() being deprecated. Please use Firebase.DataSnapshot.key() instead.");x("Firebase.DataSnapshot.name",0,0,arguments.length);return this.key()};S.prototype.name=S.prototype.name;S.prototype.key=function(){x("Firebase.DataSnapshot.key",0,0,arguments.length);return this.V.key()};
+S.prototype.key=S.prototype.key;S.prototype.Db=function(){x("Firebase.DataSnapshot.numChildren",0,0,arguments.length);return this.B.Db()};S.prototype.numChildren=S.prototype.Db;S.prototype.lc=function(){x("Firebase.DataSnapshot.ref",0,0,arguments.length);return this.V};S.prototype.ref=S.prototype.lc;function Kh(a,b){this.H=a;this.Va=Ob(a);this.ea=new ub;this.Ed=1;this.Ra=null;b||0<=("object"===typeof window&&window.navigator&&window.navigator.userAgent||"").search(/googlebot|google webmaster tools|bingbot|yahoo! slurp|baiduspider|yandexbot|duckduckbot/i)?(this.ca=new Ae(this.H,q(this.Gb,this)),setTimeout(q(this.Tc,this,!0),0)):this.ca=this.Ra=new wh(this.H,q(this.Gb,this),q(this.Tc,this),q(this.Ne,this));this.Pg=Pb(a,q(function(){return new Jb(this.Va,this.ca)},this));this.tc=new Cf;this.Be=
+new nb;var c=this;this.zd=new gf({Xe:function(a,b,f,g){b=[];f=c.Be.j(a.path);f.e()||(b=jf(c.zd,new Ub(ze,a.path,f)),setTimeout(function(){g("ok")},0));return b},Zd:ba});Lh(this,"connected",!1);this.ka=new qc;this.P=new Eg(a,q(this.ca.P,this.ca),q(this.ca.ee,this.ca),q(this.Ke,this));this.pd=0;this.Ce=null;this.O=new gf({Xe:function(a,b,f,g){c.ca.xf(a,f,b,function(b,e){var f=g(b,e);zb(c.ea,a.path,f)});return[]},Zd:function(a,b){c.ca.Of(a,b)}})}h=Kh.prototype;
+h.toString=function(){return(this.H.lb?"https://":"http://")+this.H.host};h.name=function(){return this.H.Cb};function Mh(a){a=a.Be.j(new K(".info/serverTimeOffset")).K()||0;return(new Date).getTime()+a}function Nh(a){a=a={timestamp:Mh(a)};a.timestamp=a.timestamp||(new Date).getTime();return a}
+h.Gb=function(a,b,c,d){this.pd++;var e=new K(a);b=this.Ce?this.Ce(a,b):b;a=[];d?c?(b=na(b,function(a){return L(a)}),a=rf(this.O,e,b,d)):(b=L(b),a=nf(this.O,e,b,d)):c?(d=na(b,function(a){return L(a)}),a=mf(this.O,e,d)):(d=L(b),a=jf(this.O,new Ub(ze,e,d)));d=e;0<a.length&&(d=Oh(this,e));zb(this.ea,d,a)};h.Tc=function(a){Lh(this,"connected",a);!1===a&&Ph(this)};h.Ne=function(a){var b=this;Yc(a,function(a,d){Lh(b,d,a)})};h.Ke=function(a){Lh(this,"authenticated",a)};
+function Lh(a,b,c){b=new K("/.info/"+b);c=L(c);var d=a.Be;d.Sd=d.Sd.G(b,c);c=jf(a.zd,new Ub(ze,b,c));zb(a.ea,b,c)}h.Kb=function(a,b,c,d){this.f("set",{path:a.toString(),value:b,Xg:c});var e=Nh(this);b=L(b,c);var e=sc(b,e),f=this.Ed++,e=hf(this.O,a,e,f,!0);vb(this.ea,e);var g=this;this.ca.put(a.toString(),b.K(!0),function(b,c){var e="ok"===b;e||Q("set at "+a+" failed: "+b);e=lf(g.O,f,!e);zb(g.ea,a,e);Qh(d,b,c)});e=Rh(this,a);Oh(this,e);zb(this.ea,e,[])};
+h.update=function(a,b,c){this.f("update",{path:a.toString(),value:b});var d=!0,e=Nh(this),f={};r(b,function(a,b){d=!1;var c=L(a);f[b]=sc(c,e)});if(d)Bb("update() called with empty data.  Don't do anything."),Qh(c,"ok");else{var g=this.Ed++,k=kf(this.O,a,f,g);vb(this.ea,k);var l=this;this.ca.yf(a.toString(),b,function(b,d){var e="ok"===b;e||Q("update at "+a+" failed: "+b);var e=lf(l.O,g,!e),f=a;0<e.length&&(f=Oh(l,a));zb(l.ea,f,e);Qh(c,b,d)});b=Rh(this,a);Oh(this,b);zb(this.ea,a,[])}};
+function Ph(a){a.f("onDisconnectEvents");var b=Nh(a),c=[];rc(pc(a.ka,b),F,function(b,e){c=c.concat(jf(a.O,new Ub(ze,b,e)));var f=Rh(a,b);Oh(a,f)});a.ka=new qc;zb(a.ea,F,c)}h.Gd=function(a,b){var c=this;this.ca.Gd(a.toString(),function(d,e){"ok"===d&&eg(c.ka,a);Qh(b,d,e)})};function Sh(a,b,c,d){var e=L(c);a.ca.Le(b.toString(),e.K(!0),function(c,g){"ok"===c&&a.ka.mc(b,e);Qh(d,c,g)})}function Th(a,b,c,d,e){var f=L(c,d);a.ca.Le(b.toString(),f.K(!0),function(c,d){"ok"===c&&a.ka.mc(b,f);Qh(e,c,d)})}
+function Uh(a,b,c,d){var e=!0,f;for(f in c)e=!1;e?(Bb("onDisconnect().update() called with empty data.  Don't do anything."),Qh(d,"ok")):a.ca.Bf(b.toString(),c,function(e,f){if("ok"===e)for(var l in c){var m=L(c[l]);a.ka.mc(b.w(l),m)}Qh(d,e,f)})}function Vh(a,b,c){c=".info"===O(b.path)?a.zd.Ob(b,c):a.O.Ob(b,c);xb(a.ea,b.path,c)}h.yb=function(){this.Ra&&this.Ra.yb()};h.qc=function(){this.Ra&&this.Ra.qc()};
+h.Ye=function(a){if("undefined"!==typeof console){a?(this.Yd||(this.Yd=new Ib(this.Va)),a=this.Yd.get()):a=this.Va.get();var b=Ra(sa(a),function(a,b){return Math.max(b.length,a)},0),c;for(c in a){for(var d=a[c],e=c.length;e<b+2;e++)c+=" ";console.log(c+d)}}};h.Ze=function(a){Lb(this.Va,a);this.Pg.Mf[a]=!0};h.f=function(a){var b="";this.Ra&&(b=this.Ra.id+":");Bb(b,arguments)};
+function Qh(a,b,c){a&&Cb(function(){if("ok"==b)a(null);else{var d=(b||"error").toUpperCase(),e=d;c&&(e+=": "+c);e=Error(e);e.code=d;a(e)}})};function Wh(a,b,c,d,e){function f(){}a.f("transaction on "+b);var g=new U(a,b);g.Eb("value",f);c={path:b,update:c,J:d,status:null,Ef:Gc(),cf:e,Kf:0,ge:function(){g.gc("value",f)},je:null,Aa:null,md:null,nd:null,od:null};d=a.O.ua(b,void 0)||C;c.md=d;d=c.update(d.K());if(n(d)){Sf("transaction failed: Data returned ",d,c.path);c.status=1;e=Df(a.tc,b);var k=e.Ba()||[];k.push(c);Ef(e,k);"object"===typeof d&&null!==d&&u(d,".priority")?(k=w(d,".priority"),J(Qf(k),"Invalid priority returned by transaction. Priority must be a valid string, finite number, server value, or null.")):
+k=(a.O.ua(b)||C).A().K();e=Nh(a);d=L(d,k);e=sc(d,e);c.nd=d;c.od=e;c.Aa=a.Ed++;c=hf(a.O,b,e,c.Aa,c.cf);zb(a.ea,b,c);Xh(a)}else c.ge(),c.nd=null,c.od=null,c.J&&(a=new S(c.md,new U(a,c.path),M),c.J(null,!1,a))}function Xh(a,b){var c=b||a.tc;b||Yh(a,c);if(null!==c.Ba()){var d=Zh(a,c);J(0<d.length,"Sending zero length transaction queue");Sa(d,function(a){return 1===a.status})&&$h(a,c.path(),d)}else c.td()&&c.U(function(b){Xh(a,b)})}
+function $h(a,b,c){for(var d=Qa(c,function(a){return a.Aa}),e=a.O.ua(b,d)||C,d=e,e=e.hash(),f=0;f<c.length;f++){var g=c[f];J(1===g.status,"tryToSendTransactionQueue_: items in queue should all be run.");g.status=2;g.Kf++;var k=N(b,g.path),d=d.G(k,g.nd)}d=d.K(!0);a.ca.put(b.toString(),d,function(d){a.f("transaction put response",{path:b.toString(),status:d});var e=[];if("ok"===d){d=[];for(f=0;f<c.length;f++){c[f].status=3;e=e.concat(lf(a.O,c[f].Aa));if(c[f].J){var g=c[f].od,k=new U(a,c[f].path);d.push(q(c[f].J,
+null,null,!0,new S(g,k,M)))}c[f].ge()}Yh(a,Df(a.tc,b));Xh(a);zb(a.ea,b,e);for(f=0;f<d.length;f++)Cb(d[f])}else{if("datastale"===d)for(f=0;f<c.length;f++)c[f].status=4===c[f].status?5:1;else for(Q("transaction at "+b.toString()+" failed: "+d),f=0;f<c.length;f++)c[f].status=5,c[f].je=d;Oh(a,b)}},e)}function Oh(a,b){var c=ai(a,b),d=c.path(),c=Zh(a,c);bi(a,c,d);return d}
+function bi(a,b,c){if(0!==b.length){for(var d=[],e=[],f=Qa(b,function(a){return a.Aa}),g=0;g<b.length;g++){var k=b[g],l=N(c,k.path),m=!1,v;J(null!==l,"rerunTransactionsUnderNode_: relativePath should not be null.");if(5===k.status)m=!0,v=k.je,e=e.concat(lf(a.O,k.Aa,!0));else if(1===k.status)if(25<=k.Kf)m=!0,v="maxretry",e=e.concat(lf(a.O,k.Aa,!0));else{var y=a.O.ua(k.path,f)||C;k.md=y;var I=b[g].update(y.K());n(I)?(Sf("transaction failed: Data returned ",I,k.path),l=L(I),"object"===typeof I&&null!=
+I&&u(I,".priority")||(l=l.da(y.A())),y=k.Aa,I=Nh(a),I=sc(l,I),k.nd=l,k.od=I,k.Aa=a.Ed++,Va(f,y),e=e.concat(hf(a.O,k.path,I,k.Aa,k.cf)),e=e.concat(lf(a.O,y,!0))):(m=!0,v="nodata",e=e.concat(lf(a.O,k.Aa,!0)))}zb(a.ea,c,e);e=[];m&&(b[g].status=3,setTimeout(b[g].ge,Math.floor(0)),b[g].J&&("nodata"===v?(k=new U(a,b[g].path),d.push(q(b[g].J,null,null,!1,new S(b[g].md,k,M)))):d.push(q(b[g].J,null,Error(v),!1,null))))}Yh(a,a.tc);for(g=0;g<d.length;g++)Cb(d[g]);Xh(a)}}
+function ai(a,b){for(var c,d=a.tc;null!==(c=O(b))&&null===d.Ba();)d=Df(d,c),b=G(b);return d}function Zh(a,b){var c=[];ci(a,b,c);c.sort(function(a,b){return a.Ef-b.Ef});return c}function ci(a,b,c){var d=b.Ba();if(null!==d)for(var e=0;e<d.length;e++)c.push(d[e]);b.U(function(b){ci(a,b,c)})}function Yh(a,b){var c=b.Ba();if(c){for(var d=0,e=0;e<c.length;e++)3!==c[e].status&&(c[d]=c[e],d++);c.length=d;Ef(b,0<c.length?c:null)}b.U(function(b){Yh(a,b)})}
+function Rh(a,b){var c=ai(a,b).path(),d=Df(a.tc,b);Hf(d,function(b){di(a,b)});di(a,d);Gf(d,function(b){di(a,b)});return c}
+function di(a,b){var c=b.Ba();if(null!==c){for(var d=[],e=[],f=-1,g=0;g<c.length;g++)4!==c[g].status&&(2===c[g].status?(J(f===g-1,"All SENT items should be at beginning of queue."),f=g,c[g].status=4,c[g].je="set"):(J(1===c[g].status,"Unexpected transaction status in abort"),c[g].ge(),e=e.concat(lf(a.O,c[g].Aa,!0)),c[g].J&&d.push(q(c[g].J,null,Error("set"),!1,null))));-1===f?Ef(b,null):c.length=f+1;zb(a.ea,b.path(),e);for(g=0;g<d.length;g++)Cb(d[g])}};function W(){this.nc={};this.Pf=!1}ca(W);W.prototype.yb=function(){for(var a in this.nc)this.nc[a].yb()};W.prototype.interrupt=W.prototype.yb;W.prototype.qc=function(){for(var a in this.nc)this.nc[a].qc()};W.prototype.resume=W.prototype.qc;W.prototype.ue=function(){this.Pf=!0};function X(a,b){this.ad=a;this.qa=b}X.prototype.cancel=function(a){x("Firebase.onDisconnect().cancel",0,1,arguments.length);A("Firebase.onDisconnect().cancel",1,a,!0);this.ad.Gd(this.qa,a||null)};X.prototype.cancel=X.prototype.cancel;X.prototype.remove=function(a){x("Firebase.onDisconnect().remove",0,1,arguments.length);Yf("Firebase.onDisconnect().remove",this.qa);A("Firebase.onDisconnect().remove",1,a,!0);Sh(this.ad,this.qa,null,a)};X.prototype.remove=X.prototype.remove;
+X.prototype.set=function(a,b){x("Firebase.onDisconnect().set",1,2,arguments.length);Yf("Firebase.onDisconnect().set",this.qa);Rf("Firebase.onDisconnect().set",a,this.qa,!1);A("Firebase.onDisconnect().set",2,b,!0);Sh(this.ad,this.qa,a,b)};X.prototype.set=X.prototype.set;
+X.prototype.Kb=function(a,b,c){x("Firebase.onDisconnect().setWithPriority",2,3,arguments.length);Yf("Firebase.onDisconnect().setWithPriority",this.qa);Rf("Firebase.onDisconnect().setWithPriority",a,this.qa,!1);Uf("Firebase.onDisconnect().setWithPriority",2,b);A("Firebase.onDisconnect().setWithPriority",3,c,!0);Th(this.ad,this.qa,a,b,c)};X.prototype.setWithPriority=X.prototype.Kb;
+X.prototype.update=function(a,b){x("Firebase.onDisconnect().update",1,2,arguments.length);Yf("Firebase.onDisconnect().update",this.qa);if(ea(a)){for(var c={},d=0;d<a.length;++d)c[""+d]=a[d];a=c;Q("Passing an Array to Firebase.onDisconnect().update() is deprecated. Use set() if you want to overwrite the existing data, or an Object with integer keys if you really do want to only update some of the children.")}Tf("Firebase.onDisconnect().update",a,this.qa);A("Firebase.onDisconnect().update",2,b,!0);
+Uh(this.ad,this.qa,a,b)};X.prototype.update=X.prototype.update;function Y(a,b,c,d){this.k=a;this.path=b;this.n=c;this.jc=d}
+function ei(a){var b=null,c=null;a.la&&(b=od(a));a.na&&(c=qd(a));if(a.g===Vd){if(a.la){if("[MIN_NAME]"!=nd(a))throw Error("Query: When ordering by key, you may only pass one argument to startAt(), endAt(), or equalTo().");if("string"!==typeof b)throw Error("Query: When ordering by key, the argument passed to startAt(), endAt(),or equalTo() must be a string.");}if(a.na){if("[MAX_NAME]"!=pd(a))throw Error("Query: When ordering by key, you may only pass one argument to startAt(), endAt(), or equalTo().");if("string"!==
+typeof c)throw Error("Query: When ordering by key, the argument passed to startAt(), endAt(),or equalTo() must be a string.");}}else if(a.g===M){if(null!=b&&!Qf(b)||null!=c&&!Qf(c))throw Error("Query: When ordering by priority, the first argument passed to startAt(), endAt(), or equalTo() must be a valid priority value (null, a number, or a string).");}else if(J(a.g instanceof Rd||a.g===Yd,"unknown index type."),null!=b&&"object"===typeof b||null!=c&&"object"===typeof c)throw Error("Query: First argument passed to startAt(), endAt(), or equalTo() cannot be an object.");
+}function fi(a){if(a.la&&a.na&&a.ia&&(!a.ia||""===a.Nb))throw Error("Query: Can't combine startAt(), endAt(), and limit(). Use limitToFirst() or limitToLast() instead.");}function gi(a,b){if(!0===a.jc)throw Error(b+": You can't combine multiple orderBy calls.");}Y.prototype.lc=function(){x("Query.ref",0,0,arguments.length);return new U(this.k,this.path)};Y.prototype.ref=Y.prototype.lc;
+Y.prototype.Eb=function(a,b,c,d){x("Query.on",2,4,arguments.length);Vf("Query.on",a,!1);A("Query.on",2,b,!1);var e=hi("Query.on",c,d);if("value"===a)Vh(this.k,this,new jd(b,e.cancel||null,e.Ma||null));else{var f={};f[a]=b;Vh(this.k,this,new kd(f,e.cancel,e.Ma))}return b};Y.prototype.on=Y.prototype.Eb;
+Y.prototype.gc=function(a,b,c){x("Query.off",0,3,arguments.length);Vf("Query.off",a,!0);A("Query.off",2,b,!0);lb("Query.off",3,c);var d=null,e=null;"value"===a?d=new jd(b||null,null,c||null):a&&(b&&(e={},e[a]=b),d=new kd(e,null,c||null));e=this.k;d=".info"===O(this.path)?e.zd.kb(this,d):e.O.kb(this,d);xb(e.ea,this.path,d)};Y.prototype.off=Y.prototype.gc;
+Y.prototype.Ag=function(a,b){function c(g){f&&(f=!1,e.gc(a,c),b.call(d.Ma,g))}x("Query.once",2,4,arguments.length);Vf("Query.once",a,!1);A("Query.once",2,b,!1);var d=hi("Query.once",arguments[2],arguments[3]),e=this,f=!0;this.Eb(a,c,function(b){e.gc(a,c);d.cancel&&d.cancel.call(d.Ma,b)})};Y.prototype.once=Y.prototype.Ag;
+Y.prototype.Ge=function(a){Q("Query.limit() being deprecated. Please use Query.limitToFirst() or Query.limitToLast() instead.");x("Query.limit",1,1,arguments.length);if(!ga(a)||Math.floor(a)!==a||0>=a)throw Error("Query.limit: First argument must be a positive integer.");if(this.n.ia)throw Error("Query.limit: Limit was already set (by another call to limit, limitToFirst, orlimitToLast.");var b=this.n.Ge(a);fi(b);return new Y(this.k,this.path,b,this.jc)};Y.prototype.limit=Y.prototype.Ge;
+Y.prototype.He=function(a){x("Query.limitToFirst",1,1,arguments.length);if(!ga(a)||Math.floor(a)!==a||0>=a)throw Error("Query.limitToFirst: First argument must be a positive integer.");if(this.n.ia)throw Error("Query.limitToFirst: Limit was already set (by another call to limit, limitToFirst, or limitToLast).");return new Y(this.k,this.path,this.n.He(a),this.jc)};Y.prototype.limitToFirst=Y.prototype.He;
+Y.prototype.Ie=function(a){x("Query.limitToLast",1,1,arguments.length);if(!ga(a)||Math.floor(a)!==a||0>=a)throw Error("Query.limitToLast: First argument must be a positive integer.");if(this.n.ia)throw Error("Query.limitToLast: Limit was already set (by another call to limit, limitToFirst, or limitToLast).");return new Y(this.k,this.path,this.n.Ie(a),this.jc)};Y.prototype.limitToLast=Y.prototype.Ie;
+Y.prototype.Bg=function(a){x("Query.orderByChild",1,1,arguments.length);if("$key"===a)throw Error('Query.orderByChild: "$key" is invalid.  Use Query.orderByKey() instead.');if("$priority"===a)throw Error('Query.orderByChild: "$priority" is invalid.  Use Query.orderByPriority() instead.');if("$value"===a)throw Error('Query.orderByChild: "$value" is invalid.  Use Query.orderByValue() instead.');Wf("Query.orderByChild",1,a,!1);gi(this,"Query.orderByChild");var b=be(this.n,new Rd(a));ei(b);return new Y(this.k,
+this.path,b,!0)};Y.prototype.orderByChild=Y.prototype.Bg;Y.prototype.Cg=function(){x("Query.orderByKey",0,0,arguments.length);gi(this,"Query.orderByKey");var a=be(this.n,Vd);ei(a);return new Y(this.k,this.path,a,!0)};Y.prototype.orderByKey=Y.prototype.Cg;Y.prototype.Dg=function(){x("Query.orderByPriority",0,0,arguments.length);gi(this,"Query.orderByPriority");var a=be(this.n,M);ei(a);return new Y(this.k,this.path,a,!0)};Y.prototype.orderByPriority=Y.prototype.Dg;
+Y.prototype.Eg=function(){x("Query.orderByValue",0,0,arguments.length);gi(this,"Query.orderByValue");var a=be(this.n,Yd);ei(a);return new Y(this.k,this.path,a,!0)};Y.prototype.orderByValue=Y.prototype.Eg;
+Y.prototype.Xd=function(a,b){x("Query.startAt",0,2,arguments.length);Rf("Query.startAt",a,this.path,!0);Wf("Query.startAt",2,b,!0);var c=this.n.Xd(a,b);fi(c);ei(c);if(this.n.la)throw Error("Query.startAt: Starting point was already set (by another call to startAt or equalTo).");n(a)||(b=a=null);return new Y(this.k,this.path,c,this.jc)};Y.prototype.startAt=Y.prototype.Xd;
+Y.prototype.qd=function(a,b){x("Query.endAt",0,2,arguments.length);Rf("Query.endAt",a,this.path,!0);Wf("Query.endAt",2,b,!0);var c=this.n.qd(a,b);fi(c);ei(c);if(this.n.na)throw Error("Query.endAt: Ending point was already set (by another call to endAt or equalTo).");return new Y(this.k,this.path,c,this.jc)};Y.prototype.endAt=Y.prototype.qd;
+Y.prototype.hg=function(a,b){x("Query.equalTo",1,2,arguments.length);Rf("Query.equalTo",a,this.path,!1);Wf("Query.equalTo",2,b,!0);if(this.n.la)throw Error("Query.equalTo: Starting point was already set (by another call to endAt or equalTo).");if(this.n.na)throw Error("Query.equalTo: Ending point was already set (by another call to endAt or equalTo).");return this.Xd(a,b).qd(a,b)};Y.prototype.equalTo=Y.prototype.hg;
+Y.prototype.toString=function(){x("Query.toString",0,0,arguments.length);for(var a=this.path,b="",c=a.Y;c<a.o.length;c++)""!==a.o[c]&&(b+="/"+encodeURIComponent(String(a.o[c])));a=this.k.toString()+(b||"/");b=jb(ee(this.n));return a+=b.replace(/^&/,"")};Y.prototype.toString=Y.prototype.toString;Y.prototype.wa=function(){var a=Wc(ce(this.n));return"{}"===a?"default":a};
+function hi(a,b,c){var d={cancel:null,Ma:null};if(b&&c)d.cancel=b,A(a,3,d.cancel,!0),d.Ma=c,lb(a,4,d.Ma);else if(b)if("object"===typeof b&&null!==b)d.Ma=b;else if("function"===typeof b)d.cancel=b;else throw Error(z(a,3,!0)+" must either be a cancel callback or a context object.");return d};var Z={};Z.vc=wh;Z.DataConnection=Z.vc;wh.prototype.Og=function(a,b){this.Da("q",{p:a},b)};Z.vc.prototype.simpleListen=Z.vc.prototype.Og;wh.prototype.gg=function(a,b){this.Da("echo",{d:a},b)};Z.vc.prototype.echo=Z.vc.prototype.gg;wh.prototype.interrupt=wh.prototype.yb;Z.Sf=kh;Z.RealTimeConnection=Z.Sf;kh.prototype.sendRequest=kh.prototype.Da;kh.prototype.close=kh.prototype.close;
+Z.og=function(a){var b=wh.prototype.put;wh.prototype.put=function(c,d,e,f){n(f)&&(f=a());b.call(this,c,d,e,f)};return function(){wh.prototype.put=b}};Z.hijackHash=Z.og;Z.Rf=Ec;Z.ConnectionTarget=Z.Rf;Z.wa=function(a){return a.wa()};Z.queryIdentifier=Z.wa;Z.qg=function(a){return a.k.Ra.aa};Z.listens=Z.qg;Z.ue=function(a){a.ue()};Z.forceRestClient=Z.ue;function U(a,b){var c,d,e;if(a instanceof Kh)c=a,d=b;else{x("new Firebase",1,2,arguments.length);d=Rc(arguments[0]);c=d.Qg;"firebase"===d.domain&&Qc(d.host+" is no longer supported. Please use <YOUR FIREBASE>.firebaseio.com instead");c||Qc("Cannot parse Firebase url. Please use https://<YOUR FIREBASE>.firebaseio.com");d.lb||"undefined"!==typeof window&&window.location&&window.location.protocol&&-1!==window.location.protocol.indexOf("https:")&&Q("Insecure Firebase access from a secure page. Please use https in calls to new Firebase().");
+c=new Ec(d.host,d.lb,c,"ws"===d.scheme||"wss"===d.scheme);d=new K(d.Zc);e=d.toString();var f;!(f=!p(c.host)||0===c.host.length||!Pf(c.Cb))&&(f=0!==e.length)&&(e&&(e=e.replace(/^\/*\.info(\/|$)/,"/")),f=!(p(e)&&0!==e.length&&!Of.test(e)));if(f)throw Error(z("new Firebase",1,!1)+'must be a valid firebase URL and the path can\'t contain ".", "#", "$", "[", or "]".');if(b)if(b instanceof W)e=b;else if(p(b))e=W.ub(),c.Ld=b;else throw Error("Expected a valid Firebase.Context for second argument to new Firebase()");
+else e=W.ub();f=c.toString();var g=w(e.nc,f);g||(g=new Kh(c,e.Pf),e.nc[f]=g);c=g}Y.call(this,c,d,$d,!1)}ma(U,Y);var ii=U,ji=["Firebase"],ki=aa;ji[0]in ki||!ki.execScript||ki.execScript("var "+ji[0]);for(var li;ji.length&&(li=ji.shift());)!ji.length&&n(ii)?ki[li]=ii:ki=ki[li]?ki[li]:ki[li]={};U.prototype.name=function(){Q("Firebase.name() being deprecated. Please use Firebase.key() instead.");x("Firebase.name",0,0,arguments.length);return this.key()};U.prototype.name=U.prototype.name;
+U.prototype.key=function(){x("Firebase.key",0,0,arguments.length);return this.path.e()?null:vc(this.path)};U.prototype.key=U.prototype.key;U.prototype.w=function(a){x("Firebase.child",1,1,arguments.length);if(ga(a))a=String(a);else if(!(a instanceof K))if(null===O(this.path)){var b=a;b&&(b=b.replace(/^\/*\.info(\/|$)/,"/"));Xf("Firebase.child",b)}else Xf("Firebase.child",a);return new U(this.k,this.path.w(a))};U.prototype.child=U.prototype.w;
+U.prototype.parent=function(){x("Firebase.parent",0,0,arguments.length);var a=this.path.parent();return null===a?null:new U(this.k,a)};U.prototype.parent=U.prototype.parent;U.prototype.root=function(){x("Firebase.ref",0,0,arguments.length);for(var a=this;null!==a.parent();)a=a.parent();return a};U.prototype.root=U.prototype.root;
+U.prototype.set=function(a,b){x("Firebase.set",1,2,arguments.length);Yf("Firebase.set",this.path);Rf("Firebase.set",a,this.path,!1);A("Firebase.set",2,b,!0);this.k.Kb(this.path,a,null,b||null)};U.prototype.set=U.prototype.set;
+U.prototype.update=function(a,b){x("Firebase.update",1,2,arguments.length);Yf("Firebase.update",this.path);if(ea(a)){for(var c={},d=0;d<a.length;++d)c[""+d]=a[d];a=c;Q("Passing an Array to Firebase.update() is deprecated. Use set() if you want to overwrite the existing data, or an Object with integer keys if you really do want to only update some of the children.")}Tf("Firebase.update",a,this.path);A("Firebase.update",2,b,!0);this.k.update(this.path,a,b||null)};U.prototype.update=U.prototype.update;
+U.prototype.Kb=function(a,b,c){x("Firebase.setWithPriority",2,3,arguments.length);Yf("Firebase.setWithPriority",this.path);Rf("Firebase.setWithPriority",a,this.path,!1);Uf("Firebase.setWithPriority",2,b);A("Firebase.setWithPriority",3,c,!0);if(".length"===this.key()||".keys"===this.key())throw"Firebase.setWithPriority failed: "+this.key()+" is a read-only object.";this.k.Kb(this.path,a,b,c||null)};U.prototype.setWithPriority=U.prototype.Kb;
+U.prototype.remove=function(a){x("Firebase.remove",0,1,arguments.length);Yf("Firebase.remove",this.path);A("Firebase.remove",1,a,!0);this.set(null,a)};U.prototype.remove=U.prototype.remove;
+U.prototype.transaction=function(a,b,c){x("Firebase.transaction",1,3,arguments.length);Yf("Firebase.transaction",this.path);A("Firebase.transaction",1,a,!1);A("Firebase.transaction",2,b,!0);if(n(c)&&"boolean"!=typeof c)throw Error(z("Firebase.transaction",3,!0)+"must be a boolean.");if(".length"===this.key()||".keys"===this.key())throw"Firebase.transaction failed: "+this.key()+" is a read-only object.";"undefined"===typeof c&&(c=!0);Wh(this.k,this.path,a,b||null,c)};U.prototype.transaction=U.prototype.transaction;
+U.prototype.Lg=function(a,b){x("Firebase.setPriority",1,2,arguments.length);Yf("Firebase.setPriority",this.path);Uf("Firebase.setPriority",1,a);A("Firebase.setPriority",2,b,!0);this.k.Kb(this.path.w(".priority"),a,null,b)};U.prototype.setPriority=U.prototype.Lg;
+U.prototype.push=function(a,b){x("Firebase.push",0,2,arguments.length);Yf("Firebase.push",this.path);Rf("Firebase.push",a,this.path,!0);A("Firebase.push",2,b,!0);var c=Mh(this.k),c=Kf(c),c=this.w(c);"undefined"!==typeof a&&null!==a&&c.set(a,b);return c};U.prototype.push=U.prototype.push;U.prototype.jb=function(){Yf("Firebase.onDisconnect",this.path);return new X(this.k,this.path)};U.prototype.onDisconnect=U.prototype.jb;
+U.prototype.P=function(a,b,c){Q("FirebaseRef.auth() being deprecated. Please use FirebaseRef.authWithCustomToken() instead.");x("Firebase.auth",1,3,arguments.length);Zf("Firebase.auth",a);A("Firebase.auth",2,b,!0);A("Firebase.auth",3,b,!0);Kg(this.k.P,a,{},{remember:"none"},b,c)};U.prototype.auth=U.prototype.P;U.prototype.ee=function(a){x("Firebase.unauth",0,1,arguments.length);A("Firebase.unauth",1,a,!0);Lg(this.k.P,a)};U.prototype.unauth=U.prototype.ee;
+U.prototype.we=function(){x("Firebase.getAuth",0,0,arguments.length);return this.k.P.we()};U.prototype.getAuth=U.prototype.we;U.prototype.ug=function(a,b){x("Firebase.onAuth",1,2,arguments.length);A("Firebase.onAuth",1,a,!1);lb("Firebase.onAuth",2,b);this.k.P.Eb("auth_status",a,b)};U.prototype.onAuth=U.prototype.ug;U.prototype.tg=function(a,b){x("Firebase.offAuth",1,2,arguments.length);A("Firebase.offAuth",1,a,!1);lb("Firebase.offAuth",2,b);this.k.P.gc("auth_status",a,b)};U.prototype.offAuth=U.prototype.tg;
+U.prototype.Wf=function(a,b,c){x("Firebase.authWithCustomToken",2,3,arguments.length);Zf("Firebase.authWithCustomToken",a);A("Firebase.authWithCustomToken",2,b,!1);ag("Firebase.authWithCustomToken",3,c,!0);Kg(this.k.P,a,{},c||{},b)};U.prototype.authWithCustomToken=U.prototype.Wf;U.prototype.Xf=function(a,b,c){x("Firebase.authWithOAuthPopup",2,3,arguments.length);$f("Firebase.authWithOAuthPopup",1,a);A("Firebase.authWithOAuthPopup",2,b,!1);ag("Firebase.authWithOAuthPopup",3,c,!0);Pg(this.k.P,a,c,b)};
+U.prototype.authWithOAuthPopup=U.prototype.Xf;U.prototype.Yf=function(a,b,c){x("Firebase.authWithOAuthRedirect",2,3,arguments.length);$f("Firebase.authWithOAuthRedirect",1,a);A("Firebase.authWithOAuthRedirect",2,b,!1);ag("Firebase.authWithOAuthRedirect",3,c,!0);var d=this.k.P;Ng(d);var e=[wg],f=ig(c);"anonymous"===a||"firebase"===a?R(b,yg("TRANSPORT_UNAVAILABLE")):(P.set("redirect_client_options",f.ld),Og(d,e,"/auth/"+a,f,b))};U.prototype.authWithOAuthRedirect=U.prototype.Yf;
+U.prototype.Zf=function(a,b,c,d){x("Firebase.authWithOAuthToken",3,4,arguments.length);$f("Firebase.authWithOAuthToken",1,a);A("Firebase.authWithOAuthToken",3,c,!1);ag("Firebase.authWithOAuthToken",4,d,!0);p(b)?($f("Firebase.authWithOAuthToken",2,b),Mg(this.k.P,a+"/token",{access_token:b},d,c)):(ag("Firebase.authWithOAuthToken",2,b,!1),Mg(this.k.P,a+"/token",b,d,c))};U.prototype.authWithOAuthToken=U.prototype.Zf;
+U.prototype.Vf=function(a,b){x("Firebase.authAnonymously",1,2,arguments.length);A("Firebase.authAnonymously",1,a,!1);ag("Firebase.authAnonymously",2,b,!0);Mg(this.k.P,"anonymous",{},b,a)};U.prototype.authAnonymously=U.prototype.Vf;
+U.prototype.$f=function(a,b,c){x("Firebase.authWithPassword",2,3,arguments.length);ag("Firebase.authWithPassword",1,a,!1);bg("Firebase.authWithPassword",a,"email");bg("Firebase.authWithPassword",a,"password");A("Firebase.authAnonymously",2,b,!1);ag("Firebase.authAnonymously",3,c,!0);Mg(this.k.P,"password",a,c,b)};U.prototype.authWithPassword=U.prototype.$f;
+U.prototype.re=function(a,b){x("Firebase.createUser",2,2,arguments.length);ag("Firebase.createUser",1,a,!1);bg("Firebase.createUser",a,"email");bg("Firebase.createUser",a,"password");A("Firebase.createUser",2,b,!1);this.k.P.re(a,b)};U.prototype.createUser=U.prototype.re;U.prototype.Se=function(a,b){x("Firebase.removeUser",2,2,arguments.length);ag("Firebase.removeUser",1,a,!1);bg("Firebase.removeUser",a,"email");bg("Firebase.removeUser",a,"password");A("Firebase.removeUser",2,b,!1);this.k.P.Se(a,b)};
+U.prototype.removeUser=U.prototype.Se;U.prototype.oe=function(a,b){x("Firebase.changePassword",2,2,arguments.length);ag("Firebase.changePassword",1,a,!1);bg("Firebase.changePassword",a,"email");bg("Firebase.changePassword",a,"oldPassword");bg("Firebase.changePassword",a,"newPassword");A("Firebase.changePassword",2,b,!1);this.k.P.oe(a,b)};U.prototype.changePassword=U.prototype.oe;
+U.prototype.ne=function(a,b){x("Firebase.changeEmail",2,2,arguments.length);ag("Firebase.changeEmail",1,a,!1);bg("Firebase.changeEmail",a,"oldEmail");bg("Firebase.changeEmail",a,"newEmail");bg("Firebase.changeEmail",a,"password");A("Firebase.changeEmail",2,b,!1);this.k.P.ne(a,b)};U.prototype.changeEmail=U.prototype.ne;
+U.prototype.Ue=function(a,b){x("Firebase.resetPassword",2,2,arguments.length);ag("Firebase.resetPassword",1,a,!1);bg("Firebase.resetPassword",a,"email");A("Firebase.resetPassword",2,b,!1);this.k.P.Ue(a,b)};U.prototype.resetPassword=U.prototype.Ue;U.goOffline=function(){x("Firebase.goOffline",0,0,arguments.length);W.ub().yb()};U.goOnline=function(){x("Firebase.goOnline",0,0,arguments.length);W.ub().qc()};
+function Nc(a,b){J(!b||!0===a||!1===a,"Can't turn on custom loggers persistently.");!0===a?("undefined"!==typeof console&&("function"===typeof console.log?Ab=q(console.log,console):"object"===typeof console.log&&(Ab=function(a){console.log(a)})),b&&P.set("logging_enabled",!0)):a?Ab=a:(Ab=null,P.remove("logging_enabled"))}U.enableLogging=Nc;U.ServerValue={TIMESTAMP:{".sv":"timestamp"}};U.SDK_VERSION="2.2.4";U.INTERNAL=V;U.Context=W;U.TEST_ACCESS=Z;})();
+
diff --git a/ionic/components/app/test/hn/hn.js b/ionic/components/app/test/hn/hn.js
index d9cb167723..ab359bec02 100644
--- a/ionic/components/app/test/hn/hn.js
+++ b/ionic/components/app/test/hn/hn.js
@@ -4,7 +4,7 @@ console.log(Promise);
 var APIUrl = 'https://hacker-news.firebaseio.com/v0/';
 export class HackerNewsClient {
   constructor() {
-    this.fb = new Firebase(APIUrl);
+    //this.fb = new Firebase(APIUrl);
   }
 
   getTopStories(cb) {
diff --git a/ionic/components/app/test/hn/main.html b/ionic/components/app/test/hn/main.html
index bfbbe0774e..818de8dc68 100644
--- a/ionic/components/app/test/hn/main.html
+++ b/ionic/components/app/test/hn/main.html
@@ -1,3 +1,5 @@
-<script src="https://cdn.firebase.com/js/client/2.2.4/firebase.js"></script>
+<!--
+  <script src="https://cdn.firebase.com/js/client/2.2.4/firebase.js"></script>
+  -->
 <ion-nav [initial]="splashPage">
 </ion-nav>
diff --git a/ionic/components/app/test/hn/pages/top.js b/ionic/components/app/test/hn/pages/top.js
index 0304dd81c7..354390d3f1 100644
--- a/ionic/components/app/test/hn/pages/top.js
+++ b/ionic/components/app/test/hn/pages/top.js
@@ -32,57 +32,45 @@ export class HNTopStories {
       url: "http://minusbat.livejournal.com/180556.html"
     }];
 
-    var APIUrl = 'https://hacker-news.firebaseio.com/v0';
+      var APIUrl = 'https://hacker-news.firebaseio.com/v0';
+      this.fb = new window.Firebase(APIUrl);
 
-    var s = document.createElement('script');
-    s.src = 'https://cdn.firebase.com/js/client/2.2.4/firebase.js';
-    s.async = true;
-    s.onload = doStuff.bind(this);
-    document.head.appendChild(s);
-    console.log('loading firebase');
+      this.fb = new window.Firebase(APIUrl);
+      this.fb.child('topstories').limitToFirst(20).once('value', (snapshot) => {
 
-  function doStuff() {
-    console.log('done loading firebase');
+        let items = snapshot.val();
 
-    this.fb = new window.Firebase(APIUrl);
-    this.fb.child('topstories').limitToFirst(20).once('value', (snapshot) => {
+        console.log('Fetched', items.length, 'items');
 
-      let items = snapshot.val();
+        for(var itemID of items) {
 
-      console.log('Fetched', items.length, 'items');
-      debugger;
-
-      for(var itemID of items) {
-
-        this.fb.child("item").child(itemID).on('value', (data) => {
-          //setTimeout(() => {
-            //console.log('SUB THIS', this);
-            //console.log(itemID, data.val());
-            //console.log('ADDED');
-            //self.stories.push(data.val());
-            //throw new Error("stack test");
-            debugger;
-            console.log('GOT ITEM', data.val());
-            self.stories.push({title: 'asdf'});
-          //});
-
-          //console.log(data.val());
-        });
-      }
-    });
+          this.fb.child("item").child(itemID).on('value', (data) => {
+            //setTimeout(() => {
+              //console.log('SUB THIS', this);
+              //console.log(itemID, data.val());
+              //console.log('ADDED');
+              //self.stories.push(data.val());
+              //throw new Error("stack test");
+              debugger;
+              console.log('GOT ITEM', data.val());
+              self.stories.push({title: 'asdf'});
+            //});
 
+            //console.log(data.val());
+          });
+        }
+      });
 
     //doStuffEnd
   }
 
-    /*
-    HackerNews.getTopStories((val) => {
-      new Promise((resolve, reject) => {
-        console.log('PROMISES!', val);
-        this.stories.push(val);
-        resolve();
-      });
+  /*
+  HackerNews.getTopStories((val) => {
+    new Promise((resolve, reject) => {
+      console.log('PROMISES!', val);
+      this.stories.push(val);
+      resolve();
     });
-    */
-  }
+  });
+  */
 }
diff --git a/scripts/e2e/index.template.html b/scripts/e2e/index.template.html
index c4a4115a68..db0fe436b2 100644
--- a/scripts/e2e/index.template.html
+++ b/scripts/e2e/index.template.html
@@ -20,7 +20,7 @@
 </body>
 <script>
  System.config({
-   traceurOptions: {annotations: true, types: true}
+   traceurOptions: {annotations: true, types: true},
   });
  System.import('main').catch(console.error.bind(console));
 </script>