var $jscomp = $jscomp || {};
$jscomp.scope = {};
$jscomp.findInternal = function (a, b, c) {
  a instanceof String && (a = String(a));
  for (var d = a.length, e = 0; e < d; e++) {
    var f = a[e];
    if (b.call(c, f, e, a))
      return {
        i: e,
        v: f,
      };
  }
  return {
    i: -1,
    v: void 0,
  };
};
$jscomp.ASSUME_ES5 = !1;
$jscomp.ASSUME_NO_NATIVE_MAP = !1;
$jscomp.ASSUME_NO_NATIVE_SET = !1;
$jscomp.SIMPLE_FROUND_POLYFILL = !1;
$jscomp.defineProperty =
  $jscomp.ASSUME_ES5 || 'function' == typeof Object.defineProperties
    ? Object.defineProperty
    : function (a, b, c) {
        a != Array.prototype && a != Object.prototype && (a[b] = c.value);
      };
$jscomp.getGlobal = function (a) {
  return 'undefined' != typeof window && window === a
    ? a
    : 'undefined' != typeof global && null != global
    ? global
    : a;
};
$jscomp.global = $jscomp.getGlobal(this);
$jscomp.polyfill = function (a, b, c, d) {
  if (b) {
    c = $jscomp.global;
    a = a.split('.');
    for (d = 0; d < a.length - 1; d++) {
      var e = a[d];
      e in c || (c[e] = {});
      c = c[e];
    }
    a = a[a.length - 1];
    d = c[a];
    b = b(d);
    b != d &&
      null != b &&
      $jscomp.defineProperty(c, a, {
        configurable: !0,
        writable: !0,
        value: b,
      });
  }
};
$jscomp.polyfill(
  'Array.prototype.findIndex',
  function (a) {
    return a
      ? a
      : function (a, c) {
          return $jscomp.findInternal(this, a, c).i;
        };
  },
  'es6',
  'es3'
);
$jscomp.checkStringArgs = function (a, b, c) {
  if (null == a)
    throw new TypeError(
      "The 'this' value for String.prototype." +
        c +
        ' must not be null or undefined'
    );
  if (b instanceof RegExp)
    throw new TypeError(
      'First argument to String.prototype.' +
        c +
        ' must not be a regular expression'
    );
  return a + '';
};
$jscomp.polyfill(
  'String.prototype.endsWith',
  function (a) {
    return a
      ? a
      : function (a, c) {
          var b = $jscomp.checkStringArgs(this, a, 'endsWith');
          a += '';
          void 0 === c && (c = b.length);
          c = Math.max(0, Math.min(c | 0, b.length));
          for (var e = a.length; 0 < e && 0 < c; )
            if (b[--c] != a[--e]) return !1;
          return 0 >= e;
        };
  },
  'es6',
  'es3'
);
$jscomp.polyfill(
  'Array.prototype.find',
  function (a) {
    return a
      ? a
      : function (a, c) {
          return $jscomp.findInternal(this, a, c).v;
        };
  },
  'es6',
  'es3'
);
$jscomp.polyfill(
  'String.prototype.startsWith',
  function (a) {
    return a
      ? a
      : function (a, c) {
          var b = $jscomp.checkStringArgs(this, a, 'startsWith');
          a += '';
          var e = b.length,
            f = a.length;
          c = Math.max(0, Math.min(c | 0, b.length));
          for (var g = 0; g < f && c < e; ) if (b[c++] != a[g++]) return !1;
          return g >= f;
        };
  },
  'es6',
  'es3'
);
$jscomp.polyfill(
  'String.prototype.repeat',
  function (a) {
    return a
      ? a
      : function (a) {
          var b = $jscomp.checkStringArgs(this, null, 'repeat');
          if (0 > a || 1342177279 < a)
            throw new RangeError('Invalid count value');
          a |= 0;
          for (var d = ''; a; ) if ((a & 1 && (d += b), (a >>>= 1))) b += b;
          return d;
        };
  },
  'es6',
  'es3'
);
var COMPILED = !0,
  goog = goog || {};
goog.global = this || {};
goog.isDef = function (a) {
  return void 0 !== a;
};
goog.isString = function (a) {
  return 'string' == typeof a;
};
goog.isBoolean = function (a) {
  return 'boolean' == typeof a;
};
goog.isNumber = function (a) {
  return 'number' == typeof a;
};
goog.exportPath_ = function (a, b, c) {
  a = a.split('.');
  c = c || goog.global;
  a[0] in c ||
    'undefined' == typeof c.execScript ||
    c.execScript('var ' + a[0]);
  for (var d; a.length && (d = a.shift()); )
    !a.length && goog.isDef(b)
      ? (c[d] = b)
      : (c = c[d] && c[d] !== Object.prototype[d] ? c[d] : (c[d] = {}));
};
goog.define = function (a, b) {
  if (!COMPILED) {
    var c = goog.global.CLOSURE_UNCOMPILED_DEFINES,
      d = goog.global.CLOSURE_DEFINES;
    c && void 0 === c.nodeType && Object.prototype.hasOwnProperty.call(c, a)
      ? (b = c[a])
      : d &&
        void 0 === d.nodeType &&
        Object.prototype.hasOwnProperty.call(d, a) &&
        (b = d[a]);
  }
  return b;
};
goog.FEATURESET_YEAR = 2012;
goog.DEBUG = !0;
goog.LOCALE = 'en';
goog.TRUSTED_SITE = !0;
goog.STRICT_MODE_COMPATIBLE = !1;
goog.DISALLOW_TEST_ONLY_CODE = COMPILED && !goog.DEBUG;
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING = !1;
goog.provide = function (a) {
  if (goog.isInModuleLoader_())
    throw Error('goog.provide cannot be used within a module.');
  if (!COMPILED && goog.isProvided_(a))
    throw Error('Namespace "' + a + '" already declared.');
  goog.constructNamespace_(a);
};
goog.constructNamespace_ = function (a, b) {
  if (!COMPILED) {
    delete goog.implicitNamespaces_[a];
    for (
      var c = a;
      (c = c.substring(0, c.lastIndexOf('.'))) && !goog.getObjectByName(c);

    )
      goog.implicitNamespaces_[c] = !0;
  }
  goog.exportPath_(a, b);
};
goog.getScriptNonce = function (a) {
  if (a && a != goog.global) return goog.getScriptNonce_(a.document);
  null === goog.cspNonce_ &&
    (goog.cspNonce_ = goog.getScriptNonce_(goog.global.document));
  return goog.cspNonce_;
};
goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;
goog.cspNonce_ = null;
goog.getScriptNonce_ = function (a) {
  return (a = a.querySelector && a.querySelector('script[nonce]')) &&
    (a = a.nonce || a.getAttribute('nonce')) &&
    goog.NONCE_PATTERN_.test(a)
    ? a
    : '';
};
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module = function (a) {
  if (!goog.isString(a) || !a || -1 == a.search(goog.VALID_MODULE_RE_))
    throw Error('Invalid module identifier');
  if (!goog.isInGoogModuleLoader_())
    throw Error(
      'Module ' +
        a +
        " has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide."
    );
  if (goog.moduleLoaderState_.moduleName)
    throw Error('goog.module may only be called once per module.');
  goog.moduleLoaderState_.moduleName = a;
  if (!COMPILED) {
    if (goog.isProvided_(a))
      throw Error('Namespace "' + a + '" already declared.');
    delete goog.implicitNamespaces_[a];
  }
};
goog.module.get = function (a) {
  return goog.module.getInternal_(a);
};
goog.module.getInternal_ = function (a) {
  if (!COMPILED) {
    if (a in goog.loadedModules_) return goog.loadedModules_[a].exports;
    if (!goog.implicitNamespaces_[a])
      return (a = goog.getObjectByName(a)), null != a ? a : null;
  }
  return null;
};
goog.ModuleType = {
  ES6: 'es6',
  GOOG: 'goog',
};
goog.moduleLoaderState_ = null;
goog.isInModuleLoader_ = function () {
  return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
};
goog.isInGoogModuleLoader_ = function () {
  return (
    !!goog.moduleLoaderState_ &&
    goog.moduleLoaderState_.type == goog.ModuleType.GOOG
  );
};
goog.isInEs6ModuleLoader_ = function () {
  if (
    goog.moduleLoaderState_ &&
    goog.moduleLoaderState_.type == goog.ModuleType.ES6
  )
    return !0;
  var a = goog.global.$jscomp;
  return a
    ? 'function' != typeof a.getCurrentModulePath
      ? !1
      : !!a.getCurrentModulePath()
    : !1;
};
goog.module.declareLegacyNamespace = function () {
  if (!COMPILED && !goog.isInGoogModuleLoader_())
    throw 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 = !0;
};
goog.declareModuleId = function (a) {
  if (!COMPILED) {
    if (!goog.isInEs6ModuleLoader_())
      throw Error(
        'goog.declareModuleId may only be called from within an ES6 module'
      );
    if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName)
      throw Error('goog.declareModuleId may only be called once per module.');
    if (a in goog.loadedModules_)
      throw Error('Module with namespace "' + a + '" already exists.');
  }
  if (goog.moduleLoaderState_) goog.moduleLoaderState_.moduleName = a;
  else {
    var b = goog.global.$jscomp;
    if (!b || 'function' != typeof b.getCurrentModulePath)
      throw Error(
        'Module with namespace "' + a + '" has been loaded incorrectly.'
      );
    b = b.require(b.getCurrentModulePath());
    goog.loadedModules_[a] = {
      exports: b,
      type: goog.ModuleType.ES6,
      moduleId: a,
    };
  }
};
goog.setTestOnly = function (a) {
  if (goog.DISALLOW_TEST_ONLY_CODE)
    throw (
      ((a = a || ''),
      Error(
        'Importing test-only code into non-debug environment' +
          (a ? ': ' + a : '.')
      ))
    );
};
goog.forwardDeclare = function (a) {};
COMPILED ||
  ((goog.isProvided_ = function (a) {
    return (
      a in goog.loadedModules_ ||
      (!goog.implicitNamespaces_[a] &&
        goog.isDefAndNotNull(goog.getObjectByName(a)))
    );
  }),
  (goog.implicitNamespaces_ = {
    'goog.module': !0,
  }));
goog.getObjectByName = function (a, b) {
  a = a.split('.');
  b = b || goog.global;
  for (var c = 0; c < a.length; c++)
    if (((b = b[a[c]]), !goog.isDefAndNotNull(b))) return null;
  return b;
};
goog.globalize = function (a, b) {
  b = b || goog.global;
  for (var c in a) b[c] = a[c];
};
goog.addDependency = function (a, b, c, d) {
  !COMPILED &&
    goog.DEPENDENCIES_ENABLED &&
    goog.debugLoader_.addDependency(a, b, c, d);
};
goog.ENABLE_DEBUG_LOADER = !0;
goog.logToConsole_ = function (a) {
  goog.global.console && goog.global.console.error(a);
};
goog.require = function (a) {
  if (!COMPILED) {
    goog.ENABLE_DEBUG_LOADER && goog.debugLoader_.requested(a);
    if (goog.isProvided_(a)) {
      if (goog.isInModuleLoader_()) return goog.module.getInternal_(a);
    } else if (goog.ENABLE_DEBUG_LOADER) {
      var b = goog.moduleLoaderState_;
      goog.moduleLoaderState_ = null;
      try {
        goog.debugLoader_.load_(a);
      } finally {
        goog.moduleLoaderState_ = b;
      }
    }
    return null;
  }
};
goog.requireType = function (a) {
  return {};
};
goog.basePath = '';
goog.nullFunction = function () {};
goog.abstractMethod = function () {
  throw Error('unimplemented abstract method');
};
goog.addSingletonGetter = function (a) {
  a.instance_ = void 0;
  a.getInstance = function () {
    if (a.instance_) return a.instance_;
    goog.DEBUG &&
      (goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = a);
    return (a.instance_ = new a());
  };
};
goog.instantiatedSingletons_ = [];
goog.LOAD_MODULE_USING_EVAL = !0;
goog.SEAL_MODULE_EXPORTS = goog.DEBUG;
goog.loadedModules_ = {};
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
goog.TRANSPILE = 'detect';
goog.ASSUME_ES_MODULES_TRANSPILED = !1;
goog.TRANSPILE_TO_LANGUAGE = '';
goog.TRANSPILER = 'transpile.js';
goog.hasBadLetScoping = null;
goog.useSafari10Workaround = function () {
  if (null == goog.hasBadLetScoping) {
    try {
      var a = !eval(
        '"use strict";let x = 1; function f() { return typeof x; };f() == "number";'
      );
    } catch (b) {
      a = !1;
    }
    goog.hasBadLetScoping = a;
  }
  return goog.hasBadLetScoping;
};
goog.workaroundSafari10EvalBug = function (a) {
  return '(function(){' + a + '\n;})();\n';
};
goog.loadModule = function (a) {
  var b = goog.moduleLoaderState_;
  try {
    goog.moduleLoaderState_ = {
      moduleName: '',
      declareLegacyNamespace: !1,
      type: goog.ModuleType.GOOG,
    };
    if (goog.isFunction(a)) var c = a.call(void 0, {});
    else if (goog.isString(a))
      goog.useSafari10Workaround() && (a = goog.workaroundSafari10EvalBug(a)),
        (c = goog.loadModuleFromSource_.call(void 0, a));
    else throw Error('Invalid module definition');
    var d = goog.moduleLoaderState_.moduleName;
    if (goog.isString(d) && d)
      goog.moduleLoaderState_.declareLegacyNamespace
        ? goog.constructNamespace_(d, c)
        : goog.SEAL_MODULE_EXPORTS &&
          Object.seal &&
          'object' == typeof c &&
          null != c &&
          Object.seal(c),
        (goog.loadedModules_[d] = {
          exports: c,
          type: goog.ModuleType.GOOG,
          moduleId: goog.moduleLoaderState_.moduleName,
        });
    else throw Error('Invalid module name "' + d + '"');
  } finally {
    goog.moduleLoaderState_ = b;
  }
};
goog.loadModuleFromSource_ = function (a) {
  eval(a);
  return {};
};
goog.normalizePath_ = function (a) {
  a = a.split('/');
  for (var b = 0; b < a.length; )
    '.' == a[b]
      ? a.splice(b, 1)
      : b && '..' == a[b] && a[b - 1] && '..' != a[b - 1]
      ? a.splice(--b, 2)
      : b++;
  return a.join('/');
};
goog.loadFileSync_ = function (a) {
  if (goog.global.CLOSURE_LOAD_FILE_SYNC)
    return goog.global.CLOSURE_LOAD_FILE_SYNC(a);
  try {
    var b = new goog.global.XMLHttpRequest();
    b.open('get', a, !1);
    b.send();
    return 0 == b.status || 200 == b.status ? b.responseText : null;
  } catch (c) {
    return null;
  }
};
goog.transpile_ = function (a, b, c) {
  var d = goog.global.$jscomp;
  d || (goog.global.$jscomp = d = {});
  var e = d.transpile;
  if (!e) {
    var f = goog.basePath + goog.TRANSPILER,
      g = goog.loadFileSync_(f);
    if (g) {
      (function () {
        (0, eval)(g + '\n//# sourceURL=' + f);
      }.call(goog.global));
      if (
        goog.global.$gwtExport &&
        goog.global.$gwtExport.$jscomp &&
        !goog.global.$gwtExport.$jscomp.transpile
      )
        throw Error(
          'The transpiler did not properly export the "transpile" method. $gwtExport: ' +
            JSON.stringify(goog.global.$gwtExport)
        );
      goog.global.$jscomp.transpile = goog.global.$gwtExport.$jscomp.transpile;
      d = goog.global.$jscomp;
      e = d.transpile;
    }
  }
  e ||
    (e = d.transpile = function (a, b) {
      goog.logToConsole_(
        b + ' requires transpilation but no transpiler was found.'
      );
      return a;
    });
  return e(a, b, c);
};
goog.typeOf = function (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;
};
goog.isNull = function (a) {
  return null === a;
};
goog.isDefAndNotNull = function (a) {
  return null != a;
};
goog.isArray = function (a) {
  return 'array' == goog.typeOf(a);
};
goog.isArrayLike = function (a) {
  var b = goog.typeOf(a);
  return 'array' == b || ('object' == b && 'number' == typeof a.length);
};
goog.isDateLike = function (a) {
  return goog.isObject(a) && 'function' == typeof a.getFullYear;
};
goog.isFunction = function (a) {
  return 'function' == goog.typeOf(a);
};
goog.isObject = function (a) {
  var b = typeof a;
  return ('object' == b && null != a) || 'function' == b;
};
goog.getUid = function (a) {
  return a[goog.UID_PROPERTY_] || (a[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};
goog.hasUid = function (a) {
  return !!a[goog.UID_PROPERTY_];
};
goog.removeUid = function (a) {
  null !== a && 'removeAttribute' in a && a.removeAttribute(goog.UID_PROPERTY_);
  try {
    delete a[goog.UID_PROPERTY_];
  } catch (b) {}
};
goog.UID_PROPERTY_ = 'closure_uid_' + ((1e9 * Math.random()) >>> 0);
goog.uidCounter_ = 0;
goog.getHashCode = goog.getUid;
goog.removeHashCode = goog.removeUid;
goog.cloneObject = function (a) {
  var b = goog.typeOf(a);
  if ('object' == b || 'array' == b) {
    if ('function' === typeof a.clone) return a.clone();
    b = 'array' == b ? [] : {};
    for (var c in a) b[c] = goog.cloneObject(a[c]);
    return b;
  }
  return a;
};
goog.bindNative_ = function (a, b, c) {
  return a.call.apply(a.bind, arguments);
};
goog.bindJs_ = function (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);
  };
};
goog.bind = function (a, b, c) {
  Function.prototype.bind &&
  -1 != Function.prototype.bind.toString().indexOf('native code')
    ? (goog.bind = goog.bindNative_)
    : (goog.bind = goog.bindJs_);
  return goog.bind.apply(null, arguments);
};
goog.partial = function (a, b) {
  var c = Array.prototype.slice.call(arguments, 1);
  return function () {
    var b = c.slice();
    b.push.apply(b, arguments);
    return a.apply(this, b);
  };
};
goog.mixin = function (a, b) {
  for (var c in b) a[c] = b[c];
};
goog.now =
  (goog.TRUSTED_SITE && Date.now) ||
  function () {
    return +new Date();
  };
goog.globalEval = function (a) {
  if (goog.global.execScript) goog.global.execScript(a, 'JavaScript');
  else if (goog.global.eval) {
    if (null == goog.evalWorksForGlobals_) {
      try {
        goog.global.eval('var _evalTest_ = 1;');
      } catch (d) {}
      if ('undefined' != typeof goog.global._evalTest_) {
        try {
          delete goog.global._evalTest_;
        } catch (d) {}
        goog.evalWorksForGlobals_ = !0;
      } else goog.evalWorksForGlobals_ = !1;
    }
    if (goog.evalWorksForGlobals_) goog.global.eval(a);
    else {
      var b = goog.global.document,
        c = b.createElement('SCRIPT');
      c.type = 'text/javascript';
      c.defer = !1;
      c.appendChild(b.createTextNode(a));
      b.head.appendChild(c);
      b.head.removeChild(c);
    }
  } else throw Error('goog.globalEval not available');
};
goog.evalWorksForGlobals_ = null;
goog.getCssName = function (a, b) {
  if ('.' == String(a).charAt(0))
    throw Error(
      'className passed in goog.getCssName must not start with ".". You passed: ' +
        a
    );
  var c = function (a) {
      return goog.cssNameMapping_[a] || a;
    },
    d = function (a) {
      a = a.split('-');
      for (var b = [], d = 0; d < a.length; d++) b.push(c(a[d]));
      return b.join('-');
    };
  d = goog.cssNameMapping_
    ? 'BY_WHOLE' == goog.cssNameMappingStyle_
      ? c
      : d
    : function (a) {
        return a;
      };
  a = b ? a + '-' + d(b) : d(a);
  return goog.global.CLOSURE_CSS_NAME_MAP_FN
    ? goog.global.CLOSURE_CSS_NAME_MAP_FN(a)
    : a;
};
goog.setCssNameMapping = function (a, b) {
  goog.cssNameMapping_ = a;
  goog.cssNameMappingStyle_ = b;
};
!COMPILED &&
  goog.global.CLOSURE_CSS_NAME_MAPPING &&
  (goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING);
goog.getMsg = function (a, b, c) {
  c && c.html && (a = a.replace(/</g, '&lt;'));
  b &&
    (a = a.replace(/\{\$([^}]+)}/g, function (a, c) {
      return null != b && c in b ? b[c] : a;
    }));
  return a;
};
goog.getMsgWithFallback = function (a, b) {
  return a;
};
goog.exportSymbol = function (a, b, c) {
  goog.exportPath_(a, b, c);
};
goog.exportProperty = function (a, b, c) {
  a[b] = c;
};
goog.inherits = function (a, b) {
  function c() {}
  c.prototype = b.prototype;
  a.superClass_ = b.prototype;
  a.prototype = new c();
  a.prototype.constructor = a;
  a.base = function (a, c, f) {
    for (var d = Array(arguments.length - 2), e = 2; e < arguments.length; e++)
      d[e - 2] = arguments[e];
    return b.prototype[c].apply(a, d);
  };
};
goog.base = function (a, b, c) {
  var d = arguments.callee.caller;
  if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !d))
    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 ('undefined' !== typeof d.superClass_) {
    for (var e = Array(arguments.length - 1), f = 1; f < arguments.length; f++)
      e[f - 1] = arguments[f];
    return d.superClass_.constructor.apply(a, e);
  }
  if ('string' != typeof b && 'symbol' != typeof b)
    throw Error(
      'method names provided to goog.base must be a string or a symbol'
    );
  e = Array(arguments.length - 2);
  for (f = 2; f < arguments.length; f++) e[f - 2] = arguments[f];
  f = !1;
  for (var g = a.constructor.prototype; g; g = Object.getPrototypeOf(g))
    if (g[b] === d) f = !0;
    else if (f) return g[b].apply(a, e);
  if (a[b] === d) return a.constructor.prototype[b].apply(a, e);
  throw Error(
    'goog.base called from a method of one name to a method of a different name'
  );
};
goog.scope = function (a) {
  if (goog.isInModuleLoader_())
    throw Error('goog.scope is not supported within a module.');
  a.call(goog.global);
};
COMPILED || (goog.global.COMPILED = COMPILED);
goog.defineClass = function (a, b) {
  var c = b.constructor,
    d = b.statics;
  (c && c != Object.prototype.constructor) ||
    (c = function () {
      throw Error('cannot instantiate an interface (no constructor defined).');
    });
  c = goog.defineClass.createSealingConstructor_(c, a);
  a && goog.inherits(c, a);
  delete b.constructor;
  delete b.statics;
  goog.defineClass.applyProperties_(c.prototype, b);
  null != d &&
    (d instanceof Function ? d(c) : goog.defineClass.applyProperties_(c, d));
  return c;
};
goog.defineClass.SEAL_CLASS_INSTANCES = goog.DEBUG;
goog.defineClass.createSealingConstructor_ = function (a, b) {
  if (!goog.defineClass.SEAL_CLASS_INSTANCES) return a;
  var c = !goog.defineClass.isUnsealable_(b),
    d = function () {
      var b = a.apply(this, arguments) || this;
      b[goog.UID_PROPERTY_] = b[goog.UID_PROPERTY_];
      this.constructor === d &&
        c &&
        Object.seal instanceof Function &&
        Object.seal(b);
      return b;
    };
  return d;
};
goog.defineClass.isUnsealable_ = function (a) {
  return a && a.prototype && a.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = 'constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf'.split(
  ' '
);
goog.defineClass.applyProperties_ = function (a, b) {
  for (var c in b) Object.prototype.hasOwnProperty.call(b, c) && (a[c] = b[c]);
  for (var d = 0; d < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; d++)
    (c = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d]),
      Object.prototype.hasOwnProperty.call(b, c) && (a[c] = b[c]);
};
goog.tagUnsealableClass = function (a) {
  !COMPILED &&
    goog.defineClass.SEAL_CLASS_INSTANCES &&
    (a.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = !0);
};
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';
!COMPILED &&
  goog.DEPENDENCIES_ENABLED &&
  ((goog.inHtmlDocument_ = function () {
    var a = goog.global.document;
    return null != a && 'write' in a;
  }),
  (goog.isDocumentLoading_ = function () {
    var a = goog.global.document;
    return a.attachEvent
      ? 'complete' != a.readyState
      : 'loading' == a.readyState;
  }),
  (goog.findBasePath_ = function () {
    if (
      goog.isDef(goog.global.CLOSURE_BASE_PATH) &&
      goog.isString(goog.global.CLOSURE_BASE_PATH)
    )
      goog.basePath = goog.global.CLOSURE_BASE_PATH;
    else if (goog.inHtmlDocument_()) {
      var a = goog.global.document,
        b = a.currentScript;
      a = b ? [b] : a.getElementsByTagName('SCRIPT');
      for (b = a.length - 1; 0 <= b; --b) {
        var c = a[b].src,
          d = c.lastIndexOf('?');
        d = -1 == d ? c.length : d;
        if ('base.js' == c.substr(d - 7, 7)) {
          goog.basePath = c.substr(0, d - 7);
          break;
        }
      }
    }
  }),
  goog.findBasePath_(),
  (goog.Transpiler = function () {
    this.requiresTranspilation_ = null;
    this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;
  }),
  (goog.Transpiler.prototype.createRequiresTranspilation_ = function () {
    function a(a, b) {
      e ? (d[a] = !0) : b() ? ((c = a), (d[a] = !1)) : (e = d[a] = !0);
    }

    function b(a) {
      try {
        return !!eval(a);
      } catch (h) {
        return !1;
      }
    }
    var c = 'es3',
      d = {
        es3: !1,
      },
      e = !1,
      f =
        goog.global.navigator && goog.global.navigator.userAgent
          ? goog.global.navigator.userAgent
          : '';
    a('es5', function () {
      return b('[1,].length==1');
    });
    a('es6', function () {
      return f.match(/Edge\/(\d+)(\.\d)*/i)
        ? !1
        : b(
            '(()=>{"use strict";class X{constructor(){if(new.target!=String)throw 1;this.x=42}}let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof String))throw 1;for(const a of[2,3]){if(a==2)continue;function f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()==3}})()'
          );
    });
    a('es7', function () {
      return b('2 ** 2 == 4');
    });
    a('es8', function () {
      return b('async () => 1, true');
    });
    a('es9', function () {
      return b('({...rest} = {}), true');
    });
    a('es_next', function () {
      return !1;
    });
    return {
      target: c,
      map: d,
    };
  }),
  (goog.Transpiler.prototype.needsTranspile = function (a, b) {
    if ('always' == goog.TRANSPILE) return !0;
    if ('never' == goog.TRANSPILE) return !1;
    if (!this.requiresTranspilation_) {
      var c = this.createRequiresTranspilation_();
      this.requiresTranspilation_ = c.map;
      this.transpilationTarget_ = this.transpilationTarget_ || c.target;
    }
    if (a in this.requiresTranspilation_)
      return this.requiresTranspilation_[a]
        ? !0
        : !goog.inHtmlDocument_() ||
          'es6' != b ||
          'noModule' in goog.global.document.createElement('script')
        ? !1
        : !0;
    throw Error('Unknown language mode: ' + a);
  }),
  (goog.Transpiler.prototype.transpile = function (a, b) {
    return goog.transpile_(a, b, this.transpilationTarget_);
  }),
  (goog.transpiler_ = new goog.Transpiler()),
  (goog.protectScriptTag_ = function (a) {
    return a.replace(/<\/(SCRIPT)/gi, '\\x3c/$1');
  }),
  (goog.DebugLoader_ = function () {
    this.dependencies_ = {};
    this.idToPath_ = {};
    this.written_ = {};
    this.loadingDeps_ = [];
    this.depsToLoad_ = [];
    this.paused_ = !1;
    this.factory_ = new goog.DependencyFactory(goog.transpiler_);
    this.deferredCallbacks_ = {};
    this.deferredQueue_ = [];
  }),
  (goog.DebugLoader_.prototype.bootstrap = function (a, b) {
    function c() {
      d && (goog.global.setTimeout(d, 0), (d = null));
    }
    var d = b;
    if (a.length) {
      b = [];
      for (var e = 0; e < a.length; e++) {
        var f = this.getPathFromDeps_(a[e]);
        if (!f) throw Error('Unregonized namespace: ' + a[e]);
        b.push(this.dependencies_[f]);
      }
      f = goog.require;
      var g = 0;
      for (e = 0; e < a.length; e++)
        f(a[e]),
          b[e].onLoad(function () {
            ++g == a.length && c();
          });
    } else c();
  }),
  (goog.DebugLoader_.prototype.loadClosureDeps = function () {
    this.depsToLoad_.push(
      this.factory_.createDependency(
        goog.normalizePath_(goog.basePath + 'deps.js'),
        'deps.js',
        [],
        [],
        {},
        !1
      )
    );
    this.loadDeps_();
  }),
  (goog.DebugLoader_.prototype.requested = function (a, b) {
    (a = this.getPathFromDeps_(a)) &&
      (b || this.areDepsLoaded_(this.dependencies_[a].requires)) &&
      (b = this.deferredCallbacks_[a]) &&
      (delete this.deferredCallbacks_[a], b());
  }),
  (goog.DebugLoader_.prototype.setDependencyFactory = function (a) {
    this.factory_ = a;
  }),
  (goog.DebugLoader_.prototype.load_ = function (a) {
    if (this.getPathFromDeps_(a)) {
      var b = this,
        c = [],
        d = function (a) {
          var e = b.getPathFromDeps_(a);
          if (!e) throw Error('Bad dependency path or symbol: ' + a);
          if (!b.written_[e]) {
            b.written_[e] = !0;
            a = b.dependencies_[e];
            for (e = 0; e < a.requires.length; e++)
              goog.isProvided_(a.requires[e]) || d(a.requires[e]);
            c.push(a);
          }
        };
      d(a);
      a = !!this.depsToLoad_.length;
      this.depsToLoad_ = this.depsToLoad_.concat(c);
      this.paused_ || a || this.loadDeps_();
    } else
      throw (
        ((a = 'goog.require could not find: ' + a),
        goog.logToConsole_(a),
        Error(a))
      );
  }),
  (goog.DebugLoader_.prototype.loadDeps_ = function () {
    for (var a = this, b = this.paused_; this.depsToLoad_.length && !b; )
      (function () {
        var c = !1,
          d = a.depsToLoad_.shift(),
          e = !1;
        a.loading_(d);
        var f = {
          pause: function () {
            if (c) throw Error('Cannot call pause after the call to load.');
            b = !0;
          },
          resume: function () {
            c ? a.resume_() : (b = !1);
          },
          loaded: function () {
            if (e) throw Error('Double call to loaded.');
            e = !0;
            a.loaded_(d);
          },
          pending: function () {
            for (var b = [], c = 0; c < a.loadingDeps_.length; c++)
              b.push(a.loadingDeps_[c]);
            return b;
          },
          setModuleState: function (a) {
            goog.moduleLoaderState_ = {
              type: a,
              moduleName: '',
              declareLegacyNamespace: !1,
            };
          },
          registerEs6ModuleExports: function (a, b, c) {
            c &&
              (goog.loadedModules_[c] = {
                exports: b,
                type: goog.ModuleType.ES6,
                moduleId: c || '',
              });
          },
          registerGoogModuleExports: function (a, b) {
            goog.loadedModules_[a] = {
              exports: b,
              type: goog.ModuleType.GOOG,
              moduleId: a,
            };
          },
          clearModuleState: function () {
            goog.moduleLoaderState_ = null;
          },
          defer: function (b) {
            if (c)
              throw Error('Cannot register with defer after the call to load.');
            a.defer_(d, b);
          },
          areDepsLoaded: function () {
            return a.areDepsLoaded_(d.requires);
          },
        };
        try {
          d.load(f);
        } finally {
          c = !0;
        }
      })();
    b && this.pause_();
  }),
  (goog.DebugLoader_.prototype.pause_ = function () {
    this.paused_ = !0;
  }),
  (goog.DebugLoader_.prototype.resume_ = function () {
    this.paused_ && ((this.paused_ = !1), this.loadDeps_());
  }),
  (goog.DebugLoader_.prototype.loading_ = function (a) {
    this.loadingDeps_.push(a);
  }),
  (goog.DebugLoader_.prototype.loaded_ = function (a) {
    for (var b = 0; b < this.loadingDeps_.length; b++)
      if (this.loadingDeps_[b] == a) {
        this.loadingDeps_.splice(b, 1);
        break;
      }
    for (b = 0; b < this.deferredQueue_.length; b++)
      if (this.deferredQueue_[b] == a.path) {
        this.deferredQueue_.splice(b, 1);
        break;
      }
    if (
      this.loadingDeps_.length == this.deferredQueue_.length &&
      !this.depsToLoad_.length
    )
      for (; this.deferredQueue_.length; )
        this.requested(this.deferredQueue_.shift(), !0);
    a.loaded();
  }),
  (goog.DebugLoader_.prototype.areDepsLoaded_ = function (a) {
    for (var b = 0; b < a.length; b++) {
      var c = this.getPathFromDeps_(a[b]);
      if (!c || !(c in this.deferredCallbacks_ || goog.isProvided_(a[b])))
        return !1;
    }
    return !0;
  }),
  (goog.DebugLoader_.prototype.getPathFromDeps_ = function (a) {
    return a in this.idToPath_
      ? this.idToPath_[a]
      : a in this.dependencies_
      ? a
      : null;
  }),
  (goog.DebugLoader_.prototype.defer_ = function (a, b) {
    this.deferredCallbacks_[a.path] = b;
    this.deferredQueue_.push(a.path);
  }),
  (goog.LoadController = function () {}),
  (goog.LoadController.prototype.pause = function () {}),
  (goog.LoadController.prototype.resume = function () {}),
  (goog.LoadController.prototype.loaded = function () {}),
  (goog.LoadController.prototype.pending = function () {}),
  (goog.LoadController.prototype.registerEs6ModuleExports = function (
    a,
    b,
    c
  ) {}),
  (goog.LoadController.prototype.setModuleState = function (a) {}),
  (goog.LoadController.prototype.clearModuleState = function () {}),
  (goog.LoadController.prototype.defer = function (a) {}),
  (goog.LoadController.prototype.areDepsLoaded = function () {}),
  (goog.Dependency = function (a, b, c, d, e) {
    this.path = a;
    this.relativePath = b;
    this.provides = c;
    this.requires = d;
    this.loadFlags = e;
    this.loaded_ = !1;
    this.loadCallbacks_ = [];
  }),
  (goog.Dependency.prototype.getPathName = function () {
    var a = this.path,
      b = a.indexOf('://');
    0 <= b &&
      ((a = a.substring(b + 3)),
      (b = a.indexOf('/')),
      0 <= b && (a = a.substring(b + 1)));
    return a;
  }),
  (goog.Dependency.prototype.onLoad = function (a) {
    this.loaded_ ? a() : this.loadCallbacks_.push(a);
  }),
  (goog.Dependency.prototype.loaded = function () {
    this.loaded_ = !0;
    var a = this.loadCallbacks_;
    this.loadCallbacks_ = [];
    for (var b = 0; b < a.length; b++) a[b]();
  }),
  (goog.Dependency.defer_ = !1),
  (goog.Dependency.callbackMap_ = {}),
  (goog.Dependency.registerCallback_ = function (a) {
    var b = Math.random().toString(32);
    goog.Dependency.callbackMap_[b] = a;
    return b;
  }),
  (goog.Dependency.unregisterCallback_ = function (a) {
    delete goog.Dependency.callbackMap_[a];
  }),
  (goog.Dependency.callback_ = function (a, b) {
    if (a in goog.Dependency.callbackMap_) {
      for (
        var c = goog.Dependency.callbackMap_[a], d = [], e = 1;
        e < arguments.length;
        e++
      )
        d.push(arguments[e]);
      c.apply(void 0, d);
    } else
      throw Error(
        'Callback key ' +
          a +
          ' does not exist (was base.js loaded more than once?).'
      );
  }),
  (goog.Dependency.prototype.load = function (a) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT)
      goog.global.CLOSURE_IMPORT_SCRIPT(this.path) ? a.loaded() : a.pause();
    else if (goog.inHtmlDocument_()) {
      var b = goog.global.document;
      if (
        'complete' == b.readyState &&
        !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING
      ) {
        if (/\bdeps.js$/.test(this.path)) {
          a.loaded();
          return;
        }
        throw Error('Cannot write "' + this.path + '" after document load');
      }
      if (
        !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
        goog.isDocumentLoading_()
      ) {
        var c = goog.Dependency.registerCallback_(function (b) {
            (goog.DebugLoader_.IS_OLD_IE_ && 'complete' != b.readyState) ||
              (goog.Dependency.unregisterCallback_(c), a.loaded());
          }),
          d =
            !goog.DebugLoader_.IS_OLD_IE_ && goog.getScriptNonce()
              ? ' nonce="' + goog.getScriptNonce() + '"'
              : '';
        d =
          '<script src="' +
          this.path +
          '" ' +
          (goog.DebugLoader_.IS_OLD_IE_ ? 'onreadystatechange' : 'onload') +
          '="goog.Dependency.callback_(\'' +
          c +
          '\', this)" type="text/javascript" ' +
          (goog.Dependency.defer_ ? 'defer' : '') +
          d +
          '>\x3c/script>';
        b.write(
          goog.TRUSTED_TYPES_POLICY_
            ? goog.TRUSTED_TYPES_POLICY_.createHTML(d)
            : d
        );
      } else {
        var e = b.createElement('script');
        e.defer = goog.Dependency.defer_;
        e.async = !1;
        e.type = 'text/javascript';
        (d = goog.getScriptNonce()) && e.setAttribute('nonce', d);
        goog.DebugLoader_.IS_OLD_IE_
          ? (a.pause(),
            (e.onreadystatechange = function () {
              if ('loaded' == e.readyState || 'complete' == e.readyState)
                a.loaded(), a.resume();
            }))
          : (e.onload = function () {
              e.onload = null;
              a.loaded();
            });
        e.src = goog.TRUSTED_TYPES_POLICY_
          ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path)
          : this.path;
        b.head.appendChild(e);
      }
    } else
      goog.logToConsole_(
        'Cannot use default debug loader outside of HTML documents.'
      ),
        'deps.js' == this.relativePath
          ? (goog.logToConsole_(
              'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true.'
            ),
            a.loaded())
          : a.pause();
  }),
  (goog.Es6ModuleDependency = function (a, b, c, d, e) {
    goog.Dependency.call(this, a, b, c, d, e);
  }),
  goog.inherits(goog.Es6ModuleDependency, goog.Dependency),
  (goog.Es6ModuleDependency.prototype.load = function (a) {
    function b(a, b) {
      a = b
        ? '<script type="module" crossorigin>' + b + '\x3c/script>'
        : '<script type="module" crossorigin src="' + a + '">\x3c/script>';
      d.write(
        goog.TRUSTED_TYPES_POLICY_
          ? goog.TRUSTED_TYPES_POLICY_.createHTML(a)
          : a
      );
    }

    function c(a, b) {
      var c = d.createElement('script');
      c.defer = !0;
      c.async = !1;
      c.type = 'module';
      c.setAttribute('crossorigin', !0);
      var e = goog.getScriptNonce();
      e && c.setAttribute('nonce', e);
      b
        ? (c.textContent = goog.TRUSTED_TYPES_POLICY_
            ? goog.TRUSTED_TYPES_POLICY_.createScript(b)
            : b)
        : (c.src = goog.TRUSTED_TYPES_POLICY_
            ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(a)
            : a);
      d.head.appendChild(c);
    }
    if (goog.global.CLOSURE_IMPORT_SCRIPT)
      goog.global.CLOSURE_IMPORT_SCRIPT(this.path) ? a.loaded() : a.pause();
    else if (goog.inHtmlDocument_()) {
      var d = goog.global.document,
        e = this;
      if (goog.isDocumentLoading_()) {
        var f = b;
        goog.Dependency.defer_ = !0;
      } else f = c;
      var g = goog.Dependency.registerCallback_(function () {
        goog.Dependency.unregisterCallback_(g);
        a.setModuleState(goog.ModuleType.ES6);
      });
      f(void 0, 'goog.Dependency.callback_("' + g + '")');
      f(this.path, void 0);
      var h = goog.Dependency.registerCallback_(function (b) {
        goog.Dependency.unregisterCallback_(h);
        a.registerEs6ModuleExports(
          e.path,
          b,
          goog.moduleLoaderState_.moduleName
        );
      });
      f(
        void 0,
        'import * as m from "' +
          this.path +
          '"; goog.Dependency.callback_("' +
          h +
          '", m)'
      );
      var k = goog.Dependency.registerCallback_(function () {
        goog.Dependency.unregisterCallback_(k);
        a.clearModuleState();
        a.loaded();
      });
      f(void 0, 'goog.Dependency.callback_("' + k + '")');
    } else
      goog.logToConsole_(
        'Cannot use default debug loader outside of HTML documents.'
      ),
        a.pause();
  }),
  (goog.TransformedDependency = function (a, b, c, d, e) {
    goog.Dependency.call(this, a, b, c, d, e);
    this.contents_ = null;
    this.lazyFetch_ =
      !goog.inHtmlDocument_() ||
      !('noModule' in goog.global.document.createElement('script'));
  }),
  goog.inherits(goog.TransformedDependency, goog.Dependency),
  (goog.TransformedDependency.prototype.load = function (a) {
    function b() {
      e.contents_ = goog.loadFileSync_(e.path);
      e.contents_ &&
        ((e.contents_ = e.transform(e.contents_)),
        e.contents_ && (e.contents_ += '\n//# sourceURL=' + e.path));
    }

    function c() {
      e.lazyFetch_ && b();
      if (e.contents_) {
        f && a.setModuleState(goog.ModuleType.ES6);
        try {
          var c = e.contents_;
          e.contents_ = null;
          goog.globalEval(c);
          if (f) var d = goog.moduleLoaderState_.moduleName;
        } finally {
          f && a.clearModuleState();
        }
        f &&
          goog.global.$jscomp.require.ensure([e.getPathName()], function () {
            a.registerEs6ModuleExports(
              e.path,
              goog.global.$jscomp.require(e.getPathName()),
              d
            );
          });
        a.loaded();
      }
    }

    function d() {
      var a = goog.global.document,
        b = goog.Dependency.registerCallback_(function () {
          goog.Dependency.unregisterCallback_(b);
          c();
        }),
        d =
          '<script type="text/javascript">' +
          goog.protectScriptTag_('goog.Dependency.callback_("' + b + '");') +
          '\x3c/script>';
      a.write(
        goog.TRUSTED_TYPES_POLICY_
          ? goog.TRUSTED_TYPES_POLICY_.createHTML(d)
          : d
      );
    }
    var e = this;
    if (goog.global.CLOSURE_IMPORT_SCRIPT)
      b(),
        this.contents_ && goog.global.CLOSURE_IMPORT_SCRIPT('', this.contents_)
          ? ((this.contents_ = null), a.loaded())
          : a.pause();
    else {
      var f = this.loadFlags.module == goog.ModuleType.ES6;
      this.lazyFetch_ || b();
      var g = 1 < a.pending().length,
        h = g && goog.DebugLoader_.IS_OLD_IE_;
      g = goog.Dependency.defer_ && (g || goog.isDocumentLoading_());
      if (h || g)
        a.defer(function () {
          c();
        });
      else {
        var k = goog.global.document;
        h = goog.inHtmlDocument_() && 'ActiveXObject' in goog.global;
        if (f && goog.inHtmlDocument_() && goog.isDocumentLoading_() && !h) {
          goog.Dependency.defer_ = !0;
          a.pause();
          var l = k.onreadystatechange;
          k.onreadystatechange = function () {
            'interactive' == k.readyState &&
              ((k.onreadystatechange = l), c(), a.resume());
            goog.isFunction(l) && l.apply(void 0, arguments);
          };
        } else
          !goog.DebugLoader_.IS_OLD_IE_ &&
          goog.inHtmlDocument_() &&
          goog.isDocumentLoading_()
            ? d()
            : c();
      }
    }
  }),
  (goog.TransformedDependency.prototype.transform = function (a) {}),
  (goog.TranspiledDependency = function (a, b, c, d, e, f) {
    goog.TransformedDependency.call(this, a, b, c, d, e);
    this.transpiler = f;
  }),
  goog.inherits(goog.TranspiledDependency, goog.TransformedDependency),
  (goog.TranspiledDependency.prototype.transform = function (a) {
    return this.transpiler.transpile(a, this.getPathName());
  }),
  (goog.PreTranspiledEs6ModuleDependency = function (a, b, c, d, e) {
    goog.TransformedDependency.call(this, a, b, c, d, e);
  }),
  goog.inherits(
    goog.PreTranspiledEs6ModuleDependency,
    goog.TransformedDependency
  ),
  (goog.PreTranspiledEs6ModuleDependency.prototype.transform = function (a) {
    return a;
  }),
  (goog.GoogModuleDependency = function (a, b, c, d, e, f, g) {
    goog.TransformedDependency.call(this, a, b, c, d, e);
    this.needsTranspile_ = f;
    this.transpiler_ = g;
  }),
  goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency),
  (goog.GoogModuleDependency.prototype.transform = function (a) {
    this.needsTranspile_ &&
      (a = this.transpiler_.transpile(a, this.getPathName()));
    return goog.LOAD_MODULE_USING_EVAL && goog.isDef(goog.global.JSON)
      ? 'goog.loadModule(' +
          goog.global.JSON.stringify(
            a + '\n//# sourceURL=' + this.path + '\n'
          ) +
          ');'
      : 'goog.loadModule(function(exports) {"use strict";' +
          a +
          '\n;return exports});\n//# sourceURL=' +
          this.path +
          '\n';
  }),
  (goog.DebugLoader_.IS_OLD_IE_ = !(
    goog.global.atob ||
    !goog.global.document ||
    !goog.global.document.all
  )),
  (goog.DebugLoader_.prototype.addDependency = function (a, b, c, d) {
    b = b || [];
    a = a.replace(/\\/g, '/');
    var e = goog.normalizePath_(goog.basePath + a);
    (d && 'boolean' !== typeof d) ||
      (d = d
        ? {
            module: goog.ModuleType.GOOG,
          }
        : {});
    c = this.factory_.createDependency(
      e,
      a,
      b,
      c,
      d,
      goog.transpiler_.needsTranspile(d.lang || 'es3', d.module)
    );
    this.dependencies_[e] = c;
    for (c = 0; c < b.length; c++) this.idToPath_[b[c]] = e;
    this.idToPath_[a] = e;
  }),
  (goog.DependencyFactory = function (a) {
    this.transpiler = a;
  }),
  (goog.DependencyFactory.prototype.createDependency = function (
    a,
    b,
    c,
    d,
    e,
    f
  ) {
    return e.module == goog.ModuleType.GOOG
      ? new goog.GoogModuleDependency(a, b, c, d, e, f, this.transpiler)
      : f
      ? new goog.TranspiledDependency(a, b, c, d, e, this.transpiler)
      : e.module == goog.ModuleType.ES6
      ? 'never' == goog.TRANSPILE && goog.ASSUME_ES_MODULES_TRANSPILED
        ? new goog.PreTranspiledEs6ModuleDependency(a, b, c, d, e)
        : new goog.Es6ModuleDependency(a, b, c, d, e)
      : new goog.Dependency(a, b, c, d, e);
  }),
  (goog.debugLoader_ = new goog.DebugLoader_()),
  (goog.loadClosureDeps = function () {
    goog.debugLoader_.loadClosureDeps();
  }),
  (goog.setDependencyFactory = function (a) {
    goog.debugLoader_.setDependencyFactory(a);
  }),
  goog.global.CLOSURE_NO_DEPS || goog.debugLoader_.loadClosureDeps(),
  (goog.bootstrap = function (a, b) {
    goog.debugLoader_.bootstrap(a, b);
  }));
goog.TRUSTED_TYPES_POLICY_NAME = '';
goog.identity_ = function (a) {
  return a;
};
goog.createTrustedTypesPolicy = function (a) {
  var b = null;
  if ('undefined' === typeof TrustedTypes || !TrustedTypes.createPolicy)
    return b;
  try {
    b = TrustedTypes.createPolicy(a, {
      createHTML: goog.identity_,
      createScript: goog.identity_,
      createScriptURL: goog.identity_,
      createURL: goog.identity_,
    });
  } catch (c) {
    goog.logToConsole_(c.message);
  }
  return b;
};
goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME
  ? goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + '#base')
  : null;
var jspb = {
  BinaryConstants: {},
  ConstBinaryMessage: function () {},
  BinaryMessage: function () {},
};
jspb.BinaryConstants.FieldType = {
  INVALID: -1,
  DOUBLE: 1,
  FLOAT: 2,
  INT64: 3,
  UINT64: 4,
  INT32: 5,
  FIXED64: 6,
  FIXED32: 7,
  BOOL: 8,
  STRING: 9,
  GROUP: 10,
  MESSAGE: 11,
  BYTES: 12,
  UINT32: 13,
  ENUM: 14,
  SFIXED32: 15,
  SFIXED64: 16,
  SINT32: 17,
  SINT64: 18,
  FHASH64: 30,
  VHASH64: 31,
};
jspb.BinaryConstants.WireType = {
  INVALID: -1,
  VARINT: 0,
  FIXED64: 1,
  DELIMITED: 2,
  START_GROUP: 3,
  END_GROUP: 4,
  FIXED32: 5,
};
jspb.BinaryConstants.FieldTypeToWireType = function (a) {
  var b = jspb.BinaryConstants.FieldType,
    c = jspb.BinaryConstants.WireType;
  switch (a) {
    case b.INT32:
    case b.INT64:
    case b.UINT32:
    case b.UINT64:
    case b.SINT32:
    case b.SINT64:
    case b.BOOL:
    case b.ENUM:
    case b.VHASH64:
      return c.VARINT;
    case b.DOUBLE:
    case b.FIXED64:
    case b.SFIXED64:
    case b.FHASH64:
      return c.FIXED64;
    case b.STRING:
    case b.MESSAGE:
    case b.BYTES:
      return c.DELIMITED;
    case b.FLOAT:
    case b.FIXED32:
    case b.SFIXED32:
      return c.FIXED32;
    default:
      return c.INVALID;
  }
};
jspb.BinaryConstants.INVALID_FIELD_NUMBER = -1;
jspb.BinaryConstants.FLOAT32_EPS = 1.401298464324817e-45;
jspb.BinaryConstants.FLOAT32_MIN = 1.1754943508222875e-38;
jspb.BinaryConstants.FLOAT32_MAX = 3.4028234663852886e38;
jspb.BinaryConstants.FLOAT64_EPS = 4.9e-324;
jspb.BinaryConstants.FLOAT64_MIN = 2.2250738585072014e-308;
jspb.BinaryConstants.FLOAT64_MAX = 1.7976931348623157e308;
jspb.BinaryConstants.TWO_TO_20 = 1048576;
jspb.BinaryConstants.TWO_TO_23 = 8388608;
jspb.BinaryConstants.TWO_TO_31 = 2147483648;
jspb.BinaryConstants.TWO_TO_32 = 4294967296;
jspb.BinaryConstants.TWO_TO_52 = 4503599627370496;
jspb.BinaryConstants.TWO_TO_63 = 0x7fffffffffffffff;
jspb.BinaryConstants.TWO_TO_64 = 1.8446744073709552e19;
jspb.BinaryConstants.ZERO_HASH = '\x00\x00\x00\x00\x00\x00\x00\x00';
goog.dom = {};
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.debug = {};
goog.debug.Error = function (a) {
  if (Error.captureStackTrace) Error.captureStackTrace(this, goog.debug.Error);
  else {
    var b = Error().stack;
    b && (this.stack = b);
  }
  a && (this.message = String(a));
  this.reportErrorToServer = !0;
};
goog.inherits(goog.debug.Error, Error);
goog.debug.Error.prototype.name = 'CustomError';
goog.asserts = {};
goog.asserts.ENABLE_ASSERTS = goog.DEBUG;
goog.asserts.AssertionError = function (a, b) {
  goog.debug.Error.call(this, goog.asserts.subs_(a, b));
  this.messagePattern = a;
};
goog.inherits(goog.asserts.AssertionError, goog.debug.Error);
goog.asserts.AssertionError.prototype.name = 'AssertionError';
goog.asserts.DEFAULT_ERROR_HANDLER = function (a) {
  throw a;
};
goog.asserts.errorHandler_ = goog.asserts.DEFAULT_ERROR_HANDLER;
goog.asserts.subs_ = function (a, b) {
  a = a.split('%s');
  for (var c = '', d = a.length - 1, e = 0; e < d; e++)
    c += a[e] + (e < b.length ? b[e] : '%s');
  return c + a[d];
};
goog.asserts.doAssertFailure_ = function (a, b, c, d) {
  var e = 'Assertion failed';
  if (c) {
    e += ': ' + c;
    var f = d;
  } else a && ((e += ': ' + a), (f = b));
  a = new goog.asserts.AssertionError('' + e, f || []);
  goog.asserts.errorHandler_(a);
};
goog.asserts.setErrorHandler = function (a) {
  goog.asserts.ENABLE_ASSERTS && (goog.asserts.errorHandler_ = a);
};
goog.asserts.assert = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    !a &&
    goog.asserts.doAssertFailure_(
      '',
      null,
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertExists = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    null == a &&
    goog.asserts.doAssertFailure_(
      'Expected to exist: %s.',
      [a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.fail = function (a, b) {
  goog.asserts.ENABLE_ASSERTS &&
    goog.asserts.errorHandler_(
      new goog.asserts.AssertionError(
        'Failure' + (a ? ': ' + a : ''),
        Array.prototype.slice.call(arguments, 1)
      )
    );
};
goog.asserts.assertNumber = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    !goog.isNumber(a) &&
    goog.asserts.doAssertFailure_(
      'Expected number but got %s: %s.',
      [goog.typeOf(a), a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertString = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    !goog.isString(a) &&
    goog.asserts.doAssertFailure_(
      'Expected string but got %s: %s.',
      [goog.typeOf(a), a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertFunction = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    !goog.isFunction(a) &&
    goog.asserts.doAssertFailure_(
      'Expected function but got %s: %s.',
      [goog.typeOf(a), a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertObject = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    !goog.isObject(a) &&
    goog.asserts.doAssertFailure_(
      'Expected object but got %s: %s.',
      [goog.typeOf(a), a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertArray = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    !goog.isArray(a) &&
    goog.asserts.doAssertFailure_(
      'Expected array but got %s: %s.',
      [goog.typeOf(a), a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertBoolean = function (a, b, c) {
  goog.asserts.ENABLE_ASSERTS &&
    !goog.isBoolean(a) &&
    goog.asserts.doAssertFailure_(
      'Expected boolean but got %s: %s.',
      [goog.typeOf(a), a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertElement = function (a, b, c) {
  !goog.asserts.ENABLE_ASSERTS ||
    (goog.isObject(a) && a.nodeType == goog.dom.NodeType.ELEMENT) ||
    goog.asserts.doAssertFailure_(
      'Expected Element but got %s: %s.',
      [goog.typeOf(a), a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertInstanceof = function (a, b, c, d) {
  !goog.asserts.ENABLE_ASSERTS ||
    a instanceof b ||
    goog.asserts.doAssertFailure_(
      'Expected instanceof %s but got %s.',
      [goog.asserts.getType_(b), goog.asserts.getType_(a)],
      c,
      Array.prototype.slice.call(arguments, 3)
    );
  return a;
};
goog.asserts.assertFinite = function (a, b, c) {
  !goog.asserts.ENABLE_ASSERTS ||
    ('number' == typeof a && isFinite(a)) ||
    goog.asserts.doAssertFailure_(
      'Expected %s to be a finite number but it is not.',
      [a],
      b,
      Array.prototype.slice.call(arguments, 2)
    );
  return a;
};
goog.asserts.assertObjectPrototypeIsIntact = function () {
  for (var a in Object.prototype)
    goog.asserts.fail(a + ' should not be enumerable in Object.prototype.');
};
goog.asserts.getType_ = function (a) {
  return a instanceof Function
    ? a.displayName || a.name || 'unknown type name'
    : a instanceof Object
    ? a.constructor.displayName ||
      a.constructor.name ||
      Object.prototype.toString.call(a)
    : null === a
    ? 'null'
    : typeof a;
};
goog.array = {};
goog.NATIVE_ARRAY_PROTOTYPES = goog.TRUSTED_SITE;
goog.array.ASSUME_NATIVE_FUNCTIONS = 2012 < goog.FEATURESET_YEAR;
goog.array.peek = function (a) {
  return a[a.length - 1];
};
goog.array.last = goog.array.peek;
goog.array.indexOf =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.indexOf)
    ? function (a, b, c) {
        goog.asserts.assert(null != a.length);
        return Array.prototype.indexOf.call(a, b, c);
      }
    : function (a, b, c) {
        c = null == c ? 0 : 0 > c ? Math.max(0, a.length + c) : c;
        if (goog.isString(a))
          return goog.isString(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;
      };
goog.array.lastIndexOf =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.lastIndexOf)
    ? function (a, b, c) {
        goog.asserts.assert(null != a.length);
        return Array.prototype.lastIndexOf.call(
          a,
          b,
          null == c ? a.length - 1 : c
        );
      }
    : function (a, b, c) {
        c = null == c ? a.length - 1 : c;
        0 > c && (c = Math.max(0, a.length + c));
        if (goog.isString(a))
          return goog.isString(b) && 1 == b.length ? a.lastIndexOf(b, c) : -1;
        for (; 0 <= c; c--) if (c in a && a[c] === b) return c;
        return -1;
      };
goog.array.forEach =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.forEach)
    ? function (a, b, c) {
        goog.asserts.assert(null != a.length);
        Array.prototype.forEach.call(a, b, c);
      }
    : function (a, b, c) {
        for (
          var d = a.length, e = goog.isString(a) ? a.split('') : a, f = 0;
          f < d;
          f++
        )
          f in e && b.call(c, e[f], f, a);
      };
goog.array.forEachRight = function (a, b, c) {
  var d = a.length,
    e = goog.isString(a) ? a.split('') : a;
  for (--d; 0 <= d; --d) d in e && b.call(c, e[d], d, a);
};
goog.array.filter =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.filter)
    ? function (a, b, c) {
        goog.asserts.assert(null != a.length);
        return Array.prototype.filter.call(a, b, c);
      }
    : function (a, b, c) {
        for (
          var d = a.length,
            e = [],
            f = 0,
            g = goog.isString(a) ? a.split('') : a,
            h = 0;
          h < d;
          h++
        )
          if (h in g) {
            var k = g[h];
            b.call(c, k, h, a) && (e[f++] = k);
          }
        return e;
      };
goog.array.map =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.map)
    ? function (a, b, c) {
        goog.asserts.assert(null != a.length);
        return Array.prototype.map.call(a, b, c);
      }
    : function (a, b, c) {
        for (
          var d = a.length,
            e = Array(d),
            f = goog.isString(a) ? a.split('') : a,
            g = 0;
          g < d;
          g++
        )
          g in f && (e[g] = b.call(c, f[g], g, a));
        return e;
      };
goog.array.reduce =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduce)
    ? function (a, b, c, d) {
        goog.asserts.assert(null != a.length);
        d && (b = goog.bind(b, d));
        return Array.prototype.reduce.call(a, b, c);
      }
    : function (a, b, c, d) {
        var e = c;
        goog.array.forEach(a, function (c, g) {
          e = b.call(d, e, c, g, a);
        });
        return e;
      };
goog.array.reduceRight =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduceRight)
    ? function (a, b, c, d) {
        goog.asserts.assert(null != a.length);
        goog.asserts.assert(null != b);
        d && (b = goog.bind(b, d));
        return Array.prototype.reduceRight.call(a, b, c);
      }
    : function (a, b, c, d) {
        var e = c;
        goog.array.forEachRight(a, function (c, g) {
          e = b.call(d, e, c, g, a);
        });
        return e;
      };
goog.array.some =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.some)
    ? function (a, b, c) {
        goog.asserts.assert(null != a.length);
        return Array.prototype.some.call(a, b, c);
      }
    : function (a, b, c) {
        for (
          var d = a.length, e = goog.isString(a) ? a.split('') : a, f = 0;
          f < d;
          f++
        )
          if (f in e && b.call(c, e[f], f, a)) return !0;
        return !1;
      };
goog.array.every =
  goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.every)
    ? function (a, b, c) {
        goog.asserts.assert(null != a.length);
        return Array.prototype.every.call(a, b, c);
      }
    : function (a, b, c) {
        for (
          var d = a.length, e = goog.isString(a) ? a.split('') : a, f = 0;
          f < d;
          f++
        )
          if (f in e && !b.call(c, e[f], f, a)) return !1;
        return !0;
      };
goog.array.count = function (a, b, c) {
  var d = 0;
  goog.array.forEach(
    a,
    function (a, f, g) {
      b.call(c, a, f, g) && ++d;
    },
    c
  );
  return d;
};
goog.array.find = function (a, b, c) {
  b = goog.array.findIndex(a, b, c);
  return 0 > b ? null : goog.isString(a) ? a.charAt(b) : a[b];
};
goog.array.findIndex = function (a, b, c) {
  for (
    var d = a.length, e = goog.isString(a) ? a.split('') : a, f = 0;
    f < d;
    f++
  )
    if (f in e && b.call(c, e[f], f, a)) return f;
  return -1;
};
goog.array.findRight = function (a, b, c) {
  b = goog.array.findIndexRight(a, b, c);
  return 0 > b ? null : goog.isString(a) ? a.charAt(b) : a[b];
};
goog.array.findIndexRight = function (a, b, c) {
  var d = a.length,
    e = goog.isString(a) ? a.split('') : a;
  for (--d; 0 <= d; d--) if (d in e && b.call(c, e[d], d, a)) return d;
  return -1;
};
goog.array.contains = function (a, b) {
  return 0 <= goog.array.indexOf(a, b);
};
goog.array.isEmpty = function (a) {
  return 0 == a.length;
};
goog.array.clear = function (a) {
  if (!goog.isArray(a)) for (var b = a.length - 1; 0 <= b; b--) delete a[b];
  a.length = 0;
};
goog.array.insert = function (a, b) {
  goog.array.contains(a, b) || a.push(b);
};
goog.array.insertAt = function (a, b, c) {
  goog.array.splice(a, c, 0, b);
};
goog.array.insertArrayAt = function (a, b, c) {
  goog.partial(goog.array.splice, a, c, 0).apply(null, b);
};
goog.array.insertBefore = function (a, b, c) {
  var d;
  2 == arguments.length || 0 > (d = goog.array.indexOf(a, c))
    ? a.push(b)
    : goog.array.insertAt(a, b, d);
};
goog.array.remove = function (a, b) {
  b = goog.array.indexOf(a, b);
  var c;
  (c = 0 <= b) && goog.array.removeAt(a, b);
  return c;
};
goog.array.removeLast = function (a, b) {
  b = goog.array.lastIndexOf(a, b);
  return 0 <= b ? (goog.array.removeAt(a, b), !0) : !1;
};
goog.array.removeAt = function (a, b) {
  goog.asserts.assert(null != a.length);
  return 1 == Array.prototype.splice.call(a, b, 1).length;
};
goog.array.removeIf = function (a, b, c) {
  b = goog.array.findIndex(a, b, c);
  return 0 <= b ? (goog.array.removeAt(a, b), !0) : !1;
};
goog.array.removeAllIf = function (a, b, c) {
  var d = 0;
  goog.array.forEachRight(a, function (e, f) {
    b.call(c, e, f, a) && goog.array.removeAt(a, f) && d++;
  });
  return d;
};
goog.array.concat = function (a) {
  return Array.prototype.concat.apply([], arguments);
};
goog.array.join = function (a) {
  return Array.prototype.concat.apply([], arguments);
};
goog.array.toArray = function (a) {
  var b = a.length;
  if (0 < b) {
    for (var c = Array(b), d = 0; d < b; d++) c[d] = a[d];
    return c;
  }
  return [];
};
goog.array.clone = goog.array.toArray;
goog.array.extend = function (a, b) {
  for (var c = 1; c < arguments.length; c++) {
    var d = arguments[c];
    if (goog.isArrayLike(d)) {
      var e = a.length || 0,
        f = d.length || 0;
      a.length = e + f;
      for (var g = 0; g < f; g++) a[e + g] = d[g];
    } else a.push(d);
  }
};
goog.array.splice = function (a, b, c, d) {
  goog.asserts.assert(null != a.length);
  return Array.prototype.splice.apply(a, goog.array.slice(arguments, 1));
};
goog.array.slice = function (a, b, c) {
  goog.asserts.assert(null != a.length);
  return 2 >= arguments.length
    ? Array.prototype.slice.call(a, b)
    : Array.prototype.slice.call(a, b, c);
};
goog.array.removeDuplicates = function (a, b, c) {
  b = b || a;
  var d = function (a) {
    return goog.isObject(a) ? 'o' + goog.getUid(a) : (typeof a).charAt(0) + a;
  };
  c = c || d;
  d = {};
  for (var e = 0, f = 0; f < a.length; ) {
    var g = a[f++],
      h = c(g);
    Object.prototype.hasOwnProperty.call(d, h) || ((d[h] = !0), (b[e++] = g));
  }
  b.length = e;
};
goog.array.binarySearch = function (a, b, c) {
  return goog.array.binarySearch_(a, c || goog.array.defaultCompare, !1, b);
};
goog.array.binarySelect = function (a, b, c) {
  return goog.array.binarySearch_(a, b, !0, void 0, c);
};
goog.array.binarySearch_ = function (a, b, c, d, e) {
  for (var f = 0, g = a.length, h; f < g; ) {
    var k = (f + g) >> 1;
    var l = c ? b.call(e, a[k], k, a) : b(d, a[k]);
    0 < l ? (f = k + 1) : ((g = k), (h = !l));
  }
  return h ? f : ~f;
};
goog.array.sort = function (a, b) {
  a.sort(b || goog.array.defaultCompare);
};
goog.array.stableSort = function (a, b) {
  for (var c = Array(a.length), d = 0; d < a.length; d++)
    c[d] = {
      index: d,
      value: a[d],
    };
  var e = b || goog.array.defaultCompare;
  goog.array.sort(c, function (a, b) {
    return e(a.value, b.value) || a.index - b.index;
  });
  for (d = 0; d < a.length; d++) a[d] = c[d].value;
};
goog.array.sortByKey = function (a, b, c) {
  var d = c || goog.array.defaultCompare;
  goog.array.sort(a, function (a, c) {
    return d(b(a), b(c));
  });
};
goog.array.sortObjectsByKey = function (a, b, c) {
  goog.array.sortByKey(
    a,
    function (a) {
      return a[b];
    },
    c
  );
};
goog.array.isSorted = function (a, b, c) {
  b = b || goog.array.defaultCompare;
  for (var d = 1; d < a.length; d++) {
    var e = b(a[d - 1], a[d]);
    if (0 < e || (0 == e && c)) return !1;
  }
  return !0;
};
goog.array.equals = function (a, b, c) {
  if (!goog.isArrayLike(a) || !goog.isArrayLike(b) || a.length != b.length)
    return !1;
  var d = a.length;
  c = c || goog.array.defaultCompareEquality;
  for (var e = 0; e < d; e++) if (!c(a[e], b[e])) return !1;
  return !0;
};
goog.array.compare3 = function (a, b, c) {
  c = c || goog.array.defaultCompare;
  for (var d = Math.min(a.length, b.length), e = 0; e < d; e++) {
    var f = c(a[e], b[e]);
    if (0 != f) return f;
  }
  return goog.array.defaultCompare(a.length, b.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 (a, b, c) {
  c = goog.array.binarySearch(a, b, c);
  return 0 > c ? (goog.array.insertAt(a, b, -(c + 1)), !0) : !1;
};
goog.array.binaryRemove = function (a, b, c) {
  b = goog.array.binarySearch(a, b, c);
  return 0 <= b ? goog.array.removeAt(a, b) : !1;
};
goog.array.bucket = function (a, b, c) {
  for (var d = {}, e = 0; e < a.length; e++) {
    var f = a[e],
      g = b.call(c, f, e, a);
    goog.isDef(g) && (d[g] || (d[g] = [])).push(f);
  }
  return d;
};
goog.array.toObject = function (a, b, c) {
  var d = {};
  goog.array.forEach(a, function (e, f) {
    d[b.call(c, e, f, a)] = e;
  });
  return d;
};
goog.array.range = function (a, b, c) {
  var d = [],
    e = 0,
    f = a;
  c = c || 1;
  void 0 !== b && ((e = a), (f = b));
  if (0 > c * (f - e)) return [];
  if (0 < c) for (a = e; a < f; a += c) d.push(a);
  else for (a = e; a > f; a += c) d.push(a);
  return d;
};
goog.array.repeat = function (a, b) {
  for (var c = [], d = 0; d < b; d++) c[d] = a;
  return c;
};
goog.array.flatten = function (a) {
  for (var b = [], c = 0; c < arguments.length; c++) {
    var d = arguments[c];
    if (goog.isArray(d))
      for (var e = 0; e < d.length; e += 8192) {
        var f = goog.array.slice(d, e, e + 8192);
        f = goog.array.flatten.apply(null, f);
        for (var g = 0; g < f.length; g++) b.push(f[g]);
      }
    else b.push(d);
  }
  return b;
};
goog.array.rotate = function (a, b) {
  goog.asserts.assert(null != a.length);
  a.length &&
    ((b %= a.length),
    0 < b
      ? Array.prototype.unshift.apply(a, a.splice(-b, b))
      : 0 > b && Array.prototype.push.apply(a, a.splice(0, -b)));
  return a;
};
goog.array.moveItem = function (a, b, c) {
  goog.asserts.assert(0 <= b && b < a.length);
  goog.asserts.assert(0 <= c && c < a.length);
  b = Array.prototype.splice.call(a, b, 1);
  Array.prototype.splice.call(a, c, 0, b[0]);
};
goog.array.zip = function (a) {
  if (!arguments.length) return [];
  for (var b = [], c = arguments[0].length, d = 1; d < arguments.length; d++)
    arguments[d].length < c && (c = arguments[d].length);
  for (d = 0; d < c; d++) {
    for (var e = [], f = 0; f < arguments.length; f++) e.push(arguments[f][d]);
    b.push(e);
  }
  return b;
};
goog.array.shuffle = function (a, b) {
  b = b || Math.random;
  for (var c = a.length - 1; 0 < c; c--) {
    var d = Math.floor(b() * (c + 1)),
      e = a[c];
    a[c] = a[d];
    a[d] = e;
  }
};
goog.array.copyByIndex = function (a, b) {
  var c = [];
  goog.array.forEach(b, function (b) {
    c.push(a[b]);
  });
  return c;
};
goog.array.concatMap = function (a, b, c) {
  return goog.array.concat.apply([], goog.array.map(a, b, c));
};
goog.crypt = {};
goog.crypt.stringToByteArray = function (a) {
  for (var b = [], c = 0, d = 0; d < a.length; d++) {
    var e = a.charCodeAt(d);
    255 < e && ((b[c++] = e & 255), (e >>= 8));
    b[c++] = e;
  }
  return b;
};
goog.crypt.byteArrayToString = function (a) {
  if (8192 >= a.length) return String.fromCharCode.apply(null, a);
  for (var b = '', c = 0; c < a.length; c += 8192) {
    var d = goog.array.slice(a, c, c + 8192);
    b += String.fromCharCode.apply(null, d);
  }
  return b;
};
goog.crypt.byteArrayToHex = function (a, b) {
  return goog.array
    .map(a, function (a) {
      a = a.toString(16);
      return 1 < a.length ? a : '0' + a;
    })
    .join(b || '');
};
goog.crypt.hexToByteArray = function (a) {
  goog.asserts.assert(
    0 == a.length % 2,
    'Key string length must be multiple of 2'
  );
  for (var b = [], c = 0; c < a.length; c += 2)
    b.push(parseInt(a.substring(c, c + 2), 16));
  return b;
};
goog.crypt.stringToUtf8ByteArray = function (a) {
  for (var b = [], c = 0, d = 0; d < a.length; d++) {
    var e = a.charCodeAt(d);
    128 > e
      ? (b[c++] = e)
      : (2048 > e
          ? (b[c++] = (e >> 6) | 192)
          : (55296 == (e & 64512) &&
            d + 1 < a.length &&
            56320 == (a.charCodeAt(d + 1) & 64512)
              ? ((e = 65536 + ((e & 1023) << 10) + (a.charCodeAt(++d) & 1023)),
                (b[c++] = (e >> 18) | 240),
                (b[c++] = ((e >> 12) & 63) | 128))
              : (b[c++] = (e >> 12) | 224),
            (b[c++] = ((e >> 6) & 63) | 128)),
        (b[c++] = (e & 63) | 128));
  }
  return b;
};
goog.crypt.utf8ByteArrayToString = function (a) {
  for (var b = [], c = 0, d = 0; c < a.length; ) {
    var e = a[c++];
    if (128 > e) b[d++] = String.fromCharCode(e);
    else if (191 < e && 224 > e) {
      var f = a[c++];
      b[d++] = String.fromCharCode(((e & 31) << 6) | (f & 63));
    } else if (239 < e && 365 > e) {
      f = a[c++];
      var g = a[c++],
        h = a[c++];
      e =
        (((e & 7) << 18) | ((f & 63) << 12) | ((g & 63) << 6) | (h & 63)) -
        65536;
      b[d++] = String.fromCharCode(55296 + (e >> 10));
      b[d++] = String.fromCharCode(56320 + (e & 1023));
    } else
      (f = a[c++]),
        (g = a[c++]),
        (b[d++] = String.fromCharCode(
          ((e & 15) << 12) | ((f & 63) << 6) | (g & 63)
        ));
  }
  return b.join('');
};
goog.crypt.xorByteArray = function (a, b) {
  goog.asserts.assert(a.length == b.length, 'XOR array lengths must match');
  for (var c = [], d = 0; d < a.length; d++) c.push(a[d] ^ b[d]);
  return c;
};
goog.string = {};
goog.string.internal = {};
goog.string.internal.startsWith = function (a, b) {
  return 0 == a.lastIndexOf(b, 0);
};
goog.string.internal.endsWith = function (a, b) {
  var c = a.length - b.length;
  return 0 <= c && a.indexOf(b, c) == c;
};
goog.string.internal.caseInsensitiveStartsWith = function (a, b) {
  return (
    0 == goog.string.internal.caseInsensitiveCompare(b, a.substr(0, b.length))
  );
};
goog.string.internal.caseInsensitiveEndsWith = function (a, b) {
  return (
    0 ==
    goog.string.internal.caseInsensitiveCompare(
      b,
      a.substr(a.length - b.length, b.length)
    )
  );
};
goog.string.internal.caseInsensitiveEquals = function (a, b) {
  return a.toLowerCase() == b.toLowerCase();
};
goog.string.internal.isEmptyOrWhitespace = function (a) {
  return /^[\s\xa0]*$/.test(a);
};
goog.string.internal.trim =
  goog.TRUSTED_SITE && String.prototype.trim
    ? function (a) {
        return a.trim();
      }
    : function (a) {
        return /^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(a)[1];
      };
goog.string.internal.caseInsensitiveCompare = function (a, b) {
  a = String(a).toLowerCase();
  b = String(b).toLowerCase();
  return a < b ? -1 : a == b ? 0 : 1;
};
goog.string.internal.newLineToBr = function (a, b) {
  return a.replace(/(\r\n|\r|\n)/g, b ? '<br />' : '<br>');
};
goog.string.internal.htmlEscape = function (a, b) {
  if (b)
    a = a
      .replace(goog.string.internal.AMP_RE_, '&amp;')
      .replace(goog.string.internal.LT_RE_, '&lt;')
      .replace(goog.string.internal.GT_RE_, '&gt;')
      .replace(goog.string.internal.QUOT_RE_, '&quot;')
      .replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;')
      .replace(goog.string.internal.NULL_RE_, '&#0;');
  else {
    if (!goog.string.internal.ALL_RE_.test(a)) return a;
    -1 != a.indexOf('&') &&
      (a = a.replace(goog.string.internal.AMP_RE_, '&amp;'));
    -1 != a.indexOf('<') &&
      (a = a.replace(goog.string.internal.LT_RE_, '&lt;'));
    -1 != a.indexOf('>') &&
      (a = a.replace(goog.string.internal.GT_RE_, '&gt;'));
    -1 != a.indexOf('"') &&
      (a = a.replace(goog.string.internal.QUOT_RE_, '&quot;'));
    -1 != a.indexOf("'") &&
      (a = a.replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;'));
    -1 != a.indexOf('\x00') &&
      (a = a.replace(goog.string.internal.NULL_RE_, '&#0;'));
  }
  return a;
};
goog.string.internal.AMP_RE_ = /&/g;
goog.string.internal.LT_RE_ = /</g;
goog.string.internal.GT_RE_ = />/g;
goog.string.internal.QUOT_RE_ = /"/g;
goog.string.internal.SINGLE_QUOTE_RE_ = /'/g;
goog.string.internal.NULL_RE_ = /\x00/g;
goog.string.internal.ALL_RE_ = /[\x00&<>"']/;
goog.string.internal.whitespaceEscape = function (a, b) {
  return goog.string.internal.newLineToBr(a.replace(/  /g, ' &#160;'), b);
};
goog.string.internal.contains = function (a, b) {
  return -1 != a.indexOf(b);
};
goog.string.internal.caseInsensitiveContains = function (a, b) {
  return goog.string.internal.contains(a.toLowerCase(), b.toLowerCase());
};
goog.string.internal.compareVersions = function (a, b) {
  var c = 0;
  a = goog.string.internal.trim(String(a)).split('.');
  b = goog.string.internal.trim(String(b)).split('.');
  for (var d = Math.max(a.length, b.length), e = 0; 0 == c && e < d; e++) {
    var f = a[e] || '',
      g = b[e] || '';
    do {
      f = /(\d*)(\D*)(.*)/.exec(f) || ['', '', '', ''];
      g = /(\d*)(\D*)(.*)/.exec(g) || ['', '', '', ''];
      if (0 == f[0].length && 0 == g[0].length) break;
      c = 0 == f[1].length ? 0 : parseInt(f[1], 10);
      var h = 0 == g[1].length ? 0 : parseInt(g[1], 10);
      c =
        goog.string.internal.compareElements_(c, h) ||
        goog.string.internal.compareElements_(
          0 == f[2].length,
          0 == g[2].length
        ) ||
        goog.string.internal.compareElements_(f[2], g[2]);
      f = f[3];
      g = g[3];
    } while (0 == c);
  }
  return c;
};
goog.string.internal.compareElements_ = function (a, b) {
  return a < b ? -1 : a > b ? 1 : 0;
};
goog.string.TypedString = function () {};
goog.string.Const = function (a, b) {
  this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ =
    (a === goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_ && b) || '';
  this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ =
    goog.string.Const.TYPE_MARKER_;
};
goog.string.Const.prototype.implementsGoogStringTypedString = !0;
goog.string.Const.prototype.getTypedStringValue = function () {
  return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_;
};
goog.string.Const.prototype.toString = function () {
  return (
    'Const{' +
    this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ +
    '}'
  );
};
goog.string.Const.unwrap = function (a) {
  if (
    a instanceof goog.string.Const &&
    a.constructor === goog.string.Const &&
    a.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ ===
      goog.string.Const.TYPE_MARKER_
  )
    return a.stringConstValueWithSecurityContract__googStringSecurityPrivate_;
  goog.asserts.fail("expected object of type Const, got '" + a + "'");
  return 'type_error:Const';
};
goog.string.Const.from = function (a) {
  return new goog.string.Const(
    goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_,
    a
  );
};
goog.string.Const.TYPE_MARKER_ = {};
goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_ = {};
goog.string.Const.EMPTY = goog.string.Const.from('');
goog.fs = {};
goog.fs.url = {};
goog.fs.url.createObjectUrl = function (a) {
  return goog.fs.url.getUrlObject_().createObjectURL(a);
};
goog.fs.url.revokeObjectUrl = function (a) {
  goog.fs.url.getUrlObject_().revokeObjectURL(a);
};
goog.fs.url.getUrlObject_ = function () {
  var a = goog.fs.url.findUrlObject_();
  if (null != a) return a;
  throw Error("This browser doesn't seem to support blob URLs");
};
goog.fs.url.findUrlObject_ = function () {
  return goog.isDef(goog.global.URL) &&
    goog.isDef(goog.global.URL.createObjectURL)
    ? goog.global.URL
    : goog.isDef(goog.global.webkitURL) &&
      goog.isDef(goog.global.webkitURL.createObjectURL)
    ? goog.global.webkitURL
    : goog.isDef(goog.global.createObjectURL)
    ? goog.global
    : null;
};
goog.fs.url.browserSupportsObjectUrls = function () {
  return null != goog.fs.url.findUrlObject_();
};
goog.html = {};
goog.html.trustedtypes = {};
goog.html.trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY = goog.TRUSTED_TYPES_POLICY_NAME
  ? goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + '#html')
  : null;
goog.i18n = {};
goog.i18n.bidi = {};
goog.i18n.bidi.FORCE_RTL = !1;
goog.i18n.bidi.IS_RTL =
  goog.i18n.bidi.FORCE_RTL ||
  (('ar' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'fa' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'he' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'iw' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'ps' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'sd' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'ug' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'ur' == goog.LOCALE.substring(0, 2).toLowerCase() ||
    'yi' == goog.LOCALE.substring(0, 2).toLowerCase()) &&
    (2 == goog.LOCALE.length ||
      '-' == goog.LOCALE.substring(2, 3) ||
      '_' == goog.LOCALE.substring(2, 3))) ||
  (3 <= goog.LOCALE.length &&
    'ckb' == goog.LOCALE.substring(0, 3).toLowerCase() &&
    (3 == goog.LOCALE.length ||
      '-' == goog.LOCALE.substring(3, 4) ||
      '_' == goog.LOCALE.substring(3, 4))) ||
  (7 <= goog.LOCALE.length &&
    ('-' == goog.LOCALE.substring(2, 3) ||
      '_' == goog.LOCALE.substring(2, 3)) &&
    ('adlm' == goog.LOCALE.substring(3, 7).toLowerCase() ||
      'arab' == goog.LOCALE.substring(3, 7).toLowerCase() ||
      'hebr' == goog.LOCALE.substring(3, 7).toLowerCase() ||
      'nkoo' == goog.LOCALE.substring(3, 7).toLowerCase() ||
      'rohg' == goog.LOCALE.substring(3, 7).toLowerCase() ||
      'thaa' == goog.LOCALE.substring(3, 7).toLowerCase())) ||
  (8 <= goog.LOCALE.length &&
    ('-' == goog.LOCALE.substring(3, 4) ||
      '_' == goog.LOCALE.substring(3, 4)) &&
    ('adlm' == goog.LOCALE.substring(4, 8).toLowerCase() ||
      'arab' == goog.LOCALE.substring(4, 8).toLowerCase() ||
      'hebr' == goog.LOCALE.substring(4, 8).toLowerCase() ||
      'nkoo' == goog.LOCALE.substring(4, 8).toLowerCase() ||
      'rohg' == goog.LOCALE.substring(4, 8).toLowerCase() ||
      'thaa' == goog.LOCALE.substring(4, 8).toLowerCase()));
goog.i18n.bidi.Format = {
  LRE: '\u202a',
  RLE: '\u202b',
  PDF: '\u202c',
  LRM: '\u200e',
  RLM: '\u200f',
};
goog.i18n.bidi.Dir = {
  LTR: 1,
  RTL: -1,
  NEUTRAL: 0,
};
goog.i18n.bidi.RIGHT = 'right';
goog.i18n.bidi.LEFT = 'left';
goog.i18n.bidi.I18N_RIGHT = goog.i18n.bidi.IS_RTL
  ? goog.i18n.bidi.LEFT
  : goog.i18n.bidi.RIGHT;
goog.i18n.bidi.I18N_LEFT = goog.i18n.bidi.IS_RTL
  ? goog.i18n.bidi.RIGHT
  : goog.i18n.bidi.LEFT;
goog.i18n.bidi.toDir = function (a, b) {
  return 'number' == typeof a
    ? 0 < a
      ? goog.i18n.bidi.Dir.LTR
      : 0 > a
      ? goog.i18n.bidi.Dir.RTL
      : b
      ? null
      : goog.i18n.bidi.Dir.NEUTRAL
    : null == a
    ? null
    : a
    ? goog.i18n.bidi.Dir.RTL
    : goog.i18n.bidi.Dir.LTR;
};
goog.i18n.bidi.ltrChars_ =
  'A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0900-\u1fff\u200e\u2c00-\ud801\ud804-\ud839\ud83c-\udbff\uf900-\ufb1c\ufe00-\ufe6f\ufefd-\uffff';
goog.i18n.bidi.rtlChars_ =
  '\u0591-\u06ef\u06fa-\u08ff\u200f\ud802-\ud803\ud83a-\ud83b\ufb1d-\ufdff\ufe70-\ufefc';
goog.i18n.bidi.htmlSkipReg_ = /<[^>]*>|&[^;]+;/g;
goog.i18n.bidi.stripHtmlIfNeeded_ = function (a, b) {
  return b ? a.replace(goog.i18n.bidi.htmlSkipReg_, '') : a;
};
goog.i18n.bidi.rtlCharReg_ = new RegExp('[' + goog.i18n.bidi.rtlChars_ + ']');
goog.i18n.bidi.ltrCharReg_ = new RegExp('[' + goog.i18n.bidi.ltrChars_ + ']');
goog.i18n.bidi.hasAnyRtl = function (a, b) {
  return goog.i18n.bidi.rtlCharReg_.test(
    goog.i18n.bidi.stripHtmlIfNeeded_(a, b)
  );
};
goog.i18n.bidi.hasRtlChar = goog.i18n.bidi.hasAnyRtl;
goog.i18n.bidi.hasAnyLtr = function (a, b) {
  return goog.i18n.bidi.ltrCharReg_.test(
    goog.i18n.bidi.stripHtmlIfNeeded_(a, b)
  );
};
goog.i18n.bidi.ltrRe_ = new RegExp('^[' + goog.i18n.bidi.ltrChars_ + ']');
goog.i18n.bidi.rtlRe_ = new RegExp('^[' + goog.i18n.bidi.rtlChars_ + ']');
goog.i18n.bidi.isRtlChar = function (a) {
  return goog.i18n.bidi.rtlRe_.test(a);
};
goog.i18n.bidi.isLtrChar = function (a) {
  return goog.i18n.bidi.ltrRe_.test(a);
};
goog.i18n.bidi.isNeutralChar = function (a) {
  return !goog.i18n.bidi.isLtrChar(a) && !goog.i18n.bidi.isRtlChar(a);
};
goog.i18n.bidi.ltrDirCheckRe_ = new RegExp(
  '^[^' + goog.i18n.bidi.rtlChars_ + ']*[' + goog.i18n.bidi.ltrChars_ + ']'
);
goog.i18n.bidi.rtlDirCheckRe_ = new RegExp(
  '^[^' + goog.i18n.bidi.ltrChars_ + ']*[' + goog.i18n.bidi.rtlChars_ + ']'
);
goog.i18n.bidi.startsWithRtl = function (a, b) {
  return goog.i18n.bidi.rtlDirCheckRe_.test(
    goog.i18n.bidi.stripHtmlIfNeeded_(a, b)
  );
};
goog.i18n.bidi.isRtlText = goog.i18n.bidi.startsWithRtl;
goog.i18n.bidi.startsWithLtr = function (a, b) {
  return goog.i18n.bidi.ltrDirCheckRe_.test(
    goog.i18n.bidi.stripHtmlIfNeeded_(a, b)
  );
};
goog.i18n.bidi.isLtrText = goog.i18n.bidi.startsWithLtr;
goog.i18n.bidi.isRequiredLtrRe_ = /^http:\/\/.*/;
goog.i18n.bidi.isNeutralText = function (a, b) {
  a = goog.i18n.bidi.stripHtmlIfNeeded_(a, b);
  return (
    goog.i18n.bidi.isRequiredLtrRe_.test(a) ||
    (!goog.i18n.bidi.hasAnyLtr(a) && !goog.i18n.bidi.hasAnyRtl(a))
  );
};
goog.i18n.bidi.ltrExitDirCheckRe_ = new RegExp(
  '[' + goog.i18n.bidi.ltrChars_ + '][^' + goog.i18n.bidi.rtlChars_ + ']*$'
);
goog.i18n.bidi.rtlExitDirCheckRe_ = new RegExp(
  '[' + goog.i18n.bidi.rtlChars_ + '][^' + goog.i18n.bidi.ltrChars_ + ']*$'
);
goog.i18n.bidi.endsWithLtr = function (a, b) {
  return goog.i18n.bidi.ltrExitDirCheckRe_.test(
    goog.i18n.bidi.stripHtmlIfNeeded_(a, b)
  );
};
goog.i18n.bidi.isLtrExitText = goog.i18n.bidi.endsWithLtr;
goog.i18n.bidi.endsWithRtl = function (a, b) {
  return goog.i18n.bidi.rtlExitDirCheckRe_.test(
    goog.i18n.bidi.stripHtmlIfNeeded_(a, b)
  );
};
goog.i18n.bidi.isRtlExitText = goog.i18n.bidi.endsWithRtl;
goog.i18n.bidi.rtlLocalesRe_ = /^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i;
goog.i18n.bidi.isRtlLanguage = function (a) {
  return goog.i18n.bidi.rtlLocalesRe_.test(a);
};
goog.i18n.bidi.bracketGuardTextRe_ = /(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(<.*?>+)/g;
goog.i18n.bidi.guardBracketInText = function (a, b) {
  b = (void 0 === b ? goog.i18n.bidi.hasAnyRtl(a) : b)
    ? goog.i18n.bidi.Format.RLM
    : goog.i18n.bidi.Format.LRM;
  return a.replace(goog.i18n.bidi.bracketGuardTextRe_, b + '$&' + b);
};
goog.i18n.bidi.enforceRtlInHtml = function (a) {
  return '<' == a.charAt(0)
    ? a.replace(/<\w+/, '$& dir=rtl')
    : '\n<span dir=rtl>' + a + '</span>';
};
goog.i18n.bidi.enforceRtlInText = function (a) {
  return goog.i18n.bidi.Format.RLE + a + goog.i18n.bidi.Format.PDF;
};
goog.i18n.bidi.enforceLtrInHtml = function (a) {
  return '<' == a.charAt(0)
    ? a.replace(/<\w+/, '$& dir=ltr')
    : '\n<span dir=ltr>' + a + '</span>';
};
goog.i18n.bidi.enforceLtrInText = function (a) {
  return goog.i18n.bidi.Format.LRE + a + goog.i18n.bidi.Format.PDF;
};
goog.i18n.bidi.dimensionsRe_ = /:\s*([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)/g;
goog.i18n.bidi.leftRe_ = /left/gi;
goog.i18n.bidi.rightRe_ = /right/gi;
goog.i18n.bidi.tempRe_ = /%%%%/g;
goog.i18n.bidi.mirrorCSS = function (a) {
  return a
    .replace(goog.i18n.bidi.dimensionsRe_, ':$1 $4 $3 $2')
    .replace(goog.i18n.bidi.leftRe_, '%%%%')
    .replace(goog.i18n.bidi.rightRe_, goog.i18n.bidi.LEFT)
    .replace(goog.i18n.bidi.tempRe_, goog.i18n.bidi.RIGHT);
};
goog.i18n.bidi.doubleQuoteSubstituteRe_ = /([\u0591-\u05f2])"/g;
goog.i18n.bidi.singleQuoteSubstituteRe_ = /([\u0591-\u05f2])'/g;
goog.i18n.bidi.normalizeHebrewQuote = function (a) {
  return a
    .replace(goog.i18n.bidi.doubleQuoteSubstituteRe_, '$1\u05f4')
    .replace(goog.i18n.bidi.singleQuoteSubstituteRe_, '$1\u05f3');
};
goog.i18n.bidi.wordSeparatorRe_ = /\s+/;
goog.i18n.bidi.hasNumeralsRe_ = /[\d\u06f0-\u06f9]/;
goog.i18n.bidi.rtlDetectionThreshold_ = 0.4;
goog.i18n.bidi.estimateDirection = function (a, b) {
  var c = 0,
    d = 0,
    e = !1;
  a = goog.i18n.bidi
    .stripHtmlIfNeeded_(a, b)
    .split(goog.i18n.bidi.wordSeparatorRe_);
  for (b = 0; b < a.length; b++) {
    var f = a[b];
    goog.i18n.bidi.startsWithRtl(f)
      ? (c++, d++)
      : goog.i18n.bidi.isRequiredLtrRe_.test(f)
      ? (e = !0)
      : goog.i18n.bidi.hasAnyLtr(f)
      ? d++
      : goog.i18n.bidi.hasNumeralsRe_.test(f) && (e = !0);
  }
  return 0 == d
    ? e
      ? goog.i18n.bidi.Dir.LTR
      : goog.i18n.bidi.Dir.NEUTRAL
    : c / d > goog.i18n.bidi.rtlDetectionThreshold_
    ? goog.i18n.bidi.Dir.RTL
    : goog.i18n.bidi.Dir.LTR;
};
goog.i18n.bidi.detectRtlDirectionality = function (a, b) {
  return goog.i18n.bidi.estimateDirection(a, b) == goog.i18n.bidi.Dir.RTL;
};
goog.i18n.bidi.setElementDirAndAlign = function (a, b) {
  a &&
    (b = goog.i18n.bidi.toDir(b)) &&
    ((a.style.textAlign =
      b == goog.i18n.bidi.Dir.RTL ? goog.i18n.bidi.RIGHT : goog.i18n.bidi.LEFT),
    (a.dir = b == goog.i18n.bidi.Dir.RTL ? 'rtl' : 'ltr'));
};
goog.i18n.bidi.setElementDirByTextDirectionality = function (a, b) {
  switch (goog.i18n.bidi.estimateDirection(b)) {
    case goog.i18n.bidi.Dir.LTR:
      a.dir = 'ltr';
      break;
    case goog.i18n.bidi.Dir.RTL:
      a.dir = 'rtl';
      break;
    default:
      a.removeAttribute('dir');
  }
};
goog.i18n.bidi.DirectionalString = function () {};
goog.html.TrustedResourceUrl = function () {
  this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ = '';
  this.trustedURL_ = null;
  this.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ =
    goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString = !0;
goog.html.TrustedResourceUrl.prototype.getTypedStringValue = function () {
  return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_.toString();
};
goog.html.TrustedResourceUrl.prototype.implementsGoogI18nBidiDirectionalString = !0;
goog.html.TrustedResourceUrl.prototype.getDirection = function () {
  return goog.i18n.bidi.Dir.LTR;
};
goog.html.TrustedResourceUrl.prototype.cloneWithParams = function (a, b) {
  var c = goog.html.TrustedResourceUrl.unwrap(this);
  c = goog.html.TrustedResourceUrl.URL_PARAM_PARSER_.exec(c);
  var d = c[3] || '';
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(
    c[1] +
      goog.html.TrustedResourceUrl.stringifyParams_('?', c[2] || '', a) +
      goog.html.TrustedResourceUrl.stringifyParams_('#', d, b)
  );
};
goog.DEBUG &&
  (goog.html.TrustedResourceUrl.prototype.toString = function () {
    return (
      'TrustedResourceUrl{' +
      this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ +
      '}'
    );
  });
goog.html.TrustedResourceUrl.unwrap = function (a) {
  return goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(a).toString();
};
goog.html.TrustedResourceUrl.unwrapTrustedScriptURL = function (a) {
  if (
    a instanceof goog.html.TrustedResourceUrl &&
    a.constructor === goog.html.TrustedResourceUrl &&
    a.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ ===
      goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_
  )
    return a.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;
  goog.asserts.fail(
    "expected object of type TrustedResourceUrl, got '" +
      a +
      "' of type " +
      goog.typeOf(a)
  );
  return 'type_error:TrustedResourceUrl';
};
goog.html.TrustedResourceUrl.unwrapTrustedURL = function (a) {
  return a.trustedURL_ ? a.trustedURL_ : goog.html.TrustedResourceUrl.unwrap(a);
};
goog.html.TrustedResourceUrl.format = function (a, b) {
  var c = goog.string.Const.unwrap(a);
  if (!goog.html.TrustedResourceUrl.BASE_URL_.test(c))
    throw Error('Invalid TrustedResourceUrl format: ' + c);
  a = c.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_, function (a, e) {
    if (!Object.prototype.hasOwnProperty.call(b, e))
      throw Error(
        'Found marker, "' +
          e +
          '", in format string, "' +
          c +
          '", but no valid label mapping found in args: ' +
          JSON.stringify(b)
      );
    a = b[e];
    return a instanceof goog.string.Const
      ? goog.string.Const.unwrap(a)
      : encodeURIComponent(String(a));
  });
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(
    a
  );
};
goog.html.TrustedResourceUrl.FORMAT_MARKER_ = /%{(\w+)}/g;
goog.html.TrustedResourceUrl.BASE_URL_ = /^((https:)?\/\/[0-9a-z.:[\]-]+\/|\/[^/\\]|[^:/\\%]+\/|[^:/\\%]*[?#]|about:blank#)/i;
goog.html.TrustedResourceUrl.URL_PARAM_PARSER_ = /^([^?#]*)(\?[^#]*)?(#[\s\S]*)?/;
goog.html.TrustedResourceUrl.formatWithParams = function (a, b, c, d) {
  return goog.html.TrustedResourceUrl.format(a, b).cloneWithParams(c, d);
};
goog.html.TrustedResourceUrl.fromConstant = function (a) {
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(
    goog.string.Const.unwrap(a)
  );
};
goog.html.TrustedResourceUrl.fromConstants = function (a) {
  for (var b = '', c = 0; c < a.length; c++)
    b += goog.string.Const.unwrap(a[c]);
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(
    b
  );
};
goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse = function (
  a
) {
  var b = new goog.html.TrustedResourceUrl();
  b.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ = goog.html
    .trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY
    ? goog.html.trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY.createScriptURL(
        a
      )
    : a;
  goog.html.trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY &&
    (b.trustedURL_ = goog.html.trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY.createURL(
      a
    ));
  return b;
};
goog.html.TrustedResourceUrl.stringifyParams_ = function (a, b, c) {
  if (null == c) return b;
  if (goog.isString(c)) return c ? a + encodeURIComponent(c) : '';
  for (var d in c) {
    var e = c[d];
    e = goog.isArray(e) ? e : [e];
    for (var f = 0; f < e.length; f++) {
      var g = e[f];
      null != g &&
        (b || (b = a),
        (b +=
          (b.length > a.length ? '&' : '') +
          encodeURIComponent(d) +
          '=' +
          encodeURIComponent(String(g))));
    }
  }
  return b;
};
goog.html.SafeUrl = function () {
  this.privateDoNotAccessOrElseSafeUrlWrappedValue_ = '';
  this.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ =
    goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeUrl.INNOCUOUS_STRING = 'about:invalid#zClosurez';
goog.html.SafeUrl.prototype.implementsGoogStringTypedString = !0;
goog.html.SafeUrl.prototype.getTypedStringValue = function () {
  return this.privateDoNotAccessOrElseSafeUrlWrappedValue_.toString();
};
goog.html.SafeUrl.prototype.implementsGoogI18nBidiDirectionalString = !0;
goog.html.SafeUrl.prototype.getDirection = function () {
  return goog.i18n.bidi.Dir.LTR;
};
goog.DEBUG &&
  (goog.html.SafeUrl.prototype.toString = function () {
    return 'SafeUrl{' + this.privateDoNotAccessOrElseSafeUrlWrappedValue_ + '}';
  });
goog.html.SafeUrl.unwrap = function (a) {
  return goog.html.SafeUrl.unwrapTrustedURL(a).toString();
};
goog.html.SafeUrl.unwrapTrustedURL = function (a) {
  if (
    a instanceof goog.html.SafeUrl &&
    a.constructor === goog.html.SafeUrl &&
    a.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ ===
      goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_
  )
    return a.privateDoNotAccessOrElseSafeUrlWrappedValue_;
  goog.asserts.fail(
    "expected object of type SafeUrl, got '" + a + "' of type " + goog.typeOf(a)
  );
  return 'type_error:SafeUrl';
};
goog.html.SafeUrl.fromConstant = function (a) {
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(
    goog.string.Const.unwrap(a)
  );
};
goog.html.SAFE_MIME_TYPE_PATTERN_ = /^(?:audio\/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-wav|wav|webm)|image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp|x-icon)|text\/csv|video\/(?:mpeg|mp4|ogg|webm|quicktime))(?:;\w+=(?:\w+|"[\w;=]+"))*$/i;
goog.html.SafeUrl.isSafeMimeType = function (a) {
  return goog.html.SAFE_MIME_TYPE_PATTERN_.test(a);
};
goog.html.SafeUrl.fromBlob = function (a) {
  a = goog.html.SAFE_MIME_TYPE_PATTERN_.test(a.type)
    ? goog.fs.url.createObjectUrl(a)
    : goog.html.SafeUrl.INNOCUOUS_STRING;
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.DATA_URL_PATTERN_ = /^data:([^,]*);base64,[a-z0-9+\/]+=*$/i;
goog.html.SafeUrl.fromDataUrl = function (a) {
  a = a.replace(/(%0A|%0D)/g, '');
  var b = a.match(goog.html.DATA_URL_PATTERN_);
  b = b && goog.html.SAFE_MIME_TYPE_PATTERN_.test(b[1]);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(
    b ? a : goog.html.SafeUrl.INNOCUOUS_STRING
  );
};
goog.html.SafeUrl.fromTelUrl = function (a) {
  goog.string.internal.caseInsensitiveStartsWith(a, 'tel:') ||
    (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SIP_URL_PATTERN_ = /^sip[s]?:[+a-z0-9_.!$%&'*\/=^`{|}~-]+@([a-z0-9-]+\.)+[a-z0-9]{2,63}$/i;
goog.html.SafeUrl.fromSipUrl = function (a) {
  goog.html.SIP_URL_PATTERN_.test(decodeURIComponent(a)) ||
    (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeUrl.fromFacebookMessengerUrl = function (a) {
  goog.string.internal.caseInsensitiveStartsWith(a, 'fb-messenger://share') ||
    (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeUrl.fromWhatsAppUrl = function (a) {
  goog.string.internal.caseInsensitiveStartsWith(a, 'whatsapp://send') ||
    (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeUrl.fromSmsUrl = function (a) {
  (goog.string.internal.caseInsensitiveStartsWith(a, 'sms:') &&
    goog.html.SafeUrl.isSmsUrlBodyValid_(a)) ||
    (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeUrl.isSmsUrlBodyValid_ = function (a) {
  var b = a.indexOf('#');
  0 < b && (a = a.substring(0, b));
  b = a.match(/[?&]body=/gi);
  if (!b) return !0;
  if (1 < b.length) return !1;
  a = a.match(/[?&]body=([^&]*)/)[1];
  if (!a) return !0;
  try {
    decodeURIComponent(a);
  } catch (c) {
    return !1;
  }
  return /^(?:[a-z0-9\-_.~]|%[0-9a-f]{2})+$/i.test(a);
};
goog.html.SafeUrl.fromSshUrl = function (a) {
  goog.string.internal.caseInsensitiveStartsWith(a, 'ssh://') ||
    (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeUrl.sanitizeChromeExtensionUrl = function (a, b) {
  return goog.html.SafeUrl.sanitizeExtensionUrl_(
    /^chrome-extension:\/\/([^\/]+)\//,
    a,
    b
  );
};
goog.html.SafeUrl.sanitizeFirefoxExtensionUrl = function (a, b) {
  return goog.html.SafeUrl.sanitizeExtensionUrl_(
    /^moz-extension:\/\/([^\/]+)\//,
    a,
    b
  );
};
goog.html.SafeUrl.sanitizeEdgeExtensionUrl = function (a, b) {
  return goog.html.SafeUrl.sanitizeExtensionUrl_(
    /^ms-browser-extension:\/\/([^\/]+)\//,
    a,
    b
  );
};
goog.html.SafeUrl.sanitizeExtensionUrl_ = function (a, b, c) {
  (a = a.exec(b))
    ? ((a = a[1]),
      -1 ==
        (c instanceof goog.string.Const
          ? [goog.string.Const.unwrap(c)]
          : c.map(function (a) {
              return goog.string.Const.unwrap(a);
            })
        ).indexOf(a) && (b = goog.html.SafeUrl.INNOCUOUS_STRING))
    : (b = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b);
};
goog.html.SafeUrl.fromTrustedResourceUrl = function (a) {
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(
    goog.html.TrustedResourceUrl.unwrap(a)
  );
};
goog.html.SAFE_URL_PATTERN_ = /^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;
goog.html.SafeUrl.SAFE_URL_PATTERN = goog.html.SAFE_URL_PATTERN_;
goog.html.SafeUrl.sanitize = function (a) {
  if (a instanceof goog.html.SafeUrl) return a;
  a =
    'object' == typeof a && a.implementsGoogStringTypedString
      ? a.getTypedStringValue()
      : String(a);
  goog.html.SAFE_URL_PATTERN_.test(a) ||
    (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeUrl.sanitizeAssertUnchanged = function (a, b) {
  if (a instanceof goog.html.SafeUrl) return a;
  a =
    'object' == typeof a && a.implementsGoogStringTypedString
      ? a.getTypedStringValue()
      : String(a);
  if (
    b &&
    /^data:/i.test(a) &&
    ((b = goog.html.SafeUrl.fromDataUrl(a)), b.getTypedStringValue() == a)
  )
    return b;
  goog.asserts.assert(
    goog.html.SAFE_URL_PATTERN_.test(a),
    '%s does not match the safe URL pattern',
    a
  ) || (a = goog.html.SafeUrl.INNOCUOUS_STRING);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse = function (a) {
  var b = new goog.html.SafeUrl();
  b.privateDoNotAccessOrElseSafeUrlWrappedValue_ = goog.html.trustedtypes
    .PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY
    ? goog.html.trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY.createURL(a)
    : a;
  return b;
};
goog.html.SafeUrl.ABOUT_BLANK = goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(
  'about:blank'
);
goog.html.SafeStyle = function () {
  this.privateDoNotAccessOrElseSafeStyleWrappedValue_ = '';
  this.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ =
    goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeStyle.prototype.implementsGoogStringTypedString = !0;
goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeStyle.fromConstant = function (a) {
  a = goog.string.Const.unwrap(a);
  if (0 === a.length) return goog.html.SafeStyle.EMPTY;
  goog.asserts.assert(
    goog.string.internal.endsWith(a, ';'),
    "Last character of style string is not ';': " + a
  );
  goog.asserts.assert(
    goog.string.internal.contains(a, ':'),
    'Style string must contain at least one \':\', to specify a "name: value" pair: ' +
      a
  );
  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeStyle.prototype.getTypedStringValue = function () {
  return this.privateDoNotAccessOrElseSafeStyleWrappedValue_;
};
goog.DEBUG &&
  (goog.html.SafeStyle.prototype.toString = function () {
    return (
      'SafeStyle{' + this.privateDoNotAccessOrElseSafeStyleWrappedValue_ + '}'
    );
  });
goog.html.SafeStyle.unwrap = function (a) {
  if (
    a instanceof goog.html.SafeStyle &&
    a.constructor === goog.html.SafeStyle &&
    a.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ ===
      goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_
  )
    return a.privateDoNotAccessOrElseSafeStyleWrappedValue_;
  goog.asserts.fail(
    "expected object of type SafeStyle, got '" +
      a +
      "' of type " +
      goog.typeOf(a)
  );
  return 'type_error:SafeStyle';
};
goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse = function (
  a
) {
  return new goog.html.SafeStyle().initSecurityPrivateDoNotAccessOrElse_(a);
};
goog.html.SafeStyle.prototype.initSecurityPrivateDoNotAccessOrElse_ = function (
  a
) {
  this.privateDoNotAccessOrElseSafeStyleWrappedValue_ = a;
  return this;
};
goog.html.SafeStyle.EMPTY = goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(
  ''
);
goog.html.SafeStyle.INNOCUOUS_STRING = 'zClosurez';
goog.html.SafeStyle.create = function (a) {
  var b = '',
    c;
  for (c in a) {
    if (!/^[-_a-zA-Z0-9]+$/.test(c))
      throw Error('Name allows only [-_a-zA-Z0-9], got: ' + c);
    var d = a[c];
    null != d &&
      ((d = goog.isArray(d)
        ? goog.array
            .map(d, goog.html.SafeStyle.sanitizePropertyValue_)
            .join(' ')
        : goog.html.SafeStyle.sanitizePropertyValue_(d)),
      (b += c + ':' + d + ';'));
  }
  return b
    ? goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)
    : goog.html.SafeStyle.EMPTY;
};
goog.html.SafeStyle.sanitizePropertyValue_ = function (a) {
  if (a instanceof goog.html.SafeUrl)
    return (
      'url("' +
      goog.html.SafeUrl.unwrap(a)
        .replace(/</g, '%3c')
        .replace(/[\\"]/g, '\\$&') +
      '")'
    );
  a =
    a instanceof goog.string.Const
      ? goog.string.Const.unwrap(a)
      : goog.html.SafeStyle.sanitizePropertyValueString_(String(a));
  if (/[{;}]/.test(a))
    throw new goog.asserts.AssertionError(
      'Value does not allow [{;}], got: %s.',
      [a]
    );
  return a;
};
goog.html.SafeStyle.sanitizePropertyValueString_ = function (a) {
  var b = a
    .replace(goog.html.SafeStyle.FUNCTIONS_RE_, '$1')
    .replace(goog.html.SafeStyle.FUNCTIONS_RE_, '$1')
    .replace(goog.html.SafeStyle.URL_RE_, 'url');
  if (goog.html.SafeStyle.VALUE_RE_.test(b)) {
    if (goog.html.SafeStyle.COMMENT_RE_.test(a))
      return (
        goog.asserts.fail('String value disallows comments, got: ' + a),
        goog.html.SafeStyle.INNOCUOUS_STRING
      );
    if (!goog.html.SafeStyle.hasBalancedQuotes_(a))
      return (
        goog.asserts.fail('String value requires balanced quotes, got: ' + a),
        goog.html.SafeStyle.INNOCUOUS_STRING
      );
    if (!goog.html.SafeStyle.hasBalancedSquareBrackets_(a))
      return (
        goog.asserts.fail(
          'String value requires balanced square brackets and one identifier per pair of brackets, got: ' +
            a
        ),
        goog.html.SafeStyle.INNOCUOUS_STRING
      );
  } else
    return (
      goog.asserts.fail(
        'String value allows only ' +
          goog.html.SafeStyle.VALUE_ALLOWED_CHARS_ +
          ' and simple functions, got: ' +
          a
      ),
      goog.html.SafeStyle.INNOCUOUS_STRING
    );
  return goog.html.SafeStyle.sanitizeUrl_(a);
};
goog.html.SafeStyle.hasBalancedQuotes_ = function (a) {
  for (var b = !0, c = !0, d = 0; d < a.length; d++) {
    var e = a.charAt(d);
    "'" == e && c ? (b = !b) : '"' == e && b && (c = !c);
  }
  return b && c;
};
goog.html.SafeStyle.hasBalancedSquareBrackets_ = function (a) {
  for (var b = !0, c = /^[-_a-zA-Z0-9]$/, d = 0; d < a.length; d++) {
    var e = a.charAt(d);
    if (']' == e) {
      if (b) return !1;
      b = !0;
    } else if ('[' == e) {
      if (!b) return !1;
      b = !1;
    } else if (!b && !c.test(e)) return !1;
  }
  return b;
};
goog.html.SafeStyle.VALUE_ALLOWED_CHARS_ = '[-,."\'%_!# a-zA-Z0-9\\[\\]]';
goog.html.SafeStyle.VALUE_RE_ = new RegExp(
  '^' + goog.html.SafeStyle.VALUE_ALLOWED_CHARS_ + '+$'
);
goog.html.SafeStyle.URL_RE_ = /\b(url\([ \t\n]*)('[ -&(-\[\]-~]*'|"[ !#-\[\]-~]*"|[!#-&*-\[\]-~]*)([ \t\n]*\))/g;
goog.html.SafeStyle.FUNCTIONS_RE_ = /\b(hsl|hsla|rgb|rgba|matrix|calc|minmax|fit-content|repeat|(rotate|scale|translate)(X|Y|Z|3d)?)\([-+*/0-9a-z.%\[\], ]+\)/g;
goog.html.SafeStyle.COMMENT_RE_ = /\/\*/;
goog.html.SafeStyle.sanitizeUrl_ = function (a) {
  return a.replace(goog.html.SafeStyle.URL_RE_, function (a, c, d, e) {
    var b = '';
    d = d.replace(/^(['"])(.*)\1$/, function (a, c, d) {
      b = c;
      return d;
    });
    a = goog.html.SafeUrl.sanitize(d).getTypedStringValue();
    return c + b + a + b + e;
  });
};
goog.html.SafeStyle.concat = function (a) {
  var b = '',
    c = function (a) {
      goog.isArray(a)
        ? goog.array.forEach(a, c)
        : (b += goog.html.SafeStyle.unwrap(a));
    };
  goog.array.forEach(arguments, c);
  return b
    ? goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)
    : goog.html.SafeStyle.EMPTY;
};
goog.html.SafeScript = function () {
  this.privateDoNotAccessOrElseSafeScriptWrappedValue_ = '';
  this.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ =
    goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeScript.prototype.implementsGoogStringTypedString = !0;
goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeScript.fromConstant = function (a) {
  a = goog.string.Const.unwrap(a);
  return 0 === a.length
    ? goog.html.SafeScript.EMPTY
    : goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(a);
};
goog.html.SafeScript.fromConstantAndArgs = function (a, b) {
  for (var c = [], d = 1; d < arguments.length; d++)
    c.push(goog.html.SafeScript.stringify_(arguments[d]));
  return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(
    '(' + goog.string.Const.unwrap(a) + ')(' + c.join(', ') + ');'
  );
};
goog.html.SafeScript.fromJson = function (a) {
  return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(
    goog.html.SafeScript.stringify_(a)
  );
};
goog.html.SafeScript.prototype.getTypedStringValue = function () {
  return this.privateDoNotAccessOrElseSafeScriptWrappedValue_.toString();
};
goog.DEBUG &&
  (goog.html.SafeScript.prototype.toString = function () {
    return (
      'SafeScript{' + this.privateDoNotAccessOrElseSafeScriptWrappedValue_ + '}'
    );
  });
goog.html.SafeScript.unwrap = function (a) {
  return goog.html.SafeScript.unwrapTrustedScript(a).toString();
};
goog.html.SafeScript.unwrapTrustedScript = function (a) {
  if (
    a instanceof goog.html.SafeScript &&
    a.constructor === goog.html.SafeScript &&
    a.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ ===
      goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_
  )
    return a.privateDoNotAccessOrElseSafeScriptWrappedValue_;
  goog.asserts.fail(
    "expected object of type SafeScript, got '" +
      a +
      "' of type " +
      goog.typeOf(a)
  );
  return 'type_error:SafeScript';
};
goog.html.SafeScript.stringify_ = function (a) {
  return JSON.stringify(a).replace(/</g, '\\x3c');
};
goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse = function (
  a
) {
  return new goog.html.SafeScript().initSecurityPrivateDoNotAccessOrElse_(a);
};
goog.html.SafeScript.prototype.initSecurityPrivateDoNotAccessOrElse_ = function (
  a
) {
  this.privateDoNotAccessOrElseSafeScriptWrappedValue_ = goog.html.trustedtypes
    .PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY
    ? goog.html.trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY.createScript(
        a
      )
    : a;
  return this;
};
goog.html.SafeScript.EMPTY = goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(
  ''
);
goog.object = {};
goog.object.is = function (a, b) {
  return a === b ? 0 !== a || 1 / a === 1 / b : a !== a && b !== b;
};
goog.object.forEach = function (a, b, c) {
  for (var d in a) b.call(c, a[d], d, a);
};
goog.object.filter = function (a, b, c) {
  var d = {},
    e;
  for (e in a) b.call(c, a[e], e, a) && (d[e] = a[e]);
  return d;
};
goog.object.map = function (a, b, c) {
  var d = {},
    e;
  for (e in a) d[e] = b.call(c, a[e], e, a);
  return d;
};
goog.object.some = function (a, b, c) {
  for (var d in a) if (b.call(c, a[d], d, a)) return !0;
  return !1;
};
goog.object.every = function (a, b, c) {
  for (var d in a) if (!b.call(c, a[d], d, a)) return !1;
  return !0;
};
goog.object.getCount = function (a) {
  var b = 0,
    c;
  for (c in a) b++;
  return b;
};
goog.object.getAnyKey = function (a) {
  for (var b in a) return b;
};
goog.object.getAnyValue = function (a) {
  for (var b in a) return a[b];
};
goog.object.contains = function (a, b) {
  return goog.object.containsValue(a, b);
};
goog.object.getValues = function (a) {
  var b = [],
    c = 0,
    d;
  for (d in a) b[c++] = a[d];
  return b;
};
goog.object.getKeys = function (a) {
  var b = [],
    c = 0,
    d;
  for (d in a) b[c++] = d;
  return b;
};
goog.object.getValueByKeys = function (a, b) {
  var c = goog.isArrayLike(b),
    d = c ? b : arguments;
  for (c = c ? 0 : 1; c < d.length; c++) {
    if (null == a) return;
    a = a[d[c]];
  }
  return a;
};
goog.object.containsKey = function (a, b) {
  return null !== a && b in a;
};
goog.object.containsValue = function (a, b) {
  for (var c in a) if (a[c] == b) return !0;
  return !1;
};
goog.object.findKey = function (a, b, c) {
  for (var d in a) if (b.call(c, a[d], d, a)) return d;
};
goog.object.findValue = function (a, b, c) {
  return (b = goog.object.findKey(a, b, c)) && a[b];
};
goog.object.isEmpty = function (a) {
  for (var b in a) return !1;
  return !0;
};
goog.object.clear = function (a) {
  for (var b in a) delete a[b];
};
goog.object.remove = function (a, b) {
  var c;
  (c = b in a) && delete a[b];
  return c;
};
goog.object.add = function (a, b, c) {
  if (null !== a && b in a)
    throw Error('The object already contains the key "' + b + '"');
  goog.object.set(a, b, c);
};
goog.object.get = function (a, b, c) {
  return null !== a && b in a ? a[b] : c;
};
goog.object.set = function (a, b, c) {
  a[b] = c;
};
goog.object.setIfUndefined = function (a, b, c) {
  return b in a ? a[b] : (a[b] = c);
};
goog.object.setWithReturnValueIfNotSet = function (a, b, c) {
  if (b in a) return a[b];
  c = c();
  return (a[b] = c);
};
goog.object.equals = function (a, b) {
  for (var c in a) if (!(c in b) || a[c] !== b[c]) return !1;
  for (var d in b) if (!(d in a)) return !1;
  return !0;
};
goog.object.clone = function (a) {
  var b = {},
    c;
  for (c in a) b[c] = a[c];
  return b;
};
goog.object.unsafeClone = function (a) {
  var b = goog.typeOf(a);
  if ('object' == b || 'array' == b) {
    if (goog.isFunction(a.clone)) return a.clone();
    b = 'array' == b ? [] : {};
    for (var c in a) b[c] = goog.object.unsafeClone(a[c]);
    return b;
  }
  return a;
};
goog.object.transpose = function (a) {
  var b = {},
    c;
  for (c in a) b[a[c]] = c;
  return b;
};
goog.object.PROTOTYPE_FIELDS_ = 'constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf'.split(
  ' '
);
goog.object.extend = function (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 < goog.object.PROTOTYPE_FIELDS_.length; f++)
      (c = goog.object.PROTOTYPE_FIELDS_[f]),
        Object.prototype.hasOwnProperty.call(d, c) && (a[c] = d[c]);
  }
};
goog.object.create = function (a) {
  var b = arguments.length;
  if (1 == b && goog.isArray(arguments[0]))
    return goog.object.create.apply(null, arguments[0]);
  if (b % 2) throw Error('Uneven number of arguments');
  for (var c = {}, d = 0; d < b; d += 2) c[arguments[d]] = arguments[d + 1];
  return c;
};
goog.object.createSet = function (a) {
  var b = arguments.length;
  if (1 == b && goog.isArray(arguments[0]))
    return goog.object.createSet.apply(null, arguments[0]);
  for (var c = {}, d = 0; d < b; d++) c[arguments[d]] = !0;
  return c;
};
goog.object.createImmutableView = function (a) {
  var b = a;
  Object.isFrozen &&
    !Object.isFrozen(a) &&
    ((b = Object.create(a)), Object.freeze(b));
  return b;
};
goog.object.isImmutableView = function (a) {
  return !!Object.isFrozen && Object.isFrozen(a);
};
goog.object.getAllPropertyNames = function (a, b, c) {
  if (!a) return [];
  if (!Object.getOwnPropertyNames || !Object.getPrototypeOf)
    return goog.object.getKeys(a);
  for (
    var d = {};
    a && (a !== Object.prototype || b) && (a !== Function.prototype || c);

  ) {
    for (var e = Object.getOwnPropertyNames(a), f = 0; f < e.length; f++)
      d[e[f]] = !0;
    a = Object.getPrototypeOf(a);
  }
  return goog.object.getKeys(d);
};
goog.object.getSuperClass = function (a) {
  return (a = Object.getPrototypeOf(a.prototype)) && a.constructor;
};
goog.html.SafeStyleSheet = function () {
  this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_ = '';
  this.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ =
    goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeStyleSheet.prototype.implementsGoogStringTypedString = !0;
goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeStyleSheet.createRule = function (a, b) {
  if (goog.string.internal.contains(a, '<'))
    throw Error("Selector does not allow '<', got: " + a);
  var c = a.replace(/('|")((?!\1)[^\r\n\f\\]|\\[\s\S])*\1/g, '');
  if (!/^[-_a-zA-Z0-9#.:* ,>+~[\]()=^$|]+$/.test(c))
    throw Error(
      'Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|] and strings, got: ' +
        a
    );
  if (!goog.html.SafeStyleSheet.hasBalancedBrackets_(c))
    throw Error('() and [] in selector must be balanced, got: ' + a);
  b instanceof goog.html.SafeStyle || (b = goog.html.SafeStyle.create(b));
  a = a + '{' + goog.html.SafeStyle.unwrap(b).replace(/</g, '\\3C ') + '}';
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(
    a
  );
};
goog.html.SafeStyleSheet.hasBalancedBrackets_ = function (a) {
  for (
    var b = {
        '(': ')',
        '[': ']',
      },
      c = [],
      d = 0;
    d < a.length;
    d++
  ) {
    var e = a[d];
    if (b[e]) c.push(b[e]);
    else if (goog.object.contains(b, e) && c.pop() != e) return !1;
  }
  return 0 == c.length;
};
goog.html.SafeStyleSheet.concat = function (a) {
  var b = '',
    c = function (a) {
      goog.isArray(a)
        ? goog.array.forEach(a, c)
        : (b += goog.html.SafeStyleSheet.unwrap(a));
    };
  goog.array.forEach(arguments, c);
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(
    b
  );
};
goog.html.SafeStyleSheet.fromConstant = function (a) {
  a = goog.string.Const.unwrap(a);
  if (0 === a.length) return goog.html.SafeStyleSheet.EMPTY;
  goog.asserts.assert(
    !goog.string.internal.contains(a, '<'),
    "Forbidden '<' character in style sheet string: " + a
  );
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(
    a
  );
};
goog.html.SafeStyleSheet.prototype.getTypedStringValue = function () {
  return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;
};
goog.DEBUG &&
  (goog.html.SafeStyleSheet.prototype.toString = function () {
    return (
      'SafeStyleSheet{' +
      this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_ +
      '}'
    );
  });
goog.html.SafeStyleSheet.unwrap = function (a) {
  if (
    a instanceof goog.html.SafeStyleSheet &&
    a.constructor === goog.html.SafeStyleSheet &&
    a.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ ===
      goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_
  )
    return a.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;
  goog.asserts.fail(
    "expected object of type SafeStyleSheet, got '" +
      a +
      "' of type " +
      goog.typeOf(a)
  );
  return 'type_error:SafeStyleSheet';
};
goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse = function (
  a
) {
  return new goog.html.SafeStyleSheet().initSecurityPrivateDoNotAccessOrElse_(
    a
  );
};
goog.html.SafeStyleSheet.prototype.initSecurityPrivateDoNotAccessOrElse_ = function (
  a
) {
  this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_ = a;
  return this;
};
goog.html.SafeStyleSheet.EMPTY = goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(
  ''
);
goog.dom.tags = {};
goog.dom.tags.VOID_TAGS_ = {
  area: !0,
  base: !0,
  br: !0,
  col: !0,
  command: !0,
  embed: !0,
  hr: !0,
  img: !0,
  input: !0,
  keygen: !0,
  link: !0,
  meta: !0,
  param: !0,
  source: !0,
  track: !0,
  wbr: !0,
};
goog.dom.tags.isVoidTag = function (a) {
  return !0 === goog.dom.tags.VOID_TAGS_[a];
};
goog.dom.HtmlElement = function () {};
goog.dom.TagName = function (a) {
  this.tagName_ = a;
};
goog.dom.TagName.prototype.toString = function () {
  return this.tagName_;
};
goog.dom.TagName.A = new goog.dom.TagName('A');
goog.dom.TagName.ABBR = new goog.dom.TagName('ABBR');
goog.dom.TagName.ACRONYM = new goog.dom.TagName('ACRONYM');
goog.dom.TagName.ADDRESS = new goog.dom.TagName('ADDRESS');
goog.dom.TagName.APPLET = new goog.dom.TagName('APPLET');
goog.dom.TagName.AREA = new goog.dom.TagName('AREA');
goog.dom.TagName.ARTICLE = new goog.dom.TagName('ARTICLE');
goog.dom.TagName.ASIDE = new goog.dom.TagName('ASIDE');
goog.dom.TagName.AUDIO = new goog.dom.TagName('AUDIO');
goog.dom.TagName.B = new goog.dom.TagName('B');
goog.dom.TagName.BASE = new goog.dom.TagName('BASE');
goog.dom.TagName.BASEFONT = new goog.dom.TagName('BASEFONT');
goog.dom.TagName.BDI = new goog.dom.TagName('BDI');
goog.dom.TagName.BDO = new goog.dom.TagName('BDO');
goog.dom.TagName.BIG = new goog.dom.TagName('BIG');
goog.dom.TagName.BLOCKQUOTE = new goog.dom.TagName('BLOCKQUOTE');
goog.dom.TagName.BODY = new goog.dom.TagName('BODY');
goog.dom.TagName.BR = new goog.dom.TagName('BR');
goog.dom.TagName.BUTTON = new goog.dom.TagName('BUTTON');
goog.dom.TagName.CANVAS = new goog.dom.TagName('CANVAS');
goog.dom.TagName.CAPTION = new goog.dom.TagName('CAPTION');
goog.dom.TagName.CENTER = new goog.dom.TagName('CENTER');
goog.dom.TagName.CITE = new goog.dom.TagName('CITE');
goog.dom.TagName.CODE = new goog.dom.TagName('CODE');
goog.dom.TagName.COL = new goog.dom.TagName('COL');
goog.dom.TagName.COLGROUP = new goog.dom.TagName('COLGROUP');
goog.dom.TagName.COMMAND = new goog.dom.TagName('COMMAND');
goog.dom.TagName.DATA = new goog.dom.TagName('DATA');
goog.dom.TagName.DATALIST = new goog.dom.TagName('DATALIST');
goog.dom.TagName.DD = new goog.dom.TagName('DD');
goog.dom.TagName.DEL = new goog.dom.TagName('DEL');
goog.dom.TagName.DETAILS = new goog.dom.TagName('DETAILS');
goog.dom.TagName.DFN = new goog.dom.TagName('DFN');
goog.dom.TagName.DIALOG = new goog.dom.TagName('DIALOG');
goog.dom.TagName.DIR = new goog.dom.TagName('DIR');
goog.dom.TagName.DIV = new goog.dom.TagName('DIV');
goog.dom.TagName.DL = new goog.dom.TagName('DL');
goog.dom.TagName.DT = new goog.dom.TagName('DT');
goog.dom.TagName.EM = new goog.dom.TagName('EM');
goog.dom.TagName.EMBED = new goog.dom.TagName('EMBED');
goog.dom.TagName.FIELDSET = new goog.dom.TagName('FIELDSET');
goog.dom.TagName.FIGCAPTION = new goog.dom.TagName('FIGCAPTION');
goog.dom.TagName.FIGURE = new goog.dom.TagName('FIGURE');
goog.dom.TagName.FONT = new goog.dom.TagName('FONT');
goog.dom.TagName.FOOTER = new goog.dom.TagName('FOOTER');
goog.dom.TagName.FORM = new goog.dom.TagName('FORM');
goog.dom.TagName.FRAME = new goog.dom.TagName('FRAME');
goog.dom.TagName.FRAMESET = new goog.dom.TagName('FRAMESET');
goog.dom.TagName.H1 = new goog.dom.TagName('H1');
goog.dom.TagName.H2 = new goog.dom.TagName('H2');
goog.dom.TagName.H3 = new goog.dom.TagName('H3');
goog.dom.TagName.H4 = new goog.dom.TagName('H4');
goog.dom.TagName.H5 = new goog.dom.TagName('H5');
goog.dom.TagName.H6 = new goog.dom.TagName('H6');
goog.dom.TagName.HEAD = new goog.dom.TagName('HEAD');
goog.dom.TagName.HEADER = new goog.dom.TagName('HEADER');
goog.dom.TagName.HGROUP = new goog.dom.TagName('HGROUP');
goog.dom.TagName.HR = new goog.dom.TagName('HR');
goog.dom.TagName.HTML = new goog.dom.TagName('HTML');
goog.dom.TagName.I = new goog.dom.TagName('I');
goog.dom.TagName.IFRAME = new goog.dom.TagName('IFRAME');
goog.dom.TagName.IMG = new goog.dom.TagName('IMG');
goog.dom.TagName.INPUT = new goog.dom.TagName('INPUT');
goog.dom.TagName.INS = new goog.dom.TagName('INS');
goog.dom.TagName.ISINDEX = new goog.dom.TagName('ISINDEX');
goog.dom.TagName.KBD = new goog.dom.TagName('KBD');
goog.dom.TagName.KEYGEN = new goog.dom.TagName('KEYGEN');
goog.dom.TagName.LABEL = new goog.dom.TagName('LABEL');
goog.dom.TagName.LEGEND = new goog.dom.TagName('LEGEND');
goog.dom.TagName.LI = new goog.dom.TagName('LI');
goog.dom.TagName.LINK = new goog.dom.TagName('LINK');
goog.dom.TagName.MAIN = new goog.dom.TagName('MAIN');
goog.dom.TagName.MAP = new goog.dom.TagName('MAP');
goog.dom.TagName.MARK = new goog.dom.TagName('MARK');
goog.dom.TagName.MATH = new goog.dom.TagName('MATH');
goog.dom.TagName.MENU = new goog.dom.TagName('MENU');
goog.dom.TagName.MENUITEM = new goog.dom.TagName('MENUITEM');
goog.dom.TagName.META = new goog.dom.TagName('META');
goog.dom.TagName.METER = new goog.dom.TagName('METER');
goog.dom.TagName.NAV = new goog.dom.TagName('NAV');
goog.dom.TagName.NOFRAMES = new goog.dom.TagName('NOFRAMES');
goog.dom.TagName.NOSCRIPT = new goog.dom.TagName('NOSCRIPT');
goog.dom.TagName.OBJECT = new goog.dom.TagName('OBJECT');
goog.dom.TagName.OL = new goog.dom.TagName('OL');
goog.dom.TagName.OPTGROUP = new goog.dom.TagName('OPTGROUP');
goog.dom.TagName.OPTION = new goog.dom.TagName('OPTION');
goog.dom.TagName.OUTPUT = new goog.dom.TagName('OUTPUT');
goog.dom.TagName.P = new goog.dom.TagName('P');
goog.dom.TagName.PARAM = new goog.dom.TagName('PARAM');
goog.dom.TagName.PICTURE = new goog.dom.TagName('PICTURE');
goog.dom.TagName.PRE = new goog.dom.TagName('PRE');
goog.dom.TagName.PROGRESS = new goog.dom.TagName('PROGRESS');
goog.dom.TagName.Q = new goog.dom.TagName('Q');
goog.dom.TagName.RP = new goog.dom.TagName('RP');
goog.dom.TagName.RT = new goog.dom.TagName('RT');
goog.dom.TagName.RTC = new goog.dom.TagName('RTC');
goog.dom.TagName.RUBY = new goog.dom.TagName('RUBY');
goog.dom.TagName.S = new goog.dom.TagName('S');
goog.dom.TagName.SAMP = new goog.dom.TagName('SAMP');
goog.dom.TagName.SCRIPT = new goog.dom.TagName('SCRIPT');
goog.dom.TagName.SECTION = new goog.dom.TagName('SECTION');
goog.dom.TagName.SELECT = new goog.dom.TagName('SELECT');
goog.dom.TagName.SMALL = new goog.dom.TagName('SMALL');
goog.dom.TagName.SOURCE = new goog.dom.TagName('SOURCE');
goog.dom.TagName.SPAN = new goog.dom.TagName('SPAN');
goog.dom.TagName.STRIKE = new goog.dom.TagName('STRIKE');
goog.dom.TagName.STRONG = new goog.dom.TagName('STRONG');
goog.dom.TagName.STYLE = new goog.dom.TagName('STYLE');
goog.dom.TagName.SUB = new goog.dom.TagName('SUB');
goog.dom.TagName.SUMMARY = new goog.dom.TagName('SUMMARY');
goog.dom.TagName.SUP = new goog.dom.TagName('SUP');
goog.dom.TagName.SVG = new goog.dom.TagName('SVG');
goog.dom.TagName.TABLE = new goog.dom.TagName('TABLE');
goog.dom.TagName.TBODY = new goog.dom.TagName('TBODY');
goog.dom.TagName.TD = new goog.dom.TagName('TD');
goog.dom.TagName.TEMPLATE = new goog.dom.TagName('TEMPLATE');
goog.dom.TagName.TEXTAREA = new goog.dom.TagName('TEXTAREA');
goog.dom.TagName.TFOOT = new goog.dom.TagName('TFOOT');
goog.dom.TagName.TH = new goog.dom.TagName('TH');
goog.dom.TagName.THEAD = new goog.dom.TagName('THEAD');
goog.dom.TagName.TIME = new goog.dom.TagName('TIME');
goog.dom.TagName.TITLE = new goog.dom.TagName('TITLE');
goog.dom.TagName.TR = new goog.dom.TagName('TR');
goog.dom.TagName.TRACK = new goog.dom.TagName('TRACK');
goog.dom.TagName.TT = new goog.dom.TagName('TT');
goog.dom.TagName.U = new goog.dom.TagName('U');
goog.dom.TagName.UL = new goog.dom.TagName('UL');
goog.dom.TagName.VAR = new goog.dom.TagName('VAR');
goog.dom.TagName.VIDEO = new goog.dom.TagName('VIDEO');
goog.dom.TagName.WBR = new goog.dom.TagName('WBR');
goog.labs = {};
goog.labs.userAgent = {};
goog.labs.userAgent.util = {};
goog.labs.userAgent.util.getNativeUserAgentString_ = function () {
  var a = goog.labs.userAgent.util.getNavigator_();
  return a && (a = a.userAgent) ? a : '';
};
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 (a) {
  goog.labs.userAgent.util.userAgent_ =
    a || goog.labs.userAgent.util.getNativeUserAgentString_();
};
goog.labs.userAgent.util.getUserAgent = function () {
  return goog.labs.userAgent.util.userAgent_;
};
goog.labs.userAgent.util.matchUserAgent = function (a) {
  var b = goog.labs.userAgent.util.getUserAgent();
  return goog.string.internal.contains(b, a);
};
goog.labs.userAgent.util.matchUserAgentIgnoreCase = function (a) {
  var b = goog.labs.userAgent.util.getUserAgent();
  return goog.string.internal.caseInsensitiveContains(b, a);
};
goog.labs.userAgent.util.extractVersionTuples = function (a) {
  for (
    var b = /(\w[\w ]+)\/([^\s]+)\s*(?:\((.*?)\))?/g, c = [], d;
    (d = b.exec(a));

  )
    c.push([d[1], d[2], d[3] || void 0]);
  return c;
};
goog.labs.userAgent.browser = {};
goog.labs.userAgent.browser.matchOpera_ = function () {
  return goog.labs.userAgent.util.matchUserAgent('Opera');
};
goog.labs.userAgent.browser.matchIE_ = function () {
  return (
    goog.labs.userAgent.util.matchUserAgent('Trident') ||
    goog.labs.userAgent.util.matchUserAgent('MSIE')
  );
};
goog.labs.userAgent.browser.matchEdgeHtml_ = function () {
  return goog.labs.userAgent.util.matchUserAgent('Edge');
};
goog.labs.userAgent.browser.matchEdgeChromium_ = function () {
  return goog.labs.userAgent.util.matchUserAgent('Edg/');
};
goog.labs.userAgent.browser.matchOperaChromium_ = function () {
  return goog.labs.userAgent.util.matchUserAgent('OPR');
};
goog.labs.userAgent.browser.matchFirefox_ = function () {
  return (
    goog.labs.userAgent.util.matchUserAgent('Firefox') ||
    goog.labs.userAgent.util.matchUserAgent('FxiOS')
  );
};
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.matchEdgeHtml_() ||
      goog.labs.userAgent.browser.matchEdgeChromium_() ||
      goog.labs.userAgent.browser.matchOperaChromium_() ||
      goog.labs.userAgent.browser.matchFirefox_() ||
      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.browser.matchFirefox_() &&
    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.matchEdgeHtml_()
  );
};
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.isEdge = goog.labs.userAgent.browser.matchEdgeHtml_;
goog.labs.userAgent.browser.isEdgeChromium =
  goog.labs.userAgent.browser.matchEdgeChromium_;
goog.labs.userAgent.browser.isOperaChromium =
  goog.labs.userAgent.browser.matchOperaChromium_;
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 () {
  function a(a) {
    a = goog.array.find(a, d);
    return c[a] || '';
  }
  var b = goog.labs.userAgent.util.getUserAgent();
  if (goog.labs.userAgent.browser.isIE())
    return goog.labs.userAgent.browser.getIEVersion_(b);
  b = goog.labs.userAgent.util.extractVersionTuples(b);
  var c = {};
  goog.array.forEach(b, function (a) {
    c[a[0]] = a[1];
  });
  var d = goog.partial(goog.object.containsKey, c);
  return goog.labs.userAgent.browser.isOpera()
    ? a(['Version', 'Opera'])
    : goog.labs.userAgent.browser.isEdge()
    ? a(['Edge'])
    : goog.labs.userAgent.browser.isEdgeChromium()
    ? a(['Edg'])
    : goog.labs.userAgent.browser.isChrome()
    ? a(['Chrome', 'CriOS'])
    : ((b = b[2]) && b[1]) || '';
};
goog.labs.userAgent.browser.isVersionOrHigher = function (a) {
  return (
    0 <=
    goog.string.internal.compareVersions(
      goog.labs.userAgent.browser.getVersion(),
      a
    )
  );
};
goog.labs.userAgent.browser.getIEVersion_ = function (a) {
  var b = /rv: *([\d\.]*)/.exec(a);
  if (b && b[1]) return b[1];
  b = '';
  var c = /MSIE +([\d\.]+)/.exec(a);
  if (c && c[1])
    if (((a = /Trident\/(\d.\d)/.exec(a)), '7.0' == c[1]))
      if (a && a[1])
        switch (a[1]) {
          case '4.0':
            b = '8.0';
            break;
          case '5.0':
            b = '9.0';
            break;
          case '6.0':
            b = '10.0';
            break;
          case '7.0':
            b = '11.0';
        }
      else b = '7.0';
    else b = c[1];
  return b;
};
goog.html.SafeHtml = function () {
  this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ = '';
  this.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ =
    goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
  this.dir_ = null;
};
goog.html.SafeHtml.prototype.implementsGoogI18nBidiDirectionalString = !0;
goog.html.SafeHtml.prototype.getDirection = function () {
  return this.dir_;
};
goog.html.SafeHtml.prototype.implementsGoogStringTypedString = !0;
goog.html.SafeHtml.prototype.getTypedStringValue = function () {
  return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_.toString();
};
goog.DEBUG &&
  (goog.html.SafeHtml.prototype.toString = function () {
    return (
      'SafeHtml{' + this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ + '}'
    );
  });
goog.html.SafeHtml.unwrap = function (a) {
  return goog.html.SafeHtml.unwrapTrustedHTML(a).toString();
};
goog.html.SafeHtml.unwrapTrustedHTML = function (a) {
  if (
    a instanceof goog.html.SafeHtml &&
    a.constructor === goog.html.SafeHtml &&
    a.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ ===
      goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_
  )
    return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_;
  goog.asserts.fail(
    "expected object of type SafeHtml, got '" +
      a +
      "' of type " +
      goog.typeOf(a)
  );
  return 'type_error:SafeHtml';
};
goog.html.SafeHtml.htmlEscape = function (a) {
  if (a instanceof goog.html.SafeHtml) return a;
  var b = 'object' == typeof a,
    c = null;
  b && a.implementsGoogI18nBidiDirectionalString && (c = a.getDirection());
  a =
    b && a.implementsGoogStringTypedString
      ? a.getTypedStringValue()
      : String(a);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    goog.string.internal.htmlEscape(a),
    c
  );
};
goog.html.SafeHtml.htmlEscapePreservingNewlines = function (a) {
  if (a instanceof goog.html.SafeHtml) return a;
  a = goog.html.SafeHtml.htmlEscape(a);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    goog.string.internal.newLineToBr(goog.html.SafeHtml.unwrap(a)),
    a.getDirection()
  );
};
goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces = function (a) {
  if (a instanceof goog.html.SafeHtml) return a;
  a = goog.html.SafeHtml.htmlEscape(a);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    goog.string.internal.whitespaceEscape(goog.html.SafeHtml.unwrap(a)),
    a.getDirection()
  );
};
goog.html.SafeHtml.from = goog.html.SafeHtml.htmlEscape;
goog.html.SafeHtml.VALID_NAMES_IN_TAG_ = /^[a-zA-Z0-9-]+$/;
goog.html.SafeHtml.URL_ATTRIBUTES_ = {
  action: !0,
  cite: !0,
  data: !0,
  formaction: !0,
  href: !0,
  manifest: !0,
  poster: !0,
  src: !0,
};
goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_ = {
  APPLET: !0,
  BASE: !0,
  EMBED: !0,
  IFRAME: !0,
  LINK: !0,
  MATH: !0,
  META: !0,
  OBJECT: !0,
  SCRIPT: !0,
  STYLE: !0,
  SVG: !0,
  TEMPLATE: !0,
};
goog.html.SafeHtml.create = function (a, b, c) {
  goog.html.SafeHtml.verifyTagName(String(a));
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
    String(a),
    b,
    c
  );
};
goog.html.SafeHtml.verifyTagName = function (a) {
  if (!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(a))
    throw Error('Invalid tag name <' + a + '>.');
  if (a.toUpperCase() in goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_)
    throw Error('Tag name <' + a + '> is not allowed for SafeHtml.');
};
goog.html.SafeHtml.createIframe = function (a, b, c, d) {
  a && goog.html.TrustedResourceUrl.unwrap(a);
  var e = {};
  e.src = a || null;
  e.srcdoc = b && goog.html.SafeHtml.unwrap(b);
  a = goog.html.SafeHtml.combineAttributes(
    e,
    {
      sandbox: '',
    },
    c
  );
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
    'iframe',
    a,
    d
  );
};
goog.html.SafeHtml.createSandboxIframe = function (a, b, c, d) {
  if (!goog.html.SafeHtml.canUseSandboxIframe())
    throw Error('The browser does not support sandboxed iframes.');
  var e = {};
  e.src = a ? goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a)) : null;
  e.srcdoc = b || null;
  e.sandbox = '';
  a = goog.html.SafeHtml.combineAttributes(e, {}, c);
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
    'iframe',
    a,
    d
  );
};
goog.html.SafeHtml.canUseSandboxIframe = function () {
  return (
    goog.global.HTMLIFrameElement &&
    'sandbox' in goog.global.HTMLIFrameElement.prototype
  );
};
goog.html.SafeHtml.createScriptSrc = function (a, b) {
  goog.html.TrustedResourceUrl.unwrap(a);
  a = goog.html.SafeHtml.combineAttributes(
    {
      src: a,
    },
    {},
    b
  );
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
    'script',
    a
  );
};
goog.html.SafeHtml.createScript = function (a, b) {
  for (var c in b) {
    var d = c.toLowerCase();
    if ('language' == d || 'src' == d || 'text' == d || 'type' == d)
      throw Error('Cannot set "' + d + '" attribute');
  }
  c = '';
  a = goog.array.concat(a);
  for (d = 0; d < a.length; d++) c += goog.html.SafeScript.unwrap(a[d]);
  a = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    c,
    goog.i18n.bidi.Dir.NEUTRAL
  );
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
    'script',
    b,
    a
  );
};
goog.html.SafeHtml.createStyle = function (a, b) {
  b = goog.html.SafeHtml.combineAttributes(
    {
      type: 'text/css',
    },
    {},
    b
  );
  var c = '';
  a = goog.array.concat(a);
  for (var d = 0; d < a.length; d++) c += goog.html.SafeStyleSheet.unwrap(a[d]);
  a = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    c,
    goog.i18n.bidi.Dir.NEUTRAL
  );
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
    'style',
    b,
    a
  );
};
goog.html.SafeHtml.createMetaRefresh = function (a, b) {
  a = goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a));
  (goog.labs.userAgent.browser.isIE() ||
    goog.labs.userAgent.browser.isEdge()) &&
    goog.string.internal.contains(a, ';') &&
    (a = "'" + a.replace(/'/g, '%27') + "'");
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(
    'meta',
    {
      'http-equiv': 'refresh',
      content: (b || 0) + '; url=' + a,
    }
  );
};
goog.html.SafeHtml.getAttrNameAndValue_ = function (a, b, c) {
  if (c instanceof goog.string.Const) c = goog.string.Const.unwrap(c);
  else if ('style' == b.toLowerCase()) c = goog.html.SafeHtml.getStyleValue_(c);
  else {
    if (/^on/i.test(b))
      throw Error(
        'Attribute "' +
          b +
          '" requires goog.string.Const value, "' +
          c +
          '" given.'
      );
    if (b.toLowerCase() in goog.html.SafeHtml.URL_ATTRIBUTES_)
      if (c instanceof goog.html.TrustedResourceUrl)
        c = goog.html.TrustedResourceUrl.unwrap(c);
      else if (c instanceof goog.html.SafeUrl) c = goog.html.SafeUrl.unwrap(c);
      else if (goog.isString(c))
        c = goog.html.SafeUrl.sanitize(c).getTypedStringValue();
      else
        throw Error(
          'Attribute "' +
            b +
            '" on tag "' +
            a +
            '" requires goog.html.SafeUrl, goog.string.Const, or string, value "' +
            c +
            '" given.'
        );
  }
  c.implementsGoogStringTypedString && (c = c.getTypedStringValue());
  goog.asserts.assert(
    goog.isString(c) || goog.isNumber(c),
    'String or number value expected, got ' + typeof c + ' with value: ' + c
  );
  return b + '="' + goog.string.internal.htmlEscape(String(c)) + '"';
};
goog.html.SafeHtml.getStyleValue_ = function (a) {
  if (!goog.isObject(a))
    throw Error(
      'The "style" attribute requires goog.html.SafeStyle or map of style properties, ' +
        typeof a +
        ' given: ' +
        a
    );
  a instanceof goog.html.SafeStyle || (a = goog.html.SafeStyle.create(a));
  return goog.html.SafeStyle.unwrap(a);
};
goog.html.SafeHtml.createWithDir = function (a, b, c, d) {
  b = goog.html.SafeHtml.create(b, c, d);
  b.dir_ = a;
  return b;
};
goog.html.SafeHtml.join = function (a, b) {
  a = goog.html.SafeHtml.htmlEscape(a);
  var c = a.getDirection(),
    d = [],
    e = function (a) {
      goog.isArray(a)
        ? goog.array.forEach(a, e)
        : ((a = goog.html.SafeHtml.htmlEscape(a)),
          d.push(goog.html.SafeHtml.unwrap(a)),
          (a = a.getDirection()),
          c == goog.i18n.bidi.Dir.NEUTRAL
            ? (c = a)
            : a != goog.i18n.bidi.Dir.NEUTRAL && c != a && (c = null));
    };
  goog.array.forEach(b, e);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    d.join(goog.html.SafeHtml.unwrap(a)),
    c
  );
};
goog.html.SafeHtml.concat = function (a) {
  return goog.html.SafeHtml.join(
    goog.html.SafeHtml.EMPTY,
    Array.prototype.slice.call(arguments)
  );
};
goog.html.SafeHtml.concatWithDir = function (a, b) {
  var c = goog.html.SafeHtml.concat(goog.array.slice(arguments, 1));
  c.dir_ = a;
  return c;
};
goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse = function (
  a,
  b
) {
  return new goog.html.SafeHtml().initSecurityPrivateDoNotAccessOrElse_(a, b);
};
goog.html.SafeHtml.prototype.initSecurityPrivateDoNotAccessOrElse_ = function (
  a,
  b
) {
  this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ = goog.html.trustedtypes
    .PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY
    ? goog.html.trustedtypes.PRIVATE_DO_NOT_ACCESS_OR_ELSE_POLICY.createHTML(a)
    : a;
  this.dir_ = b;
  return this;
};
goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse = function (
  a,
  b,
  c
) {
  var d = null;
  var e = '<' + a + goog.html.SafeHtml.stringifyAttributes(a, b);
  goog.isDefAndNotNull(c) ? goog.isArray(c) || (c = [c]) : (c = []);
  goog.dom.tags.isVoidTag(a.toLowerCase())
    ? (goog.asserts.assert(
        !c.length,
        'Void tag <' + a + '> does not allow content.'
      ),
      (e += '>'))
    : ((d = goog.html.SafeHtml.concat(c)),
      (e += '>' + goog.html.SafeHtml.unwrap(d) + '</' + a + '>'),
      (d = d.getDirection()));
  (a = b && b.dir) &&
    (d = /^(ltr|rtl|auto)$/i.test(a) ? goog.i18n.bidi.Dir.NEUTRAL : null);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    e,
    d
  );
};
goog.html.SafeHtml.stringifyAttributes = function (a, b) {
  var c = '';
  if (b)
    for (var d in b) {
      if (!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(d))
        throw Error('Invalid attribute name "' + d + '".');
      var e = b[d];
      goog.isDefAndNotNull(e) &&
        (c += ' ' + goog.html.SafeHtml.getAttrNameAndValue_(a, d, e));
    }
  return c;
};
goog.html.SafeHtml.combineAttributes = function (a, b, c) {
  var d = {},
    e;
  for (e in a)
    goog.asserts.assert(e.toLowerCase() == e, 'Must be lower case'),
      (d[e] = a[e]);
  for (e in b)
    goog.asserts.assert(e.toLowerCase() == e, 'Must be lower case'),
      (d[e] = b[e]);
  for (e in c) {
    var f = e.toLowerCase();
    if (f in a)
      throw Error(
        'Cannot override "' +
          f +
          '" attribute, got "' +
          e +
          '" with value "' +
          c[e] +
          '"'
      );
    f in b && delete d[f];
    d[e] = c[e];
  }
  return d;
};
goog.html.SafeHtml.DOCTYPE_HTML = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
  '<!DOCTYPE html>',
  goog.i18n.bidi.Dir.NEUTRAL
);
goog.html.SafeHtml.EMPTY = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
  '',
  goog.i18n.bidi.Dir.NEUTRAL
);
goog.html.SafeHtml.BR = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
  '<br>',
  goog.i18n.bidi.Dir.NEUTRAL
);
goog.html.uncheckedconversions = {};
goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract = function (
  a,
  b,
  c
) {
  goog.asserts.assertString(
    goog.string.Const.unwrap(a),
    'must provide justification'
  );
  goog.asserts.assert(
    !goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),
    'must provide non-empty justification'
  );
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(
    b,
    c || null
  );
};
goog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract = function (
  a,
  b
) {
  goog.asserts.assertString(
    goog.string.Const.unwrap(a),
    'must provide justification'
  );
  goog.asserts.assert(
    !goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),
    'must provide non-empty justification'
  );
  return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(
    b
  );
};
goog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract = function (
  a,
  b
) {
  goog.asserts.assertString(
    goog.string.Const.unwrap(a),
    'must provide justification'
  );
  goog.asserts.assert(
    !goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),
    'must provide non-empty justification'
  );
  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b);
};
goog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract = function (
  a,
  b
) {
  goog.asserts.assertString(
    goog.string.Const.unwrap(a),
    'must provide justification'
  );
  goog.asserts.assert(
    !goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),
    'must provide non-empty justification'
  );
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(
    b
  );
};
goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract = function (
  a,
  b
) {
  goog.asserts.assertString(
    goog.string.Const.unwrap(a),
    'must provide justification'
  );
  goog.asserts.assert(
    !goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),
    'must provide non-empty justification'
  );
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b);
};
goog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract = function (
  a,
  b
) {
  goog.asserts.assertString(
    goog.string.Const.unwrap(a),
    'must provide justification'
  );
  goog.asserts.assert(
    !goog.string.internal.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),
    'must provide non-empty justification'
  );
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(
    b
  );
};
goog.dom.asserts = {};
goog.dom.asserts.assertIsLocation = function (a) {
  if (goog.asserts.ENABLE_ASSERTS) {
    var b = goog.dom.asserts.getWindow_(a);
    b &&
      (!a || (!(a instanceof b.Location) && a instanceof b.Element)) &&
      goog.asserts.fail(
        'Argument is not a Location (or a non-Element mock); got: %s',
        goog.dom.asserts.debugStringForType_(a)
      );
  }
  return a;
};
goog.dom.asserts.assertIsElementType_ = function (a, b) {
  if (goog.asserts.ENABLE_ASSERTS) {
    var c = goog.dom.asserts.getWindow_(a);
    c &&
      'undefined' != typeof c[b] &&
      ((a &&
        (a instanceof c[b] ||
          !(a instanceof c.Location || a instanceof c.Element))) ||
        goog.asserts.fail(
          'Argument is not a %s (or a non-Element, non-Location mock); got: %s',
          b,
          goog.dom.asserts.debugStringForType_(a)
        ));
  }
  return a;
};
goog.dom.asserts.assertIsHTMLAnchorElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLAnchorElement');
};
goog.dom.asserts.assertIsHTMLButtonElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLButtonElement');
};
goog.dom.asserts.assertIsHTMLLinkElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLLinkElement');
};
goog.dom.asserts.assertIsHTMLImageElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLImageElement');
};
goog.dom.asserts.assertIsHTMLAudioElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLAudioElement');
};
goog.dom.asserts.assertIsHTMLVideoElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLVideoElement');
};
goog.dom.asserts.assertIsHTMLInputElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLInputElement');
};
goog.dom.asserts.assertIsHTMLTextAreaElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLTextAreaElement');
};
goog.dom.asserts.assertIsHTMLCanvasElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLCanvasElement');
};
goog.dom.asserts.assertIsHTMLEmbedElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLEmbedElement');
};
goog.dom.asserts.assertIsHTMLFormElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLFormElement');
};
goog.dom.asserts.assertIsHTMLFrameElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLFrameElement');
};
goog.dom.asserts.assertIsHTMLIFrameElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLIFrameElement');
};
goog.dom.asserts.assertIsHTMLObjectElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLObjectElement');
};
goog.dom.asserts.assertIsHTMLScriptElement = function (a) {
  return goog.dom.asserts.assertIsElementType_(a, 'HTMLScriptElement');
};
goog.dom.asserts.debugStringForType_ = function (a) {
  if (goog.isObject(a))
    try {
      return (
        a.constructor.displayName ||
        a.constructor.name ||
        Object.prototype.toString.call(a)
      );
    } catch (b) {
      return '<object could not be stringified>';
    }
  else return void 0 === a ? 'undefined' : null === a ? 'null' : typeof a;
};
goog.dom.asserts.getWindow_ = function (a) {
  try {
    var b = a && a.ownerDocument,
      c = b && (b.defaultView || b.parentWindow);
    c = c || goog.global;
    if (c.Element && c.Location) return c;
  } catch (d) {}
  return null;
};
goog.functions = {};
goog.functions.constant = function (a) {
  return function () {
    return a;
  };
};
goog.functions.FALSE = function () {
  return !1;
};
goog.functions.TRUE = function () {
  return !0;
};
goog.functions.NULL = function () {
  return null;
};
goog.functions.identity = function (a, b) {
  return a;
};
goog.functions.error = function (a) {
  return function () {
    throw Error(a);
  };
};
goog.functions.fail = function (a) {
  return function () {
    throw a;
  };
};
goog.functions.lock = function (a, b) {
  b = b || 0;
  return function () {
    return a.apply(this, Array.prototype.slice.call(arguments, 0, b));
  };
};
goog.functions.nth = function (a) {
  return function () {
    return arguments[a];
  };
};
goog.functions.partialRight = function (a, b) {
  var c = Array.prototype.slice.call(arguments, 1);
  return function () {
    var b = Array.prototype.slice.call(arguments);
    b.push.apply(b, c);
    return a.apply(this, b);
  };
};
goog.functions.withReturnValue = function (a, b) {
  return goog.functions.sequence(a, goog.functions.constant(b));
};
goog.functions.equalTo = function (a, b) {
  return function (c) {
    return b ? a == c : a === c;
  };
};
goog.functions.compose = function (a, b) {
  var c = arguments,
    d = c.length;
  return function () {
    var a;
    d && (a = c[d - 1].apply(this, arguments));
    for (var b = d - 2; 0 <= b; b--) a = c[b].call(this, a);
    return a;
  };
};
goog.functions.sequence = function (a) {
  var b = arguments,
    c = b.length;
  return function () {
    for (var a, e = 0; e < c; e++) a = b[e].apply(this, arguments);
    return a;
  };
};
goog.functions.and = function (a) {
  var b = arguments,
    c = b.length;
  return function () {
    for (var a = 0; a < c; a++) if (!b[a].apply(this, arguments)) return !1;
    return !0;
  };
};
goog.functions.or = function (a) {
  var b = arguments,
    c = b.length;
  return function () {
    for (var a = 0; a < c; a++) if (b[a].apply(this, arguments)) return !0;
    return !1;
  };
};
goog.functions.not = function (a) {
  return function () {
    return !a.apply(this, arguments);
  };
};
goog.functions.create = function (a, b) {
  var c = function () {};
  c.prototype = a.prototype;
  c = new c();
  a.apply(c, Array.prototype.slice.call(arguments, 1));
  return c;
};
goog.functions.CACHE_RETURN_VALUE = !0;
goog.functions.cacheReturnValue = function (a) {
  var b = !1,
    c;
  return function () {
    if (!goog.functions.CACHE_RETURN_VALUE) return a();
    b || ((c = a()), (b = !0));
    return c;
  };
};
goog.functions.once = function (a) {
  var b = a;
  return function () {
    if (b) {
      var a = b;
      b = null;
      a();
    }
  };
};
goog.functions.debounce = function (a, b, c) {
  var d = 0;
  return function (e) {
    goog.global.clearTimeout(d);
    var f = arguments;
    d = goog.global.setTimeout(function () {
      a.apply(c, f);
    }, b);
  };
};
goog.functions.throttle = function (a, b, c) {
  var d = 0,
    e = !1,
    f = [],
    g = function () {
      d = 0;
      e && ((e = !1), h());
    },
    h = function () {
      d = goog.global.setTimeout(g, b);
      a.apply(c, f);
    };
  return function (a) {
    f = arguments;
    d ? (e = !0) : h();
  };
};
goog.functions.rateLimit = function (a, b, c) {
  var d = 0,
    e = function () {
      d = 0;
    };
  return function (f) {
    d || ((d = goog.global.setTimeout(e, b)), a.apply(c, arguments));
  };
};
goog.dom.safe = {};
goog.dom.safe.InsertAdjacentHtmlPosition = {
  AFTERBEGIN: 'afterbegin',
  AFTEREND: 'afterend',
  BEFOREBEGIN: 'beforebegin',
  BEFOREEND: 'beforeend',
};
goog.dom.safe.insertAdjacentHtml = function (a, b, c) {
  a.insertAdjacentHTML(b, goog.html.SafeHtml.unwrapTrustedHTML(c));
};
goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_ = {
  MATH: !0,
  SCRIPT: !0,
  STYLE: !0,
  SVG: !0,
  TEMPLATE: !0,
};
goog.dom.safe.isInnerHtmlCleanupRecursive_ = goog.functions.cacheReturnValue(
  function () {
    if (goog.DEBUG && 'undefined' === typeof document) return !1;
    var a = document.createElement('div'),
      b = document.createElement('div');
    b.appendChild(document.createElement('div'));
    a.appendChild(b);
    if (goog.DEBUG && !a.firstChild) return !1;
    b = a.firstChild.firstChild;
    a.innerHTML = goog.html.SafeHtml.unwrapTrustedHTML(
      goog.html.SafeHtml.EMPTY
    );
    return !b.parentElement;
  }
);
goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse = function (a, b) {
  if (goog.dom.safe.isInnerHtmlCleanupRecursive_())
    for (; a.lastChild; ) a.removeChild(a.lastChild);
  a.innerHTML = goog.html.SafeHtml.unwrapTrustedHTML(b);
};
goog.dom.safe.setInnerHtml = function (a, b) {
  if (goog.asserts.ENABLE_ASSERTS) {
    var c = a.tagName.toUpperCase();
    if (goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[c])
      throw Error(
        'goog.dom.safe.setInnerHtml cannot be used to set content of ' +
          a.tagName +
          '.'
      );
  }
  goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse(a, b);
};
goog.dom.safe.setOuterHtml = function (a, b) {
  a.outerHTML = goog.html.SafeHtml.unwrapTrustedHTML(b);
};
goog.dom.safe.setFormElementAction = function (a, b) {
  b =
    b instanceof goog.html.SafeUrl
      ? b
      : goog.html.SafeUrl.sanitizeAssertUnchanged(b);
  goog.dom.asserts.assertIsHTMLFormElement(
    a
  ).action = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setButtonFormAction = function (a, b) {
  b =
    b instanceof goog.html.SafeUrl
      ? b
      : goog.html.SafeUrl.sanitizeAssertUnchanged(b);
  goog.dom.asserts.assertIsHTMLButtonElement(
    a
  ).formAction = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setInputFormAction = function (a, b) {
  b =
    b instanceof goog.html.SafeUrl
      ? b
      : goog.html.SafeUrl.sanitizeAssertUnchanged(b);
  goog.dom.asserts.assertIsHTMLInputElement(
    a
  ).formAction = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setStyle = function (a, b) {
  a.style.cssText = goog.html.SafeStyle.unwrap(b);
};
goog.dom.safe.documentWrite = function (a, b) {
  a.write(goog.html.SafeHtml.unwrapTrustedHTML(b));
};
goog.dom.safe.setAnchorHref = function (a, b) {
  goog.dom.asserts.assertIsHTMLAnchorElement(a);
  b =
    b instanceof goog.html.SafeUrl
      ? b
      : goog.html.SafeUrl.sanitizeAssertUnchanged(b);
  a.href = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setImageSrc = function (a, b) {
  goog.dom.asserts.assertIsHTMLImageElement(a);
  if (!(b instanceof goog.html.SafeUrl)) {
    var c = /^data:image\//i.test(b);
    b = goog.html.SafeUrl.sanitizeAssertUnchanged(b, c);
  }
  a.src = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setAudioSrc = function (a, b) {
  goog.dom.asserts.assertIsHTMLAudioElement(a);
  if (!(b instanceof goog.html.SafeUrl)) {
    var c = /^data:audio\//i.test(b);
    b = goog.html.SafeUrl.sanitizeAssertUnchanged(b, c);
  }
  a.src = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setVideoSrc = function (a, b) {
  goog.dom.asserts.assertIsHTMLVideoElement(a);
  if (!(b instanceof goog.html.SafeUrl)) {
    var c = /^data:video\//i.test(b);
    b = goog.html.SafeUrl.sanitizeAssertUnchanged(b, c);
  }
  a.src = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setEmbedSrc = function (a, b) {
  goog.dom.asserts.assertIsHTMLEmbedElement(a);
  a.src = goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b);
};
goog.dom.safe.setFrameSrc = function (a, b) {
  goog.dom.asserts.assertIsHTMLFrameElement(a);
  a.src = goog.html.TrustedResourceUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setIframeSrc = function (a, b) {
  goog.dom.asserts.assertIsHTMLIFrameElement(a);
  a.src = goog.html.TrustedResourceUrl.unwrapTrustedURL(b);
};
goog.dom.safe.setIframeSrcdoc = function (a, b) {
  goog.dom.asserts.assertIsHTMLIFrameElement(a);
  a.srcdoc = goog.html.SafeHtml.unwrapTrustedHTML(b);
};
goog.dom.safe.setLinkHrefAndRel = function (a, b, c) {
  goog.dom.asserts.assertIsHTMLLinkElement(a);
  a.rel = c;
  goog.string.internal.caseInsensitiveContains(c, 'stylesheet')
    ? (goog.asserts.assert(
        b instanceof goog.html.TrustedResourceUrl,
        'URL must be TrustedResourceUrl because "rel" contains "stylesheet"'
      ),
      (a.href = goog.html.TrustedResourceUrl.unwrapTrustedURL(b)))
    : (a.href =
        b instanceof goog.html.TrustedResourceUrl
          ? goog.html.TrustedResourceUrl.unwrapTrustedURL(b)
          : b instanceof goog.html.SafeUrl
          ? goog.html.SafeUrl.unwrapTrustedURL(b)
          : goog.html.SafeUrl.unwrapTrustedURL(
              goog.html.SafeUrl.sanitizeAssertUnchanged(b)
            ));
};
goog.dom.safe.setObjectData = function (a, b) {
  goog.dom.asserts.assertIsHTMLObjectElement(a);
  a.data = goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b);
};
goog.dom.safe.setScriptSrc = function (a, b) {
  goog.dom.asserts.assertIsHTMLScriptElement(a);
  a.src = goog.html.TrustedResourceUrl.unwrapTrustedScriptURL(b);
  (b = goog.getScriptNonce()) && a.setAttribute('nonce', b);
};
goog.dom.safe.setScriptContent = function (a, b) {
  goog.dom.asserts.assertIsHTMLScriptElement(a);
  a.text = goog.html.SafeScript.unwrapTrustedScript(b);
  (b = goog.getScriptNonce()) && a.setAttribute('nonce', b);
};
goog.dom.safe.setLocationHref = function (a, b) {
  goog.dom.asserts.assertIsLocation(a);
  b =
    b instanceof goog.html.SafeUrl
      ? b
      : goog.html.SafeUrl.sanitizeAssertUnchanged(b);
  a.href = goog.html.SafeUrl.unwrapTrustedURL(b);
};
goog.dom.safe.assignLocation = function (a, b) {
  goog.dom.asserts.assertIsLocation(a);
  b =
    b instanceof goog.html.SafeUrl
      ? b
      : goog.html.SafeUrl.sanitizeAssertUnchanged(b);
  a.assign(goog.html.SafeUrl.unwrapTrustedURL(b));
};
goog.dom.safe.replaceLocation = function (a, b) {
  goog.dom.asserts.assertIsLocation(a);
  b =
    b instanceof goog.html.SafeUrl
      ? b
      : goog.html.SafeUrl.sanitizeAssertUnchanged(b);
  a.replace(goog.html.SafeUrl.unwrapTrustedURL(b));
};
goog.dom.safe.openInWindow = function (a, b, c, d, e) {
  a =
    a instanceof goog.html.SafeUrl
      ? a
      : goog.html.SafeUrl.sanitizeAssertUnchanged(a);
  return (b || goog.global).open(
    goog.html.SafeUrl.unwrapTrustedURL(a),
    c ? goog.string.Const.unwrap(c) : '',
    d,
    e
  );
};
goog.dom.safe.parseFromStringHtml = function (a, b) {
  return goog.dom.safe.parseFromString(a, b, 'text/html');
};
goog.dom.safe.parseFromString = function (a, b, c) {
  return a.parseFromString(goog.html.SafeHtml.unwrapTrustedHTML(b), c);
};
goog.dom.safe.createImageFromBlob = function (a) {
  if (!/^image\/.*/g.test(a.type))
    throw Error(
      'goog.dom.safe.createImageFromBlob only accepts MIME type image/.*.'
    );
  var b = goog.global.URL.createObjectURL(a);
  a = new goog.global.Image();
  a.onload = function () {
    goog.global.URL.revokeObjectURL(b);
  };
  goog.dom.safe.setImageSrc(
    a,
    goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract(
      goog.string.Const.from('Image blob URL.'),
      b
    )
  );
  return a;
};
goog.string.DETECT_DOUBLE_ESCAPING = !1;
goog.string.FORCE_NON_DOM_HTML_UNESCAPING = !1;
goog.string.Unicode = {
  NBSP: '\u00a0',
};
goog.string.startsWith = goog.string.internal.startsWith;
goog.string.endsWith = goog.string.internal.endsWith;
goog.string.caseInsensitiveStartsWith =
  goog.string.internal.caseInsensitiveStartsWith;
goog.string.caseInsensitiveEndsWith =
  goog.string.internal.caseInsensitiveEndsWith;
goog.string.caseInsensitiveEquals = goog.string.internal.caseInsensitiveEquals;
goog.string.subs = function (a, b) {
  for (
    var c = a.split('%s'), d = '', e = Array.prototype.slice.call(arguments, 1);
    e.length && 1 < c.length;

  )
    d += c.shift() + e.shift();
  return d + c.join('%s');
};
goog.string.collapseWhitespace = function (a) {
  return a.replace(/[\s\xa0]+/g, ' ').replace(/^\s+|\s+$/g, '');
};
goog.string.isEmptyOrWhitespace = goog.string.internal.isEmptyOrWhitespace;
goog.string.isEmptyString = function (a) {
  return 0 == a.length;
};
goog.string.isEmpty = goog.string.isEmptyOrWhitespace;
goog.string.isEmptyOrWhitespaceSafe = function (a) {
  return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(a));
};
goog.string.isEmptySafe = goog.string.isEmptyOrWhitespaceSafe;
goog.string.isBreakingWhitespace = function (a) {
  return !/[^\t\n\r ]/.test(a);
};
goog.string.isAlpha = function (a) {
  return !/[^a-zA-Z]/.test(a);
};
goog.string.isNumeric = function (a) {
  return !/[^0-9]/.test(a);
};
goog.string.isAlphaNumeric = function (a) {
  return !/[^a-zA-Z0-9]/.test(a);
};
goog.string.isSpace = function (a) {
  return ' ' == a;
};
goog.string.isUnicodeChar = function (a) {
  return (
    (1 == a.length && ' ' <= a && '~' >= a) || ('\u0080' <= a && '\ufffd' >= a)
  );
};
goog.string.stripNewlines = function (a) {
  return a.replace(/(\r\n|\r|\n)+/g, ' ');
};
goog.string.canonicalizeNewlines = function (a) {
  return a.replace(/(\r\n|\r|\n)/g, '\n');
};
goog.string.normalizeWhitespace = function (a) {
  return a.replace(/\xa0|\s/g, ' ');
};
goog.string.normalizeSpaces = function (a) {
  return a.replace(/\xa0|[ \t]+/g, ' ');
};
goog.string.collapseBreakingSpaces = function (a) {
  return a.replace(/[\t\r\n ]+/g, ' ').replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, '');
};
goog.string.trim = goog.string.internal.trim;
goog.string.trimLeft = function (a) {
  return a.replace(/^[\s\xa0]+/, '');
};
goog.string.trimRight = function (a) {
  return a.replace(/[\s\xa0]+$/, '');
};
goog.string.caseInsensitiveCompare =
  goog.string.internal.caseInsensitiveCompare;
goog.string.numberAwareCompare_ = function (a, b, c) {
  if (a == b) return 0;
  if (!a) return -1;
  if (!b) return 1;
  for (
    var d = a.toLowerCase().match(c),
      e = b.toLowerCase().match(c),
      f = Math.min(d.length, e.length),
      g = 0;
    g < f;
    g++
  ) {
    c = d[g];
    var h = e[g];
    if (c != h)
      return (
        (a = parseInt(c, 10)),
        !isNaN(a) && ((b = parseInt(h, 10)), !isNaN(b) && a - b)
          ? a - b
          : c < h
          ? -1
          : 1
      );
  }
  return d.length != e.length ? d.length - e.length : a < b ? -1 : 1;
};
goog.string.intAwareCompare = function (a, b) {
  return goog.string.numberAwareCompare_(a, b, /\d+|\D+/g);
};
goog.string.floatAwareCompare = function (a, b) {
  return goog.string.numberAwareCompare_(a, b, /\d+|\.\d+|\D+/g);
};
goog.string.numerateCompare = goog.string.floatAwareCompare;
goog.string.urlEncode = function (a) {
  return encodeURIComponent(String(a));
};
goog.string.urlDecode = function (a) {
  return decodeURIComponent(a.replace(/\+/g, ' '));
};
goog.string.newLineToBr = goog.string.internal.newLineToBr;
goog.string.htmlEscape = function (a, b) {
  a = goog.string.internal.htmlEscape(a, b);
  goog.string.DETECT_DOUBLE_ESCAPING &&
    (a = a.replace(goog.string.E_RE_, '&#101;'));
  return a;
};
goog.string.E_RE_ = /e/g;
goog.string.unescapeEntities = function (a) {
  return goog.string.contains(a, '&')
    ? !goog.string.FORCE_NON_DOM_HTML_UNESCAPING && 'document' in goog.global
      ? goog.string.unescapeEntitiesUsingDom_(a)
      : goog.string.unescapePureXmlEntities_(a)
    : a;
};
goog.string.unescapeEntitiesWithDocument = function (a, b) {
  return goog.string.contains(a, '&')
    ? goog.string.unescapeEntitiesUsingDom_(a, b)
    : a;
};
goog.string.unescapeEntitiesUsingDom_ = function (a, b) {
  var c = {
    '&amp;': '&',
    '&lt;': '<',
    '&gt;': '>',
    '&quot;': '"',
  };
  var d = b
    ? b.createElement('div')
    : goog.global.document.createElement('div');
  return a.replace(goog.string.HTML_ENTITY_PATTERN_, function (a, b) {
    var e = c[a];
    if (e) return e;
    '#' == b.charAt(0) &&
      ((b = Number('0' + b.substr(1))),
      isNaN(b) || (e = String.fromCharCode(b)));
    e ||
      (goog.dom.safe.setInnerHtml(
        d,
        goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(
          goog.string.Const.from('Single HTML entity.'),
          a + ' '
        )
      ),
      (e = d.firstChild.nodeValue.slice(0, -1)));
    return (c[a] = e);
  });
};
goog.string.unescapePureXmlEntities_ = function (a) {
  return a.replace(/&([^;]+);/g, function (a, c) {
    switch (c) {
      case 'amp':
        return '&';
      case 'lt':
        return '<';
      case 'gt':
        return '>';
      case 'quot':
        return '"';
      default:
        return '#' != c.charAt(0) || ((c = Number('0' + c.substr(1))), isNaN(c))
          ? a
          : String.fromCharCode(c);
    }
  });
};
goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
goog.string.whitespaceEscape = function (a, b) {
  return goog.string.newLineToBr(a.replace(/  /g, ' &#160;'), b);
};
goog.string.preserveSpaces = function (a) {
  return a.replace(/(^|[\n ]) /g, '$1' + goog.string.Unicode.NBSP);
};
goog.string.stripQuotes = function (a, b) {
  for (var c = b.length, d = 0; d < c; d++) {
    var e = 1 == c ? b : b.charAt(d);
    if (a.charAt(0) == e && a.charAt(a.length - 1) == e)
      return a.substring(1, a.length - 1);
  }
  return a;
};
goog.string.truncate = function (a, b, c) {
  c && (a = goog.string.unescapeEntities(a));
  a.length > b && (a = a.substring(0, b - 3) + '...');
  c && (a = goog.string.htmlEscape(a));
  return a;
};
goog.string.truncateMiddle = function (a, b, c, d) {
  c && (a = goog.string.unescapeEntities(a));
  if (d && a.length > b) {
    d > b && (d = b);
    var e = a.length - d;
    a = a.substring(0, b - d) + '...' + a.substring(e);
  } else
    a.length > b &&
      ((d = Math.floor(b / 2)),
      (e = a.length - d),
      (a = a.substring(0, d + (b % 2)) + '...' + a.substring(e)));
  c && (a = goog.string.htmlEscape(a));
  return a;
};
goog.string.specialEscapeChars_ = {
  '\x00': '\\0',
  '\b': '\\b',
  '\f': '\\f',
  '\n': '\\n',
  '\r': '\\r',
  '\t': '\\t',
  '\x0B': '\\x0B',
  '"': '\\"',
  '\\': '\\\\',
  '<': '\\u003C',
};
goog.string.jsEscapeCache_ = {
  "'": "\\'",
};
goog.string.quote = function (a) {
  a = String(a);
  for (var b = ['"'], c = 0; c < a.length; c++) {
    var d = a.charAt(c),
      e = d.charCodeAt(0);
    b[c + 1] =
      goog.string.specialEscapeChars_[d] ||
      (31 < e && 127 > e ? d : goog.string.escapeChar(d));
  }
  b.push('"');
  return b.join('');
};
goog.string.escapeString = function (a) {
  for (var b = [], c = 0; c < a.length; c++)
    b[c] = goog.string.escapeChar(a.charAt(c));
  return b.join('');
};
goog.string.escapeChar = function (a) {
  if (a in goog.string.jsEscapeCache_) return goog.string.jsEscapeCache_[a];
  if (a in goog.string.specialEscapeChars_)
    return (goog.string.jsEscapeCache_[a] = goog.string.specialEscapeChars_[a]);
  var b = a.charCodeAt(0);
  if (31 < b && 127 > b) var c = a;
  else {
    if (256 > b) {
      if (((c = '\\x'), 16 > b || 256 < b)) c += '0';
    } else (c = '\\u'), 4096 > b && (c += '0');
    c += b.toString(16).toUpperCase();
  }
  return (goog.string.jsEscapeCache_[a] = c);
};
goog.string.contains = goog.string.internal.contains;
goog.string.caseInsensitiveContains =
  goog.string.internal.caseInsensitiveContains;
goog.string.countOf = function (a, b) {
  return a && b ? a.split(b).length - 1 : 0;
};
goog.string.removeAt = function (a, b, c) {
  var d = a;
  0 <= b &&
    b < a.length &&
    0 < c &&
    (d = a.substr(0, b) + a.substr(b + c, a.length - b - c));
  return d;
};
goog.string.remove = function (a, b) {
  return a.replace(b, '');
};
goog.string.removeAll = function (a, b) {
  b = new RegExp(goog.string.regExpEscape(b), 'g');
  return a.replace(b, '');
};
goog.string.replaceAll = function (a, b, c) {
  b = new RegExp(goog.string.regExpEscape(b), 'g');
  return a.replace(b, c.replace(/\$/g, '$$$$'));
};
goog.string.regExpEscape = function (a) {
  return String(a)
    .replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1')
    .replace(/\x08/g, '\\x08');
};
goog.string.repeat = String.prototype.repeat
  ? function (a, b) {
      return a.repeat(b);
    }
  : function (a, b) {
      return Array(b + 1).join(a);
    };
goog.string.padNumber = function (a, b, c) {
  a = goog.isDef(c) ? a.toFixed(c) : String(a);
  c = a.indexOf('.');
  -1 == c && (c = a.length);
  return goog.string.repeat('0', Math.max(0, b - c)) + a;
};
goog.string.makeSafe = function (a) {
  return null == a ? '' : String(a);
};
goog.string.buildString = function (a) {
  return Array.prototype.join.call(arguments, '');
};
goog.string.getRandomString = function () {
  return (
    Math.floor(2147483648 * Math.random()).toString(36) +
    Math.abs(Math.floor(2147483648 * Math.random()) ^ goog.now()).toString(36)
  );
};
goog.string.compareVersions = goog.string.internal.compareVersions;
goog.string.hashCode = function (a) {
  for (var b = 0, c = 0; c < a.length; ++c)
    b = (31 * b + a.charCodeAt(c)) >>> 0;
  return b;
};
goog.string.uniqueStringCounter_ = (2147483648 * Math.random()) | 0;
goog.string.createUniqueString = function () {
  return 'goog_' + goog.string.uniqueStringCounter_++;
};
goog.string.toNumber = function (a) {
  var b = Number(a);
  return 0 == b && goog.string.isEmptyOrWhitespace(a) ? NaN : b;
};
goog.string.isLowerCamelCase = function (a) {
  return /^[a-z]+([A-Z][a-z]*)*$/.test(a);
};
goog.string.isUpperCamelCase = function (a) {
  return /^([A-Z][a-z]*)+$/.test(a);
};
goog.string.toCamelCase = function (a) {
  return String(a).replace(/\-([a-z])/g, function (a, c) {
    return c.toUpperCase();
  });
};
goog.string.toSelectorCase = function (a) {
  return String(a)
    .replace(/([A-Z])/g, '-$1')
    .toLowerCase();
};
goog.string.toTitleCase = function (a, b) {
  b = goog.isString(b) ? goog.string.regExpEscape(b) : '\\s';
  return a.replace(
    new RegExp('(^' + (b ? '|[' + b + ']+' : '') + ')([a-z])', 'g'),
    function (a, b, e) {
      return b + e.toUpperCase();
    }
  );
};
goog.string.capitalize = function (a) {
  return String(a.charAt(0)).toUpperCase() + String(a.substr(1)).toLowerCase();
};
goog.string.parseInt = function (a) {
  isFinite(a) && (a = String(a));
  return goog.isString(a)
    ? /^\s*-?0x/i.test(a)
      ? parseInt(a, 16)
      : parseInt(a, 10)
    : NaN;
};
goog.string.splitLimit = function (a, b, c) {
  a = a.split(b);
  for (var d = []; 0 < c && a.length; ) d.push(a.shift()), c--;
  a.length && d.push(a.join(b));
  return d;
};
goog.string.lastComponent = function (a, b) {
  if (b) 'string' == typeof b && (b = [b]);
  else return a;
  for (var c = -1, d = 0; d < b.length; d++)
    if ('' != b[d]) {
      var e = a.lastIndexOf(b[d]);
      e > c && (c = e);
    }
  return -1 == c ? a : a.slice(c + 1);
};
goog.string.editDistance = function (a, b) {
  var c = [],
    d = [];
  if (a == b) return 0;
  if (!a.length || !b.length) return Math.max(a.length, b.length);
  for (var e = 0; e < b.length + 1; e++) c[e] = e;
  for (e = 0; e < a.length; e++) {
    d[0] = e + 1;
    for (var f = 0; f < b.length; f++)
      d[f + 1] = Math.min(d[f] + 1, c[f + 1] + 1, c[f] + Number(a[e] != b[f]));
    for (f = 0; f < c.length; f++) c[f] = d[f];
  }
  return d[b.length];
};
goog.labs.userAgent.platform = {};
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.isChromecast = function () {
  return goog.labs.userAgent.util.matchUserAgent('CrKey');
};
goog.labs.userAgent.platform.isKaiOS = function () {
  return goog.labs.userAgent.util.matchUserAgentIgnoreCase('KaiOS');
};
goog.labs.userAgent.platform.isGo2Phone = function () {
  return goog.labs.userAgent.util.matchUserAgentIgnoreCase('GAFP');
};
goog.labs.userAgent.platform.getVersion = function () {
  var a = goog.labs.userAgent.util.getUserAgent(),
    b = '';
  goog.labs.userAgent.platform.isWindows()
    ? ((b = /Windows (?:NT|Phone) ([0-9.]+)/),
      (b = (a = b.exec(a)) ? a[1] : '0.0'))
    : goog.labs.userAgent.platform.isIos()
    ? ((b = /(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/),
      (b = (a = b.exec(a)) && a[1].replace(/_/g, '.')))
    : goog.labs.userAgent.platform.isMacintosh()
    ? ((b = /Mac OS X ([0-9_.]+)/),
      (b = (a = b.exec(a)) ? a[1].replace(/_/g, '.') : '10'))
    : goog.labs.userAgent.platform.isKaiOS()
    ? ((b = /(?:KaiOS)\/(\S+)/i), (b = (a = b.exec(a)) && a[1]))
    : goog.labs.userAgent.platform.isAndroid()
    ? ((b = /Android\s+([^\);]+)(\)|;)/), (b = (a = b.exec(a)) && a[1]))
    : goog.labs.userAgent.platform.isChromeOS() &&
      ((b = /(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/),
      (b = (a = b.exec(a)) && a[1]));
  return b || '';
};
goog.labs.userAgent.platform.isVersionOrHigher = function (a) {
  return (
    0 <=
    goog.string.compareVersions(goog.labs.userAgent.platform.getVersion(), a)
  );
};
goog.reflect = {};
goog.reflect.object = function (a, b) {
  return b;
};
goog.reflect.objectProperty = function (a, b) {
  return a;
};
goog.reflect.sinkValue = function (a) {
  goog.reflect.sinkValue[' '](a);
  return a;
};
goog.reflect.sinkValue[' '] = goog.nullFunction;
goog.reflect.canAccessProperty = function (a, b) {
  try {
    return goog.reflect.sinkValue(a[b]), !0;
  } catch (c) {}
  return !1;
};
goog.reflect.cache = function (a, b, c, d) {
  d = d ? d(b) : b;
  return Object.prototype.hasOwnProperty.call(a, d) ? a[d] : (a[d] = c(b));
};
goog.labs.userAgent.engine = {};
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.isEdge = function () {
  return goog.labs.userAgent.util.matchUserAgent('Edge');
};
goog.labs.userAgent.engine.isWebKit = function () {
  return (
    goog.labs.userAgent.util.matchUserAgentIgnoreCase('WebKit') &&
    !goog.labs.userAgent.engine.isEdge()
  );
};
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.isEdge()
  );
};
goog.labs.userAgent.engine.getVersion = function () {
  var a = goog.labs.userAgent.util.getUserAgent();
  if (a) {
    a = goog.labs.userAgent.util.extractVersionTuples(a);
    var b = goog.labs.userAgent.engine.getEngineTuple_(a);
    if (b)
      return 'Gecko' == b[0]
        ? goog.labs.userAgent.engine.getVersionForKey_(a, 'Firefox')
        : b[1];
    a = a[0];
    var c;
    if (a && (c = a[2]) && (c = /Trident\/([^\s;]+)/.exec(c))) return c[1];
  }
  return '';
};
goog.labs.userAgent.engine.getEngineTuple_ = function (a) {
  if (!goog.labs.userAgent.engine.isEdge()) return a[1];
  for (var b = 0; b < a.length; b++) {
    var c = a[b];
    if ('Edge' == c[0]) return c;
  }
};
goog.labs.userAgent.engine.isVersionOrHigher = function (a) {
  return (
    0 <= goog.string.compareVersions(goog.labs.userAgent.engine.getVersion(), a)
  );
};
goog.labs.userAgent.engine.getVersionForKey_ = function (a, b) {
  return (
    ((a = goog.array.find(a, function (a) {
      return b == a[0];
    })) &&
      a[1]) ||
    ''
  );
};
goog.userAgent = {};
goog.userAgent.ASSUME_IE = !1;
goog.userAgent.ASSUME_EDGE = !1;
goog.userAgent.ASSUME_GECKO = !1;
goog.userAgent.ASSUME_WEBKIT = !1;
goog.userAgent.ASSUME_MOBILE_WEBKIT = !1;
goog.userAgent.ASSUME_OPERA = !1;
goog.userAgent.ASSUME_ANY_VERSION = !1;
goog.userAgent.BROWSER_KNOWN_ =
  goog.userAgent.ASSUME_IE ||
  goog.userAgent.ASSUME_EDGE ||
  goog.userAgent.ASSUME_GECKO ||
  goog.userAgent.ASSUME_MOBILE_WEBKIT ||
  goog.userAgent.ASSUME_WEBKIT ||
  goog.userAgent.ASSUME_OPERA;
goog.userAgent.getUserAgentString = function () {
  return goog.labs.userAgent.util.getUserAgent();
};
goog.userAgent.getNavigatorTyped = function () {
  return goog.global.navigator || null;
};
goog.userAgent.getNavigator = function () {
  return goog.userAgent.getNavigatorTyped();
};
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.EDGE = goog.userAgent.BROWSER_KNOWN_
  ? goog.userAgent.ASSUME_EDGE
  : goog.labs.userAgent.engine.isEdge();
goog.userAgent.EDGE_OR_IE = goog.userAgent.EDGE || goog.userAgent.IE;
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 a = goog.userAgent.getNavigatorTyped();
  return (a && a.platform) || '';
};
goog.userAgent.PLATFORM = goog.userAgent.determinePlatform_();
goog.userAgent.ASSUME_MAC = !1;
goog.userAgent.ASSUME_WINDOWS = !1;
goog.userAgent.ASSUME_LINUX = !1;
goog.userAgent.ASSUME_X11 = !1;
goog.userAgent.ASSUME_ANDROID = !1;
goog.userAgent.ASSUME_IPHONE = !1;
goog.userAgent.ASSUME_IPAD = !1;
goog.userAgent.ASSUME_IPOD = !1;
goog.userAgent.ASSUME_KAIOS = !1;
goog.userAgent.ASSUME_GO2PHONE = !1;
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.ASSUME_IPOD;
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 a = goog.userAgent.getNavigatorTyped();
  return !!a && goog.string.contains(a.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.IPOD = goog.userAgent.PLATFORM_KNOWN_
  ? goog.userAgent.ASSUME_IPOD
  : goog.labs.userAgent.platform.isIpod();
goog.userAgent.IOS = goog.userAgent.PLATFORM_KNOWN_
  ? goog.userAgent.ASSUME_IPHONE ||
    goog.userAgent.ASSUME_IPAD ||
    goog.userAgent.ASSUME_IPOD
  : goog.labs.userAgent.platform.isIos();
goog.userAgent.KAIOS = goog.userAgent.PLATFORM_KNOWN_
  ? goog.userAgent.ASSUME_KAIOS
  : goog.labs.userAgent.platform.isKaiOS();
goog.userAgent.GO2PHONE = goog.userAgent.PLATFORM_KNOWN_
  ? goog.userAgent.ASSUME_GO2PHONE
  : goog.labs.userAgent.platform.isGo2Phone();
goog.userAgent.determineVersion_ = function () {
  var a = '',
    b = goog.userAgent.getVersionRegexResult_();
  b && (a = b ? b[1] : '');
  return goog.userAgent.IE &&
    ((b = goog.userAgent.getDocumentMode_()), null != b && b > parseFloat(a))
    ? String(b)
    : a;
};
goog.userAgent.getVersionRegexResult_ = function () {
  var a = goog.userAgent.getUserAgentString();
  if (goog.userAgent.GECKO) return /rv:([^\);]+)(\)|;)/.exec(a);
  if (goog.userAgent.EDGE) return /Edge\/([\d\.]+)/.exec(a);
  if (goog.userAgent.IE) return /\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(a);
  if (goog.userAgent.WEBKIT) return /WebKit\/(\S+)/.exec(a);
  if (goog.userAgent.OPERA) return /(?:Version)[ \/]?(\S+)/.exec(a);
};
goog.userAgent.getDocumentMode_ = function () {
  var a = goog.global.document;
  return a ? a.documentMode : void 0;
};
goog.userAgent.VERSION = goog.userAgent.determineVersion_();
goog.userAgent.compare = function (a, b) {
  return goog.string.compareVersions(a, b);
};
goog.userAgent.isVersionOrHigherCache_ = {};
goog.userAgent.isVersionOrHigher = function (a) {
  return (
    goog.userAgent.ASSUME_ANY_VERSION ||
    goog.reflect.cache(goog.userAgent.isVersionOrHigherCache_, a, function () {
      return 0 <= goog.string.compareVersions(goog.userAgent.VERSION, a);
    })
  );
};
goog.userAgent.isVersion = goog.userAgent.isVersionOrHigher;
goog.userAgent.isDocumentModeOrHigher = function (a) {
  return Number(goog.userAgent.DOCUMENT_MODE) >= a;
};
goog.userAgent.isDocumentMode = goog.userAgent.isDocumentModeOrHigher;
goog.userAgent.DOCUMENT_MODE = (function () {
  if (goog.global.document && goog.userAgent.IE)
    return goog.userAgent.getDocumentMode_();
})();
goog.userAgent.product = {};
goog.userAgent.product.ASSUME_FIREFOX = !1;
goog.userAgent.product.ASSUME_IPHONE = !1;
goog.userAgent.product.ASSUME_IPAD = !1;
goog.userAgent.product.ASSUME_ANDROID = !1;
goog.userAgent.product.ASSUME_CHROME = !1;
goog.userAgent.product.ASSUME_SAFARI = !1;
goog.userAgent.product.PRODUCT_KNOWN_ =
  goog.userAgent.ASSUME_IE ||
  goog.userAgent.ASSUME_EDGE ||
  goog.userAgent.ASSUME_OPERA ||
  goog.userAgent.product.ASSUME_FIREFOX ||
  goog.userAgent.product.ASSUME_IPHONE ||
  goog.userAgent.product.ASSUME_IPAD ||
  goog.userAgent.product.ASSUME_ANDROID ||
  goog.userAgent.product.ASSUME_CHROME ||
  goog.userAgent.product.ASSUME_SAFARI;
goog.userAgent.product.OPERA = goog.userAgent.OPERA;
goog.userAgent.product.IE = goog.userAgent.IE;
goog.userAgent.product.EDGE = goog.userAgent.EDGE;
goog.userAgent.product.FIREFOX = goog.userAgent.product.PRODUCT_KNOWN_
  ? goog.userAgent.product.ASSUME_FIREFOX
  : goog.labs.userAgent.browser.isFirefox();
goog.userAgent.product.isIphoneOrIpod_ = function () {
  return (
    goog.labs.userAgent.platform.isIphone() ||
    goog.labs.userAgent.platform.isIpod()
  );
};
goog.userAgent.product.IPHONE = goog.userAgent.product.PRODUCT_KNOWN_
  ? goog.userAgent.product.ASSUME_IPHONE
  : goog.userAgent.product.isIphoneOrIpod_();
goog.userAgent.product.IPAD = goog.userAgent.product.PRODUCT_KNOWN_
  ? goog.userAgent.product.ASSUME_IPAD
  : goog.labs.userAgent.platform.isIpad();
goog.userAgent.product.ANDROID = goog.userAgent.product.PRODUCT_KNOWN_
  ? goog.userAgent.product.ASSUME_ANDROID
  : goog.labs.userAgent.browser.isAndroidBrowser();
goog.userAgent.product.CHROME = goog.userAgent.product.PRODUCT_KNOWN_
  ? goog.userAgent.product.ASSUME_CHROME
  : goog.labs.userAgent.browser.isChrome();
goog.userAgent.product.isSafariDesktop_ = function () {
  return (
    goog.labs.userAgent.browser.isSafari() &&
    !goog.labs.userAgent.platform.isIos()
  );
};
goog.userAgent.product.SAFARI = goog.userAgent.product.PRODUCT_KNOWN_
  ? goog.userAgent.product.ASSUME_SAFARI
  : goog.userAgent.product.isSafariDesktop_();
goog.crypt.base64 = {};
goog.crypt.base64.DEFAULT_ALPHABET_COMMON_ =
  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
goog.crypt.base64.ENCODED_VALS =
  goog.crypt.base64.DEFAULT_ALPHABET_COMMON_ + '+/=';
goog.crypt.base64.ENCODED_VALS_WEBSAFE =
  goog.crypt.base64.DEFAULT_ALPHABET_COMMON_ + '-_.';
goog.crypt.base64.Alphabet = {
  DEFAULT: 0,
  NO_PADDING: 1,
  WEBSAFE: 2,
  WEBSAFE_DOT_PADDING: 3,
  WEBSAFE_NO_PADDING: 4,
};
goog.crypt.base64.paddingChars_ = '=.';
goog.crypt.base64.isPadding_ = function (a) {
  return goog.string.contains(goog.crypt.base64.paddingChars_, a);
};
goog.crypt.base64.byteToCharMaps_ = {};
goog.crypt.base64.charToByteMap_ = null;
goog.crypt.base64.ASSUME_NATIVE_SUPPORT_ =
  goog.userAgent.GECKO ||
  (goog.userAgent.WEBKIT && !goog.userAgent.product.SAFARI) ||
  goog.userAgent.OPERA;
goog.crypt.base64.HAS_NATIVE_ENCODE_ =
  goog.crypt.base64.ASSUME_NATIVE_SUPPORT_ ||
  'function' == typeof goog.global.btoa;
goog.crypt.base64.HAS_NATIVE_DECODE_ =
  goog.crypt.base64.ASSUME_NATIVE_SUPPORT_ ||
  (!goog.userAgent.product.SAFARI &&
    !goog.userAgent.IE &&
    'function' == typeof goog.global.atob);
goog.crypt.base64.encodeByteArray = function (a, b) {
  goog.asserts.assert(
    goog.isArrayLike(a),
    'encodeByteArray takes an array as a parameter'
  );
  void 0 === b && (b = goog.crypt.base64.Alphabet.DEFAULT);
  goog.crypt.base64.init_();
  b = goog.crypt.base64.byteToCharMaps_[b];
  for (var c = [], d = 0; d < a.length; d += 3) {
    var e = a[d],
      f = d + 1 < a.length,
      g = f ? a[d + 1] : 0,
      h = d + 2 < a.length,
      k = h ? a[d + 2] : 0,
      l = e >> 2;
    e = ((e & 3) << 4) | (g >> 4);
    g = ((g & 15) << 2) | (k >> 6);
    k &= 63;
    h || ((k = 64), f || (g = 64));
    c.push(b[l], b[e], b[g] || '', b[k] || '');
  }
  return c.join('');
};
goog.crypt.base64.encodeString = function (a, b) {
  return goog.crypt.base64.HAS_NATIVE_ENCODE_ && !b
    ? goog.global.btoa(a)
    : goog.crypt.base64.encodeByteArray(goog.crypt.stringToByteArray(a), b);
};
goog.crypt.base64.decodeString = function (a, b) {
  if (goog.crypt.base64.HAS_NATIVE_DECODE_ && !b) return goog.global.atob(a);
  var c = '';
  goog.crypt.base64.decodeStringInternal_(a, function (a) {
    c += String.fromCharCode(a);
  });
  return c;
};
goog.crypt.base64.decodeStringToByteArray = function (a, b) {
  var c = [];
  goog.crypt.base64.decodeStringInternal_(a, function (a) {
    c.push(a);
  });
  return c;
};
goog.crypt.base64.decodeStringToUint8Array = function (a) {
  goog.asserts.assert(
    !goog.userAgent.IE || goog.userAgent.isVersionOrHigher('10'),
    'Browser does not support typed arrays'
  );
  var b = a.length,
    c = (3 * b) / 4;
  c % 3
    ? (c = Math.floor(c))
    : goog.crypt.base64.isPadding_(a[b - 1]) &&
      (c = goog.crypt.base64.isPadding_(a[b - 2]) ? c - 2 : c - 1);
  var d = new Uint8Array(c),
    e = 0;
  goog.crypt.base64.decodeStringInternal_(a, function (a) {
    d[e++] = a;
  });
  return d.subarray(0, e);
};
goog.crypt.base64.decodeStringInternal_ = function (a, b) {
  function c(b) {
    for (; d < a.length; ) {
      var c = a.charAt(d++),
        e = goog.crypt.base64.charToByteMap_[c];
      if (null != e) return e;
      if (!goog.string.isEmptyOrWhitespace(c))
        throw Error('Unknown base64 encoding at char: ' + c);
    }
    return b;
  }
  goog.crypt.base64.init_();
  for (var d = 0; ; ) {
    var e = c(-1),
      f = c(0),
      g = c(64),
      h = c(64);
    if (64 === h && -1 === e) break;
    b((e << 2) | (f >> 4));
    64 != g &&
      (b(((f << 4) & 240) | (g >> 2)), 64 != h && b(((g << 6) & 192) | h));
  }
};
goog.crypt.base64.init_ = function () {
  if (!goog.crypt.base64.charToByteMap_) {
    goog.crypt.base64.charToByteMap_ = {};
    for (
      var a = goog.crypt.base64.DEFAULT_ALPHABET_COMMON_.split(''),
        b = ['+/=', '+/', '-_=', '-_.', '-_'],
        c = 0;
      5 > c;
      c++
    ) {
      var d = a.concat(b[c].split(''));
      goog.crypt.base64.byteToCharMaps_[c] = d;
      for (var e = 0; e < d.length; e++) {
        var f = d[e],
          g = goog.crypt.base64.charToByteMap_[f];
        void 0 === g
          ? (goog.crypt.base64.charToByteMap_[f] = e)
          : goog.asserts.assert(g === e);
      }
    }
  }
};
jspb.utils = {};
jspb.utils.split64Low = 0;
jspb.utils.split64High = 0;
jspb.utils.splitUint64 = function (a) {
  var b = a >>> 0;
  a = Math.floor((a - b) / jspb.BinaryConstants.TWO_TO_32) >>> 0;
  jspb.utils.split64Low = b;
  jspb.utils.split64High = a;
};
jspb.utils.splitInt64 = function (a) {
  var b = 0 > a;
  a = Math.abs(a);
  var c = a >>> 0;
  a = Math.floor((a - c) / jspb.BinaryConstants.TWO_TO_32);
  a >>>= 0;
  b &&
    ((a = ~a >>> 0),
    (c = (~c >>> 0) + 1),
    4294967295 < c && ((c = 0), a++, 4294967295 < a && (a = 0)));
  jspb.utils.split64Low = c;
  jspb.utils.split64High = a;
};
jspb.utils.splitZigzag64 = function (a) {
  var b = 0 > a;
  a = 2 * Math.abs(a);
  jspb.utils.splitUint64(a);
  a = jspb.utils.split64Low;
  var c = jspb.utils.split64High;
  b &&
    (0 == a ? (0 == c ? (c = a = 4294967295) : (c--, (a = 4294967295))) : a--);
  jspb.utils.split64Low = a;
  jspb.utils.split64High = c;
};
jspb.utils.splitFloat32 = function (a) {
  var b = 0 > a ? 1 : 0;
  a = b ? -a : a;
  if (0 === a)
    0 < 1 / a
      ? ((jspb.utils.split64High = 0), (jspb.utils.split64Low = 0))
      : ((jspb.utils.split64High = 0), (jspb.utils.split64Low = 2147483648));
  else if (isNaN(a))
    (jspb.utils.split64High = 0), (jspb.utils.split64Low = 2147483647);
  else if (a > jspb.BinaryConstants.FLOAT32_MAX)
    (jspb.utils.split64High = 0),
      (jspb.utils.split64Low = ((b << 31) | 2139095040) >>> 0);
  else if (a < jspb.BinaryConstants.FLOAT32_MIN)
    (a = Math.round(a / Math.pow(2, -149))),
      (jspb.utils.split64High = 0),
      (jspb.utils.split64Low = ((b << 31) | a) >>> 0);
  else {
    var c = Math.floor(Math.log(a) / Math.LN2);
    a *= Math.pow(2, -c);
    a = Math.round(a * jspb.BinaryConstants.TWO_TO_23) & 8388607;
    jspb.utils.split64High = 0;
    jspb.utils.split64Low = ((b << 31) | ((c + 127) << 23) | a) >>> 0;
  }
};
jspb.utils.splitFloat64 = function (a) {
  var b = 0 > a ? 1 : 0;
  a = b ? -a : a;
  if (0 === a)
    (jspb.utils.split64High = 0 < 1 / a ? 0 : 2147483648),
      (jspb.utils.split64Low = 0);
  else if (isNaN(a))
    (jspb.utils.split64High = 2147483647), (jspb.utils.split64Low = 4294967295);
  else if (a > jspb.BinaryConstants.FLOAT64_MAX)
    (jspb.utils.split64High = ((b << 31) | 2146435072) >>> 0),
      (jspb.utils.split64Low = 0);
  else if (a < jspb.BinaryConstants.FLOAT64_MIN) {
    var c = a / Math.pow(2, -1074);
    a = c / jspb.BinaryConstants.TWO_TO_32;
    jspb.utils.split64High = ((b << 31) | a) >>> 0;
    jspb.utils.split64Low = c >>> 0;
  } else {
    c = a;
    var d = 0;
    if (2 <= c) for (; 2 <= c && 1023 > d; ) d++, (c /= 2);
    else for (; 1 > c && -1022 < d; ) (c *= 2), d--;
    c = a * Math.pow(2, -d);
    a = (c * jspb.BinaryConstants.TWO_TO_20) & 1048575;
    c = (c * jspb.BinaryConstants.TWO_TO_52) >>> 0;
    jspb.utils.split64High = ((b << 31) | ((d + 1023) << 20) | a) >>> 0;
    jspb.utils.split64Low = c;
  }
};
jspb.utils.splitHash64 = function (a) {
  var b = a.charCodeAt(0),
    c = a.charCodeAt(1),
    d = a.charCodeAt(2),
    e = a.charCodeAt(3),
    f = a.charCodeAt(4),
    g = a.charCodeAt(5),
    h = a.charCodeAt(6);
  a = a.charCodeAt(7);
  jspb.utils.split64Low = (b + (c << 8) + (d << 16) + (e << 24)) >>> 0;
  jspb.utils.split64High = (f + (g << 8) + (h << 16) + (a << 24)) >>> 0;
};
jspb.utils.joinUint64 = function (a, b) {
  return b * jspb.BinaryConstants.TWO_TO_32 + (a >>> 0);
};
jspb.utils.joinInt64 = function (a, b) {
  var c = b & 2147483648;
  c && ((a = (~a + 1) >>> 0), (b = ~b >>> 0), 0 == a && (b = (b + 1) >>> 0));
  a = jspb.utils.joinUint64(a, b);
  return c ? -a : a;
};
jspb.utils.toZigzag64 = function (a, b, c) {
  var d = b >> 31;
  return c((a << 1) ^ d, ((b << 1) | (a >>> 31)) ^ d);
};
jspb.utils.joinZigzag64 = function (a, b) {
  return jspb.utils.fromZigzag64(a, b, jspb.utils.joinInt64);
};
jspb.utils.fromZigzag64 = function (a, b, c) {
  var d = -(a & 1);
  return c(((a >>> 1) | (b << 31)) ^ d, (b >>> 1) ^ d);
};
jspb.utils.joinFloat32 = function (a, b) {
  b = 2 * (a >> 31) + 1;
  var c = (a >>> 23) & 255;
  a &= 8388607;
  return 255 == c
    ? a
      ? NaN
      : Infinity * b
    : 0 == c
    ? b * Math.pow(2, -149) * a
    : b * Math.pow(2, c - 150) * (a + Math.pow(2, 23));
};
jspb.utils.joinFloat64 = function (a, b) {
  var c = 2 * (b >> 31) + 1,
    d = (b >>> 20) & 2047;
  a = jspb.BinaryConstants.TWO_TO_32 * (b & 1048575) + a;
  return 2047 == d
    ? a
      ? NaN
      : Infinity * c
    : 0 == d
    ? c * Math.pow(2, -1074) * a
    : c * Math.pow(2, d - 1075) * (a + jspb.BinaryConstants.TWO_TO_52);
};
jspb.utils.joinHash64 = function (a, b) {
  return String.fromCharCode(
    (a >>> 0) & 255,
    (a >>> 8) & 255,
    (a >>> 16) & 255,
    (a >>> 24) & 255,
    (b >>> 0) & 255,
    (b >>> 8) & 255,
    (b >>> 16) & 255,
    (b >>> 24) & 255
  );
};
jspb.utils.DIGITS = '0123456789abcdef'.split('');
jspb.utils.ZERO_CHAR_CODE_ = 48;
jspb.utils.A_CHAR_CODE_ = 97;
jspb.utils.joinUnsignedDecimalString = function (a, b) {
  function c(a, b) {
    a = a ? String(a) : '';
    return b ? '0000000'.slice(a.length) + a : a;
  }
  if (2097151 >= b) return '' + (jspb.BinaryConstants.TWO_TO_32 * b + a);
  var d = (((a >>> 24) | (b << 8)) >>> 0) & 16777215;
  b = (b >> 16) & 65535;
  a = (a & 16777215) + 6777216 * d + 6710656 * b;
  d += 8147497 * b;
  b *= 2;
  1e7 <= a && ((d += Math.floor(a / 1e7)), (a %= 1e7));
  1e7 <= d && ((b += Math.floor(d / 1e7)), (d %= 1e7));
  return c(b, 0) + c(d, b) + c(a, 1);
};
jspb.utils.joinSignedDecimalString = function (a, b) {
  var c = b & 2147483648;
  c && ((a = (~a + 1) >>> 0), (b = (~b + (0 == a ? 1 : 0)) >>> 0));
  a = jspb.utils.joinUnsignedDecimalString(a, b);
  return c ? '-' + a : a;
};
jspb.utils.hash64ToDecimalString = function (a, b) {
  jspb.utils.splitHash64(a);
  a = jspb.utils.split64Low;
  var c = jspb.utils.split64High;
  return b
    ? jspb.utils.joinSignedDecimalString(a, c)
    : jspb.utils.joinUnsignedDecimalString(a, c);
};
jspb.utils.hash64ArrayToDecimalStrings = function (a, b) {
  for (var c = Array(a.length), d = 0; d < a.length; d++)
    c[d] = jspb.utils.hash64ToDecimalString(a[d], b);
  return c;
};
jspb.utils.decimalStringToHash64 = function (a) {
  function b(a, b) {
    for (var c = 0; 8 > c && (1 !== a || 0 < b); c++)
      (b = a * e[c] + b), (e[c] = b & 255), (b >>>= 8);
  }

  function c() {
    for (var a = 0; 8 > a; a++) e[a] = ~e[a] & 255;
  }
  goog.asserts.assert(0 < a.length);
  var d = !1;
  '-' === a[0] && ((d = !0), (a = a.slice(1)));
  for (var e = [0, 0, 0, 0, 0, 0, 0, 0], f = 0; f < a.length; f++)
    b(10, a.charCodeAt(f) - jspb.utils.ZERO_CHAR_CODE_);
  d && (c(), b(1, 1));
  return goog.crypt.byteArrayToString(e);
};
jspb.utils.splitDecimalString = function (a) {
  jspb.utils.splitHash64(jspb.utils.decimalStringToHash64(a));
};
jspb.utils.toHexDigit_ = function (a) {
  return String.fromCharCode(
    10 > a ? jspb.utils.ZERO_CHAR_CODE_ + a : jspb.utils.A_CHAR_CODE_ - 10 + a
  );
};
jspb.utils.fromHexCharCode_ = function (a) {
  return a >= jspb.utils.A_CHAR_CODE_
    ? a - jspb.utils.A_CHAR_CODE_ + 10
    : a - jspb.utils.ZERO_CHAR_CODE_;
};
jspb.utils.hash64ToHexString = function (a) {
  var b = Array(18);
  b[0] = '0';
  b[1] = 'x';
  for (var c = 0; 8 > c; c++) {
    var d = a.charCodeAt(7 - c);
    b[2 * c + 2] = jspb.utils.toHexDigit_(d >> 4);
    b[2 * c + 3] = jspb.utils.toHexDigit_(d & 15);
  }
  return b.join('');
};
jspb.utils.hexStringToHash64 = function (a) {
  a = a.toLowerCase();
  goog.asserts.assert(18 == a.length);
  goog.asserts.assert('0' == a[0]);
  goog.asserts.assert('x' == a[1]);
  for (var b = '', c = 0; 8 > c; c++) {
    var d = jspb.utils.fromHexCharCode_(a.charCodeAt(2 * c + 2)),
      e = jspb.utils.fromHexCharCode_(a.charCodeAt(2 * c + 3));
    b = String.fromCharCode(16 * d + e) + b;
  }
  return b;
};
jspb.utils.hash64ToNumber = function (a, b) {
  jspb.utils.splitHash64(a);
  a = jspb.utils.split64Low;
  var c = jspb.utils.split64High;
  return b ? jspb.utils.joinInt64(a, c) : jspb.utils.joinUint64(a, c);
};
jspb.utils.numberToHash64 = function (a) {
  jspb.utils.splitInt64(a);
  return jspb.utils.joinHash64(jspb.utils.split64Low, jspb.utils.split64High);
};
jspb.utils.countVarints = function (a, b, c) {
  for (var d = 0, e = b; e < c; e++) d += a[e] >> 7;
  return c - b - d;
};
jspb.utils.countVarintFields = function (a, b, c, d) {
  var e = 0;
  d = 8 * d + jspb.BinaryConstants.WireType.VARINT;
  if (128 > d)
    for (; b < c && a[b++] == d; )
      for (e++; ; ) {
        var f = a[b++];
        if (0 == (f & 128)) break;
      }
  else
    for (; b < c; ) {
      for (f = d; 128 < f; ) {
        if (a[b] != ((f & 127) | 128)) return e;
        b++;
        f >>= 7;
      }
      if (a[b++] != f) break;
      for (e++; (f = a[b++]), 0 != (f & 128); );
    }
  return e;
};
jspb.utils.countFixedFields_ = function (a, b, c, d, e) {
  var f = 0;
  if (128 > d) for (; b < c && a[b++] == d; ) f++, (b += e);
  else
    for (; b < c; ) {
      for (var g = d; 128 < g; ) {
        if (a[b++] != ((g & 127) | 128)) return f;
        g >>= 7;
      }
      if (a[b++] != g) break;
      f++;
      b += e;
    }
  return f;
};
jspb.utils.countFixed32Fields = function (a, b, c, d) {
  return jspb.utils.countFixedFields_(
    a,
    b,
    c,
    8 * d + jspb.BinaryConstants.WireType.FIXED32,
    4
  );
};
jspb.utils.countFixed64Fields = function (a, b, c, d) {
  return jspb.utils.countFixedFields_(
    a,
    b,
    c,
    8 * d + jspb.BinaryConstants.WireType.FIXED64,
    8
  );
};
jspb.utils.countDelimitedFields = function (a, b, c, d) {
  var e = 0;
  for (d = 8 * d + jspb.BinaryConstants.WireType.DELIMITED; b < c; ) {
    for (var f = d; 128 < f; ) {
      if (a[b++] != ((f & 127) | 128)) return e;
      f >>= 7;
    }
    if (a[b++] != f) break;
    e++;
    for (
      var g = 0, h = 1;
      (f = a[b++]), (g += (f & 127) * h), (h *= 128), 0 != (f & 128);

    );
    b += g;
  }
  return e;
};
jspb.utils.debugBytesToTextFormat = function (a) {
  var b = '"';
  if (a) {
    a = jspb.utils.byteSourceToUint8Array(a);
    for (var c = 0; c < a.length; c++)
      (b += '\\x'), 16 > a[c] && (b += '0'), (b += a[c].toString(16));
  }
  return b + '"';
};
jspb.utils.debugScalarToTextFormat = function (a) {
  return 'string' === typeof a ? goog.string.quote(a) : a.toString();
};
jspb.utils.stringToByteArray = function (a) {
  for (var b = new Uint8Array(a.length), c = 0; c < a.length; c++) {
    var d = a.charCodeAt(c);
    if (255 < d)
      throw Error(
        'Conversion error: string contains codepoint outside of byte range'
      );
    b[c] = d;
  }
  return b;
};
jspb.utils.byteSourceToUint8Array = function (a) {
  if (a.constructor === Uint8Array) return a;
  if (
    a.constructor === ArrayBuffer ||
    ('undefined' != typeof Buffer && a.constructor === Buffer) ||
    a.constructor === Array
  )
    return new Uint8Array(a);
  if (a.constructor === String)
    return goog.crypt.base64.decodeStringToUint8Array(a);
  goog.asserts.fail('Type not convertible to Uint8Array.');
  return new Uint8Array(0);
};
jspb.BinaryDecoder = function (a, b, c) {
  this.bytes_ = null;
  this.cursor_ = this.end_ = this.start_ = 0;
  this.error_ = !1;
  a && this.setBlock(a, b, c);
};
jspb.BinaryDecoder.instanceCache_ = [];
jspb.BinaryDecoder.alloc = function (a, b, c) {
  if (jspb.BinaryDecoder.instanceCache_.length) {
    var d = jspb.BinaryDecoder.instanceCache_.pop();
    a && d.setBlock(a, b, c);
    return d;
  }
  return new jspb.BinaryDecoder(a, b, c);
};
jspb.BinaryDecoder.prototype.free = function () {
  this.clear();
  100 > jspb.BinaryDecoder.instanceCache_.length &&
    jspb.BinaryDecoder.instanceCache_.push(this);
};
jspb.BinaryDecoder.prototype.clone = function () {
  return jspb.BinaryDecoder.alloc(
    this.bytes_,
    this.start_,
    this.end_ - this.start_
  );
};
jspb.BinaryDecoder.prototype.clear = function () {
  this.bytes_ = null;
  this.cursor_ = this.end_ = this.start_ = 0;
  this.error_ = !1;
};
jspb.BinaryDecoder.prototype.getBuffer = function () {
  return this.bytes_;
};
jspb.BinaryDecoder.prototype.setBlock = function (a, b, c) {
  this.bytes_ = jspb.utils.byteSourceToUint8Array(a);
  this.start_ = void 0 !== b ? b : 0;
  this.end_ = void 0 !== c ? this.start_ + c : this.bytes_.length;
  this.cursor_ = this.start_;
};
jspb.BinaryDecoder.prototype.getEnd = function () {
  return this.end_;
};
jspb.BinaryDecoder.prototype.setEnd = function (a) {
  this.end_ = a;
};
jspb.BinaryDecoder.prototype.reset = function () {
  this.cursor_ = this.start_;
};
jspb.BinaryDecoder.prototype.getCursor = function () {
  return this.cursor_;
};
jspb.BinaryDecoder.prototype.setCursor = function (a) {
  this.cursor_ = a;
};
jspb.BinaryDecoder.prototype.advance = function (a) {
  this.cursor_ += a;
  goog.asserts.assert(this.cursor_ <= this.end_);
};
jspb.BinaryDecoder.prototype.atEnd = function () {
  return this.cursor_ == this.end_;
};
jspb.BinaryDecoder.prototype.pastEnd = function () {
  return this.cursor_ > this.end_;
};
jspb.BinaryDecoder.prototype.getError = function () {
  return this.error_ || 0 > this.cursor_ || this.cursor_ > this.end_;
};
jspb.BinaryDecoder.prototype.readSplitVarint64 = function (a) {
  for (var b = 128, c = 0, d = 0, e = 0; 4 > e && 128 <= b; e++)
    (b = this.bytes_[this.cursor_++]), (c |= (b & 127) << (7 * e));
  128 <= b &&
    ((b = this.bytes_[this.cursor_++]),
    (c |= (b & 127) << 28),
    (d |= (b & 127) >> 4));
  if (128 <= b)
    for (e = 0; 5 > e && 128 <= b; e++)
      (b = this.bytes_[this.cursor_++]), (d |= (b & 127) << (7 * e + 3));
  if (128 > b) return a(c >>> 0, d >>> 0);
  goog.asserts.fail('Failed to read varint, encoding is invalid.');
  this.error_ = !0;
};
jspb.BinaryDecoder.prototype.readSplitZigzagVarint64 = function (a) {
  return this.readSplitVarint64(function (b, c) {
    return jspb.utils.fromZigzag64(b, c, a);
  });
};
jspb.BinaryDecoder.prototype.readSplitFixed64 = function (a) {
  var b = this.bytes_,
    c = this.cursor_;
  this.cursor_ += 8;
  for (var d = 0, e = 0, f = c + 7; f >= c; f--)
    (d = (d << 8) | b[f]), (e = (e << 8) | b[f + 4]);
  return a(d, e);
};
jspb.BinaryDecoder.prototype.skipVarint = function () {
  for (; this.bytes_[this.cursor_] & 128; ) this.cursor_++;
  this.cursor_++;
};
jspb.BinaryDecoder.prototype.unskipVarint = function (a) {
  for (; 128 < a; ) this.cursor_--, (a >>>= 7);
  this.cursor_--;
};
jspb.BinaryDecoder.prototype.readUnsignedVarint32 = function () {
  var a = this.bytes_;
  var b = a[this.cursor_ + 0];
  var c = b & 127;
  if (128 > b)
    return (
      (this.cursor_ += 1), goog.asserts.assert(this.cursor_ <= this.end_), c
    );
  b = a[this.cursor_ + 1];
  c |= (b & 127) << 7;
  if (128 > b)
    return (
      (this.cursor_ += 2), goog.asserts.assert(this.cursor_ <= this.end_), c
    );
  b = a[this.cursor_ + 2];
  c |= (b & 127) << 14;
  if (128 > b)
    return (
      (this.cursor_ += 3), goog.asserts.assert(this.cursor_ <= this.end_), c
    );
  b = a[this.cursor_ + 3];
  c |= (b & 127) << 21;
  if (128 > b)
    return (
      (this.cursor_ += 4), goog.asserts.assert(this.cursor_ <= this.end_), c
    );
  b = a[this.cursor_ + 4];
  c |= (b & 15) << 28;
  if (128 > b)
    return (
      (this.cursor_ += 5),
      goog.asserts.assert(this.cursor_ <= this.end_),
      c >>> 0
    );
  this.cursor_ += 5;
  128 <= a[this.cursor_++] &&
    128 <= a[this.cursor_++] &&
    128 <= a[this.cursor_++] &&
    128 <= a[this.cursor_++] &&
    128 <= a[this.cursor_++] &&
    goog.asserts.assert(!1);
  goog.asserts.assert(this.cursor_ <= this.end_);
  return c;
};
jspb.BinaryDecoder.prototype.readSignedVarint32 =
  jspb.BinaryDecoder.prototype.readUnsignedVarint32;
jspb.BinaryDecoder.prototype.readUnsignedVarint32String = function () {
  return this.readUnsignedVarint32().toString();
};
jspb.BinaryDecoder.prototype.readSignedVarint32String = function () {
  return this.readSignedVarint32().toString();
};
jspb.BinaryDecoder.prototype.readZigzagVarint32 = function () {
  var a = this.readUnsignedVarint32();
  return (a >>> 1) ^ -(a & 1);
};
jspb.BinaryDecoder.prototype.readUnsignedVarint64 = function () {
  return this.readSplitVarint64(jspb.utils.joinUint64);
};
jspb.BinaryDecoder.prototype.readUnsignedVarint64String = function () {
  return this.readSplitVarint64(jspb.utils.joinUnsignedDecimalString);
};
jspb.BinaryDecoder.prototype.readSignedVarint64 = function () {
  return this.readSplitVarint64(jspb.utils.joinInt64);
};
jspb.BinaryDecoder.prototype.readSignedVarint64String = function () {
  return this.readSplitVarint64(jspb.utils.joinSignedDecimalString);
};
jspb.BinaryDecoder.prototype.readZigzagVarint64 = function () {
  return this.readSplitVarint64(jspb.utils.joinZigzag64);
};
jspb.BinaryDecoder.prototype.readZigzagVarintHash64 = function () {
  return this.readSplitZigzagVarint64(jspb.utils.joinHash64);
};
jspb.BinaryDecoder.prototype.readZigzagVarint64String = function () {
  return this.readSplitZigzagVarint64(jspb.utils.joinSignedDecimalString);
};
jspb.BinaryDecoder.prototype.readUint8 = function () {
  var a = this.bytes_[this.cursor_ + 0];
  this.cursor_ += 1;
  goog.asserts.assert(this.cursor_ <= this.end_);
  return a;
};
jspb.BinaryDecoder.prototype.readUint16 = function () {
  var a = this.bytes_[this.cursor_ + 0],
    b = this.bytes_[this.cursor_ + 1];
  this.cursor_ += 2;
  goog.asserts.assert(this.cursor_ <= this.end_);
  return (a << 0) | (b << 8);
};
jspb.BinaryDecoder.prototype.readUint32 = function () {
  var a = this.bytes_[this.cursor_ + 0],
    b = this.bytes_[this.cursor_ + 1],
    c = this.bytes_[this.cursor_ + 2],
    d = this.bytes_[this.cursor_ + 3];
  this.cursor_ += 4;
  goog.asserts.assert(this.cursor_ <= this.end_);
  return ((a << 0) | (b << 8) | (c << 16) | (d << 24)) >>> 0;
};
jspb.BinaryDecoder.prototype.readUint64 = function () {
  var a = this.readUint32(),
    b = this.readUint32();
  return jspb.utils.joinUint64(a, b);
};
jspb.BinaryDecoder.prototype.readUint64String = function () {
  var a = this.readUint32(),
    b = this.readUint32();
  return jspb.utils.joinUnsignedDecimalString(a, b);
};
jspb.BinaryDecoder.prototype.readInt8 = function () {
  var a = this.bytes_[this.cursor_ + 0];
  this.cursor_ += 1;
  goog.asserts.assert(this.cursor_ <= this.end_);
  return (a << 24) >> 24;
};
jspb.BinaryDecoder.prototype.readInt16 = function () {
  var a = this.bytes_[this.cursor_ + 0],
    b = this.bytes_[this.cursor_ + 1];
  this.cursor_ += 2;
  goog.asserts.assert(this.cursor_ <= this.end_);
  return (((a << 0) | (b << 8)) << 16) >> 16;
};
jspb.BinaryDecoder.prototype.readInt32 = function () {
  var a = this.bytes_[this.cursor_ + 0],
    b = this.bytes_[this.cursor_ + 1],
    c = this.bytes_[this.cursor_ + 2],
    d = this.bytes_[this.cursor_ + 3];
  this.cursor_ += 4;
  goog.asserts.assert(this.cursor_ <= this.end_);
  return (a << 0) | (b << 8) | (c << 16) | (d << 24);
};
jspb.BinaryDecoder.prototype.readInt64 = function () {
  var a = this.readUint32(),
    b = this.readUint32();
  return jspb.utils.joinInt64(a, b);
};
jspb.BinaryDecoder.prototype.readInt64String = function () {
  var a = this.readUint32(),
    b = this.readUint32();
  return jspb.utils.joinSignedDecimalString(a, b);
};
jspb.BinaryDecoder.prototype.readFloat = function () {
  var a = this.readUint32();
  return jspb.utils.joinFloat32(a, 0);
};
jspb.BinaryDecoder.prototype.readDouble = function () {
  var a = this.readUint32(),
    b = this.readUint32();
  return jspb.utils.joinFloat64(a, b);
};
jspb.BinaryDecoder.prototype.readBool = function () {
  return !!this.bytes_[this.cursor_++];
};
jspb.BinaryDecoder.prototype.readEnum = function () {
  return this.readSignedVarint32();
};
jspb.BinaryDecoder.prototype.readString = function (a) {
  var b = this.bytes_,
    c = this.cursor_;
  a = c + a;
  for (var d = [], e = ''; c < a; ) {
    var f = b[c++];
    if (128 > f) d.push(f);
    else if (192 > f) continue;
    else if (224 > f) {
      var g = b[c++];
      d.push(((f & 31) << 6) | (g & 63));
    } else if (240 > f) {
      g = b[c++];
      var h = b[c++];
      d.push(((f & 15) << 12) | ((g & 63) << 6) | (h & 63));
    } else if (248 > f) {
      g = b[c++];
      h = b[c++];
      var k = b[c++];
      f = ((f & 7) << 18) | ((g & 63) << 12) | ((h & 63) << 6) | (k & 63);
      f -= 65536;
      d.push(((f >> 10) & 1023) + 55296, (f & 1023) + 56320);
    }
    8192 <= d.length &&
      ((e += String.fromCharCode.apply(null, d)), (d.length = 0));
  }
  e += goog.crypt.byteArrayToString(d);
  this.cursor_ = c;
  return e;
};
jspb.BinaryDecoder.prototype.readStringWithLength = function () {
  var a = this.readUnsignedVarint32();
  return this.readString(a);
};
jspb.BinaryDecoder.prototype.readBytes = function (a) {
  if (0 > a || this.cursor_ + a > this.bytes_.length)
    return (
      (this.error_ = !0),
      goog.asserts.fail('Invalid byte length!'),
      new Uint8Array(0)
    );
  var b = this.bytes_.subarray(this.cursor_, this.cursor_ + a);
  this.cursor_ += a;
  goog.asserts.assert(this.cursor_ <= this.end_);
  return b;
};
jspb.BinaryDecoder.prototype.readVarintHash64 = function () {
  return this.readSplitVarint64(jspb.utils.joinHash64);
};
jspb.BinaryDecoder.prototype.readFixedHash64 = function () {
  var a = this.bytes_,
    b = this.cursor_,
    c = a[b + 0],
    d = a[b + 1],
    e = a[b + 2],
    f = a[b + 3],
    g = a[b + 4],
    h = a[b + 5],
    k = a[b + 6];
  a = a[b + 7];
  this.cursor_ += 8;
  return String.fromCharCode(c, d, e, f, g, h, k, a);
};
jspb.BinaryReader = function (a, b, c) {
  this.decoder_ = jspb.BinaryDecoder.alloc(a, b, c);
  this.fieldCursor_ = this.decoder_.getCursor();
  this.nextField_ = jspb.BinaryConstants.INVALID_FIELD_NUMBER;
  this.nextWireType_ = jspb.BinaryConstants.WireType.INVALID;
  this.error_ = !1;
  this.readCallbacks_ = null;
};
jspb.BinaryReader.instanceCache_ = [];
jspb.BinaryReader.alloc = function (a, b, c) {
  if (jspb.BinaryReader.instanceCache_.length) {
    var d = jspb.BinaryReader.instanceCache_.pop();
    a && d.decoder_.setBlock(a, b, c);
    return d;
  }
  return new jspb.BinaryReader(a, b, c);
};
jspb.BinaryReader.prototype.alloc = jspb.BinaryReader.alloc;
jspb.BinaryReader.prototype.free = function () {
  this.decoder_.clear();
  this.nextField_ = jspb.BinaryConstants.INVALID_FIELD_NUMBER;
  this.nextWireType_ = jspb.BinaryConstants.WireType.INVALID;
  this.error_ = !1;
  this.readCallbacks_ = null;
  100 > jspb.BinaryReader.instanceCache_.length &&
    jspb.BinaryReader.instanceCache_.push(this);
};
jspb.BinaryReader.prototype.getFieldCursor = function () {
  return this.fieldCursor_;
};
jspb.BinaryReader.prototype.getCursor = function () {
  return this.decoder_.getCursor();
};
jspb.BinaryReader.prototype.getBuffer = function () {
  return this.decoder_.getBuffer();
};
jspb.BinaryReader.prototype.getFieldNumber = function () {
  return this.nextField_;
};
jspb.BinaryReader.prototype.getWireType = function () {
  return this.nextWireType_;
};
jspb.BinaryReader.prototype.isEndGroup = function () {
  return this.nextWireType_ == jspb.BinaryConstants.WireType.END_GROUP;
};
jspb.BinaryReader.prototype.getError = function () {
  return this.error_ || this.decoder_.getError();
};
jspb.BinaryReader.prototype.setBlock = function (a, b, c) {
  this.decoder_.setBlock(a, b, c);
  this.nextField_ = jspb.BinaryConstants.INVALID_FIELD_NUMBER;
  this.nextWireType_ = jspb.BinaryConstants.WireType.INVALID;
};
jspb.BinaryReader.prototype.reset = function () {
  this.decoder_.reset();
  this.nextField_ = jspb.BinaryConstants.INVALID_FIELD_NUMBER;
  this.nextWireType_ = jspb.BinaryConstants.WireType.INVALID;
};
jspb.BinaryReader.prototype.advance = function (a) {
  this.decoder_.advance(a);
};
jspb.BinaryReader.prototype.nextField = function () {
  if (this.decoder_.atEnd()) return !1;
  if (this.getError()) return goog.asserts.fail('Decoder hit an error'), !1;
  this.fieldCursor_ = this.decoder_.getCursor();
  var a = this.decoder_.readUnsignedVarint32(),
    b = a >>> 3;
  a &= 7;
  if (
    a != jspb.BinaryConstants.WireType.VARINT &&
    a != jspb.BinaryConstants.WireType.FIXED32 &&
    a != jspb.BinaryConstants.WireType.FIXED64 &&
    a != jspb.BinaryConstants.WireType.DELIMITED &&
    a != jspb.BinaryConstants.WireType.START_GROUP &&
    a != jspb.BinaryConstants.WireType.END_GROUP
  )
    return (
      goog.asserts.fail(
        'Invalid wire type: %s (at position %s)',
        a,
        this.fieldCursor_
      ),
      (this.error_ = !0),
      !1
    );
  this.nextField_ = b;
  this.nextWireType_ = a;
  return !0;
};
jspb.BinaryReader.prototype.unskipHeader = function () {
  this.decoder_.unskipVarint((this.nextField_ << 3) | this.nextWireType_);
};
jspb.BinaryReader.prototype.skipMatchingFields = function () {
  var a = this.nextField_;
  for (this.unskipHeader(); this.nextField() && this.getFieldNumber() == a; )
    this.skipField();
  this.decoder_.atEnd() || this.unskipHeader();
};
jspb.BinaryReader.prototype.skipVarintField = function () {
  this.nextWireType_ != jspb.BinaryConstants.WireType.VARINT
    ? (goog.asserts.fail('Invalid wire type for skipVarintField'),
      this.skipField())
    : this.decoder_.skipVarint();
};
jspb.BinaryReader.prototype.skipDelimitedField = function () {
  if (this.nextWireType_ != jspb.BinaryConstants.WireType.DELIMITED)
    goog.asserts.fail('Invalid wire type for skipDelimitedField'),
      this.skipField();
  else {
    var a = this.decoder_.readUnsignedVarint32();
    this.decoder_.advance(a);
  }
};
jspb.BinaryReader.prototype.skipFixed32Field = function () {
  this.nextWireType_ != jspb.BinaryConstants.WireType.FIXED32
    ? (goog.asserts.fail('Invalid wire type for skipFixed32Field'),
      this.skipField())
    : this.decoder_.advance(4);
};
jspb.BinaryReader.prototype.skipFixed64Field = function () {
  this.nextWireType_ != jspb.BinaryConstants.WireType.FIXED64
    ? (goog.asserts.fail('Invalid wire type for skipFixed64Field'),
      this.skipField())
    : this.decoder_.advance(8);
};
jspb.BinaryReader.prototype.skipGroup = function () {
  var a = this.nextField_;
  do {
    if (!this.nextField()) {
      goog.asserts.fail('Unmatched start-group tag: stream EOF');
      this.error_ = !0;
      break;
    }
    if (this.nextWireType_ == jspb.BinaryConstants.WireType.END_GROUP) {
      this.nextField_ != a &&
        (goog.asserts.fail('Unmatched end-group tag'), (this.error_ = !0));
      break;
    }
    this.skipField();
  } while (1);
};
jspb.BinaryReader.prototype.skipField = function () {
  switch (this.nextWireType_) {
    case jspb.BinaryConstants.WireType.VARINT:
      this.skipVarintField();
      break;
    case jspb.BinaryConstants.WireType.FIXED64:
      this.skipFixed64Field();
      break;
    case jspb.BinaryConstants.WireType.DELIMITED:
      this.skipDelimitedField();
      break;
    case jspb.BinaryConstants.WireType.FIXED32:
      this.skipFixed32Field();
      break;
    case jspb.BinaryConstants.WireType.START_GROUP:
      this.skipGroup();
      break;
    default:
      goog.asserts.fail('Invalid wire encoding for field.');
  }
};
jspb.BinaryReader.prototype.registerReadCallback = function (a, b) {
  null === this.readCallbacks_ && (this.readCallbacks_ = {});
  goog.asserts.assert(!this.readCallbacks_[a]);
  this.readCallbacks_[a] = b;
};
jspb.BinaryReader.prototype.runReadCallback = function (a) {
  goog.asserts.assert(null !== this.readCallbacks_);
  a = this.readCallbacks_[a];
  goog.asserts.assert(a);
  return a(this);
};
jspb.BinaryReader.prototype.readAny = function (a) {
  this.nextWireType_ = jspb.BinaryConstants.FieldTypeToWireType(a);
  var b = jspb.BinaryConstants.FieldType;
  switch (a) {
    case b.DOUBLE:
      return this.readDouble();
    case b.FLOAT:
      return this.readFloat();
    case b.INT64:
      return this.readInt64();
    case b.UINT64:
      return this.readUint64();
    case b.INT32:
      return this.readInt32();
    case b.FIXED64:
      return this.readFixed64();
    case b.FIXED32:
      return this.readFixed32();
    case b.BOOL:
      return this.readBool();
    case b.STRING:
      return this.readString();
    case b.GROUP:
      goog.asserts.fail('Group field type not supported in readAny()');
    case b.MESSAGE:
      goog.asserts.fail('Message field type not supported in readAny()');
    case b.BYTES:
      return this.readBytes();
    case b.UINT32:
      return this.readUint32();
    case b.ENUM:
      return this.readEnum();
    case b.SFIXED32:
      return this.readSfixed32();
    case b.SFIXED64:
      return this.readSfixed64();
    case b.SINT32:
      return this.readSint32();
    case b.SINT64:
      return this.readSint64();
    case b.FHASH64:
      return this.readFixedHash64();
    case b.VHASH64:
      return this.readVarintHash64();
    default:
      goog.asserts.fail('Invalid field type in readAny()');
  }
  return 0;
};
jspb.BinaryReader.prototype.readMessage = function (a, b) {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.DELIMITED
  );
  var c = this.decoder_.getEnd(),
    d = this.decoder_.readUnsignedVarint32();
  d = this.decoder_.getCursor() + d;
  this.decoder_.setEnd(d);
  b(a, this);
  this.decoder_.setCursor(d);
  this.decoder_.setEnd(c);
};
jspb.BinaryReader.prototype.readGroup = function (a, b, c) {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.START_GROUP
  );
  goog.asserts.assert(this.nextField_ == a);
  c(b, this);
  this.error_ ||
    this.nextWireType_ == jspb.BinaryConstants.WireType.END_GROUP ||
    (goog.asserts.fail('Group submessage did not end with an END_GROUP tag'),
    (this.error_ = !0));
};
jspb.BinaryReader.prototype.getFieldDecoder = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.DELIMITED
  );
  var a = this.decoder_.readUnsignedVarint32(),
    b = this.decoder_.getCursor(),
    c = b + a;
  a = jspb.BinaryDecoder.alloc(this.decoder_.getBuffer(), b, a);
  this.decoder_.setCursor(c);
  return a;
};
jspb.BinaryReader.prototype.readInt32 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readSignedVarint32();
};
jspb.BinaryReader.prototype.readInt32String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readSignedVarint32String();
};
jspb.BinaryReader.prototype.readInt64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readSignedVarint64();
};
jspb.BinaryReader.prototype.readInt64String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readSignedVarint64String();
};
jspb.BinaryReader.prototype.readUint32 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readUnsignedVarint32();
};
jspb.BinaryReader.prototype.readUint32String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readUnsignedVarint32String();
};
jspb.BinaryReader.prototype.readUint64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readUnsignedVarint64();
};
jspb.BinaryReader.prototype.readUint64String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readUnsignedVarint64String();
};
jspb.BinaryReader.prototype.readSint32 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readZigzagVarint32();
};
jspb.BinaryReader.prototype.readSint64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readZigzagVarint64();
};
jspb.BinaryReader.prototype.readSint64String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readZigzagVarint64String();
};
jspb.BinaryReader.prototype.readFixed32 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED32
  );
  return this.decoder_.readUint32();
};
jspb.BinaryReader.prototype.readFixed64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED64
  );
  return this.decoder_.readUint64();
};
jspb.BinaryReader.prototype.readFixed64String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED64
  );
  return this.decoder_.readUint64String();
};
jspb.BinaryReader.prototype.readSfixed32 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED32
  );
  return this.decoder_.readInt32();
};
jspb.BinaryReader.prototype.readSfixed32String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED32
  );
  return this.decoder_.readInt32().toString();
};
jspb.BinaryReader.prototype.readSfixed64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED64
  );
  return this.decoder_.readInt64();
};
jspb.BinaryReader.prototype.readSfixed64String = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED64
  );
  return this.decoder_.readInt64String();
};
jspb.BinaryReader.prototype.readFloat = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED32
  );
  return this.decoder_.readFloat();
};
jspb.BinaryReader.prototype.readDouble = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED64
  );
  return this.decoder_.readDouble();
};
jspb.BinaryReader.prototype.readBool = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return !!this.decoder_.readUnsignedVarint32();
};
jspb.BinaryReader.prototype.readEnum = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readSignedVarint64();
};
jspb.BinaryReader.prototype.readString = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.DELIMITED
  );
  var a = this.decoder_.readUnsignedVarint32();
  return this.decoder_.readString(a);
};
jspb.BinaryReader.prototype.readBytes = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.DELIMITED
  );
  var a = this.decoder_.readUnsignedVarint32();
  return this.decoder_.readBytes(a);
};
jspb.BinaryReader.prototype.readVarintHash64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readVarintHash64();
};
jspb.BinaryReader.prototype.readSintHash64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readZigzagVarintHash64();
};
jspb.BinaryReader.prototype.readSplitVarint64 = function (a) {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readSplitVarint64(a);
};
jspb.BinaryReader.prototype.readSplitZigzagVarint64 = function (a) {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.VARINT
  );
  return this.decoder_.readSplitVarint64(function (b, c) {
    return jspb.utils.fromZigzag64(b, c, a);
  });
};
jspb.BinaryReader.prototype.readFixedHash64 = function () {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED64
  );
  return this.decoder_.readFixedHash64();
};
jspb.BinaryReader.prototype.readSplitFixed64 = function (a) {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.FIXED64
  );
  return this.decoder_.readSplitFixed64(a);
};
jspb.BinaryReader.prototype.readPackedField_ = function (a) {
  goog.asserts.assert(
    this.nextWireType_ == jspb.BinaryConstants.WireType.DELIMITED
  );
  var b = this.decoder_.readUnsignedVarint32();
  b = this.decoder_.getCursor() + b;
  for (var c = []; this.decoder_.getCursor() < b; )
    c.push(a.call(this.decoder_));
  return c;
};
jspb.BinaryReader.prototype.readPackedInt32 = function () {
  return this.readPackedField_(this.decoder_.readSignedVarint32);
};
jspb.BinaryReader.prototype.readPackedInt32String = function () {
  return this.readPackedField_(this.decoder_.readSignedVarint32String);
};
jspb.BinaryReader.prototype.readPackedInt64 = function () {
  return this.readPackedField_(this.decoder_.readSignedVarint64);
};
jspb.BinaryReader.prototype.readPackedInt64String = function () {
  return this.readPackedField_(this.decoder_.readSignedVarint64String);
};
jspb.BinaryReader.prototype.readPackedUint32 = function () {
  return this.readPackedField_(this.decoder_.readUnsignedVarint32);
};
jspb.BinaryReader.prototype.readPackedUint32String = function () {
  return this.readPackedField_(this.decoder_.readUnsignedVarint32String);
};
jspb.BinaryReader.prototype.readPackedUint64 = function () {
  return this.readPackedField_(this.decoder_.readUnsignedVarint64);
};
jspb.BinaryReader.prototype.readPackedUint64String = function () {
  return this.readPackedField_(this.decoder_.readUnsignedVarint64String);
};
jspb.BinaryReader.prototype.readPackedSint32 = function () {
  return this.readPackedField_(this.decoder_.readZigzagVarint32);
};
jspb.BinaryReader.prototype.readPackedSint64 = function () {
  return this.readPackedField_(this.decoder_.readZigzagVarint64);
};
jspb.BinaryReader.prototype.readPackedSint64String = function () {
  return this.readPackedField_(this.decoder_.readZigzagVarint64String);
};
jspb.BinaryReader.prototype.readPackedFixed32 = function () {
  return this.readPackedField_(this.decoder_.readUint32);
};
jspb.BinaryReader.prototype.readPackedFixed64 = function () {
  return this.readPackedField_(this.decoder_.readUint64);
};
jspb.BinaryReader.prototype.readPackedFixed64String = function () {
  return this.readPackedField_(this.decoder_.readUint64String);
};
jspb.BinaryReader.prototype.readPackedSfixed32 = function () {
  return this.readPackedField_(this.decoder_.readInt32);
};
jspb.BinaryReader.prototype.readPackedSfixed64 = function () {
  return this.readPackedField_(this.decoder_.readInt64);
};
jspb.BinaryReader.prototype.readPackedSfixed64String = function () {
  return this.readPackedField_(this.decoder_.readInt64String);
};
jspb.BinaryReader.prototype.readPackedFloat = function () {
  return this.readPackedField_(this.decoder_.readFloat);
};
jspb.BinaryReader.prototype.readPackedDouble = function () {
  return this.readPackedField_(this.decoder_.readDouble);
};
jspb.BinaryReader.prototype.readPackedBool = function () {
  return this.readPackedField_(this.decoder_.readBool);
};
jspb.BinaryReader.prototype.readPackedEnum = function () {
  return this.readPackedField_(this.decoder_.readEnum);
};
jspb.BinaryReader.prototype.readPackedVarintHash64 = function () {
  return this.readPackedField_(this.decoder_.readVarintHash64);
};
jspb.BinaryReader.prototype.readPackedFixedHash64 = function () {
  return this.readPackedField_(this.decoder_.readFixedHash64);
};
jspb.Map = function (a, b) {
  this.arr_ = a;
  this.valueCtor_ = b;
  this.map_ = {};
  this.arrClean = !0;
  0 < this.arr_.length && this.loadFromArray_();
};
jspb.Map.prototype.loadFromArray_ = function () {
  for (var a = 0; a < this.arr_.length; a++) {
    var b = this.arr_[a],
      c = b[0];
    this.map_[c.toString()] = new jspb.Map.Entry_(c, b[1]);
  }
  this.arrClean = !0;
};
jspb.Map.prototype.toArray = function () {
  if (this.arrClean) {
    if (this.valueCtor_) {
      var a = this.map_,
        b;
      for (b in a)
        if (Object.prototype.hasOwnProperty.call(a, b)) {
          var c = a[b].valueWrapper;
          c && c.toArray();
        }
    }
  } else {
    this.arr_.length = 0;
    a = this.stringKeys_();
    a.sort();
    for (b = 0; b < a.length; b++) {
      var d = this.map_[a[b]];
      (c = d.valueWrapper) && c.toArray();
      this.arr_.push([d.key, d.value]);
    }
    this.arrClean = !0;
  }
  return this.arr_;
};
jspb.Map.prototype.toObject = function (a, b) {
  for (var c = this.toArray(), d = [], e = 0; e < c.length; e++) {
    var f = this.map_[c[e][0].toString()];
    this.wrapEntry_(f);
    var g = f.valueWrapper;
    g
      ? (goog.asserts.assert(b), d.push([f.key, b(a, g)]))
      : d.push([f.key, f.value]);
  }
  return d;
};
jspb.Map.fromObject = function (a, b, c) {
  b = new jspb.Map([], b);
  for (var d = 0; d < a.length; d++) {
    var e = a[d][0],
      f = c(a[d][1]);
    b.set(e, f);
  }
  return b;
};
jspb.Map.ArrayIteratorIterable_ = function (a) {
  this.idx_ = 0;
  this.arr_ = a;
};
jspb.Map.ArrayIteratorIterable_.prototype.next = function () {
  return this.idx_ < this.arr_.length
    ? {
        done: !1,
        value: this.arr_[this.idx_++],
      }
    : {
        done: !0,
        value: void 0,
      };
};
'undefined' != typeof Symbol &&
  (jspb.Map.ArrayIteratorIterable_.prototype[Symbol.iterator] = function () {
    return this;
  });
jspb.Map.prototype.getLength = function () {
  return this.stringKeys_().length;
};
jspb.Map.prototype.clear = function () {
  this.map_ = {};
  this.arrClean = !1;
};
jspb.Map.prototype.del = function (a) {
  a = a.toString();
  var b = this.map_.hasOwnProperty(a);
  delete this.map_[a];
  this.arrClean = !1;
  return b;
};
jspb.Map.prototype.getEntryList = function () {
  var a = [],
    b = this.stringKeys_();
  b.sort();
  for (var c = 0; c < b.length; c++) {
    var d = this.map_[b[c]];
    a.push([d.key, d.value]);
  }
  return a;
};
jspb.Map.prototype.entries = function () {
  var a = [],
    b = this.stringKeys_();
  b.sort();
  for (var c = 0; c < b.length; c++) {
    var d = this.map_[b[c]];
    a.push([d.key, this.wrapEntry_(d)]);
  }
  return new jspb.Map.ArrayIteratorIterable_(a);
};
jspb.Map.prototype.keys = function () {
  var a = [],
    b = this.stringKeys_();
  b.sort();
  for (var c = 0; c < b.length; c++) a.push(this.map_[b[c]].key);
  return new jspb.Map.ArrayIteratorIterable_(a);
};
jspb.Map.prototype.values = function () {
  var a = [],
    b = this.stringKeys_();
  b.sort();
  for (var c = 0; c < b.length; c++) a.push(this.wrapEntry_(this.map_[b[c]]));
  return new jspb.Map.ArrayIteratorIterable_(a);
};
jspb.Map.prototype.forEach = function (a, b) {
  var c = this.stringKeys_();
  c.sort();
  for (var d = 0; d < c.length; d++) {
    var e = this.map_[c[d]];
    a.call(b, this.wrapEntry_(e), e.key, this);
  }
};
jspb.Map.prototype.set = function (a, b) {
  var c = new jspb.Map.Entry_(a);
  this.valueCtor_
    ? ((c.valueWrapper = b), (c.value = b.toArray()))
    : (c.value = b);
  this.map_[a.toString()] = c;
  this.arrClean = !1;
  return this;
};
jspb.Map.prototype.wrapEntry_ = function (a) {
  return this.valueCtor_
    ? (a.valueWrapper || (a.valueWrapper = new this.valueCtor_(a.value)),
      a.valueWrapper)
    : a.value;
};
jspb.Map.prototype.get = function (a) {
  if ((a = this.map_[a.toString()])) return this.wrapEntry_(a);
};
jspb.Map.prototype.has = function (a) {
  return a.toString() in this.map_;
};
jspb.Map.prototype.serializeBinary = function (a, b, c, d, e) {
  var f = this.stringKeys_();
  f.sort();
  for (var g = 0; g < f.length; g++) {
    var h = this.map_[f[g]];
    b.beginSubMessage(a);
    c.call(b, 1, h.key);
    this.valueCtor_
      ? d.call(b, 2, this.wrapEntry_(h), e)
      : d.call(b, 2, h.value);
    b.endSubMessage();
  }
};
jspb.Map.deserializeBinary = function (a, b, c, d, e, f, g) {
  for (; b.nextField() && !b.isEndGroup(); ) {
    var h = b.getFieldNumber();
    1 == h
      ? (f = c.call(b))
      : 2 == h &&
        (a.valueCtor_
          ? (goog.asserts.assert(e),
            g || (g = new a.valueCtor_()),
            d.call(b, g, e))
          : (g = d.call(b)));
  }
  goog.asserts.assert(void 0 != f);
  goog.asserts.assert(void 0 != g);
  a.set(f, g);
};
jspb.Map.prototype.stringKeys_ = function () {
  var a = this.map_,
    b = [],
    c;
  for (c in a) Object.prototype.hasOwnProperty.call(a, c) && b.push(c);
  return b;
};
jspb.Map.Entry_ = function (a, b) {
  this.key = a;
  this.value = b;
  this.valueWrapper = void 0;
};
jspb.ExtensionFieldInfo = function (a, b, c, d, e) {
  this.fieldIndex = a;
  this.fieldName = b;
  this.ctor = c;
  this.toObjectFn = d;
  this.isRepeated = e;
};
jspb.ExtensionFieldBinaryInfo = function (a, b, c, d, e, f) {
  this.fieldInfo = a;
  this.binaryReaderFn = b;
  this.binaryWriterFn = c;
  this.binaryMessageSerializeFn = d;
  this.binaryMessageDeserializeFn = e;
  this.isPacked = f;
};
jspb.ExtensionFieldInfo.prototype.isMessageType = function () {
  return !!this.ctor;
};
jspb.Message = function () {};
jspb.Message.GENERATE_TO_OBJECT = !0;
jspb.Message.GENERATE_FROM_OBJECT = !goog.DISALLOW_TEST_ONLY_CODE;
jspb.Message.GENERATE_TO_STRING = !0;
jspb.Message.ASSUME_LOCAL_ARRAYS = !1;
jspb.Message.SERIALIZE_EMPTY_TRAILING_FIELDS = !0;
jspb.Message.SUPPORTS_UINT8ARRAY_ = 'function' == typeof Uint8Array;
jspb.Message.prototype.getJsPbMessageId = function () {
  return this.messageId_;
};
jspb.Message.getIndex_ = function (a, b) {
  return b + a.arrayIndexOffset_;
};
jspb.Message.hiddenES6Property_ = function () {};
jspb.Message.getFieldNumber_ = function (a, b) {
  return b - a.arrayIndexOffset_;
};
jspb.Message.initialize = function (a, b, c, d, e, f) {
  a.wrappers_ = null;
  b || (b = c ? [c] : []);
  a.messageId_ = c ? String(c) : void 0;
  a.arrayIndexOffset_ = 0 === c ? -1 : 0;
  a.array = b;
  jspb.Message.initPivotAndExtensionObject_(a, d);
  a.convertedPrimitiveFields_ = {};
  jspb.Message.SERIALIZE_EMPTY_TRAILING_FIELDS || (a.repeatedFields = e);
  if (e)
    for (b = 0; b < e.length; b++)
      (c = e[b]),
        c < a.pivot_
          ? ((c = jspb.Message.getIndex_(a, c)),
            (a.array[c] = a.array[c] || jspb.Message.EMPTY_LIST_SENTINEL_))
          : (jspb.Message.maybeInitEmptyExtensionObject_(a),
            (a.extensionObject_[c] =
              a.extensionObject_[c] || jspb.Message.EMPTY_LIST_SENTINEL_));
  if (f && f.length)
    for (b = 0; b < f.length; b++) jspb.Message.computeOneofCase(a, f[b]);
};
jspb.Message.EMPTY_LIST_SENTINEL_ =
  goog.DEBUG && Object.freeze ? Object.freeze([]) : [];
jspb.Message.isArray_ = function (a) {
  return jspb.Message.ASSUME_LOCAL_ARRAYS
    ? a instanceof Array
    : goog.isArray(a);
};
jspb.Message.isExtensionObject_ = function (a) {
  return (
    null !== a &&
    'object' == typeof a &&
    !jspb.Message.isArray_(a) &&
    !(jspb.Message.SUPPORTS_UINT8ARRAY_ && a instanceof Uint8Array)
  );
};
jspb.Message.initPivotAndExtensionObject_ = function (a, b) {
  var c = a.array.length,
    d = -1;
  if (
    c &&
    ((d = c - 1), (c = a.array[d]), jspb.Message.isExtensionObject_(c))
  ) {
    a.pivot_ = jspb.Message.getFieldNumber_(a, d);
    a.extensionObject_ = c;
    return;
  }
  -1 < b
    ? ((a.pivot_ = Math.max(b, jspb.Message.getFieldNumber_(a, d + 1))),
      (a.extensionObject_ = null))
    : (a.pivot_ = Number.MAX_VALUE);
};
jspb.Message.maybeInitEmptyExtensionObject_ = function (a) {
  var b = jspb.Message.getIndex_(a, a.pivot_);
  a.array[b] || (a.extensionObject_ = a.array[b] = {});
};
jspb.Message.toObjectList = function (a, b, c) {
  for (var d = [], e = 0; e < a.length; e++) d[e] = b.call(a[e], c, a[e]);
  return d;
};
jspb.Message.toObjectExtension = function (a, b, c, d, e) {
  for (var f in c) {
    var g = c[f],
      h = d.call(a, g);
    if (null != h) {
      for (var k in g.fieldName) if (g.fieldName.hasOwnProperty(k)) break;
      b[k] = g.toObjectFn
        ? g.isRepeated
          ? jspb.Message.toObjectList(h, g.toObjectFn, e)
          : g.toObjectFn(e, h)
        : h;
    }
  }
};
jspb.Message.serializeBinaryExtensions = function (a, b, c, d) {
  for (var e in c) {
    var f = c[e],
      g = f.fieldInfo;
    if (!f.binaryWriterFn)
      throw Error(
        'Message extension present that was generated without binary serialization support'
      );
    var h = d.call(a, g);
    if (null != h)
      if (g.isMessageType())
        if (f.binaryMessageSerializeFn)
          f.binaryWriterFn.call(b, g.fieldIndex, h, f.binaryMessageSerializeFn);
        else
          throw Error(
            'Message extension present holding submessage without binary support enabled, and message is being serialized to binary format'
          );
      else f.binaryWriterFn.call(b, g.fieldIndex, h);
  }
};
jspb.Message.readBinaryExtension = function (a, b, c, d, e) {
  var f = c[b.getFieldNumber()];
  if (f) {
    c = f.fieldInfo;
    if (!f.binaryReaderFn)
      throw Error(
        'Deserializing extension whose generated code does not support binary format'
      );
    if (c.isMessageType()) {
      var g = new c.ctor();
      f.binaryReaderFn.call(b, g, f.binaryMessageDeserializeFn);
    } else g = f.binaryReaderFn.call(b);
    c.isRepeated && !f.isPacked
      ? (b = d.call(a, c))
        ? b.push(g)
        : e.call(a, c, [g])
      : e.call(a, c, g);
  } else b.skipField();
};
jspb.Message.getField = function (a, b) {
  if (b < a.pivot_) {
    b = jspb.Message.getIndex_(a, b);
    var c = a.array[b];
    return c === jspb.Message.EMPTY_LIST_SENTINEL_ ? (a.array[b] = []) : c;
  }
  if (a.extensionObject_)
    return (
      (c = a.extensionObject_[b]),
      c === jspb.Message.EMPTY_LIST_SENTINEL_ ? (a.extensionObject_[b] = []) : c
    );
};
jspb.Message.getRepeatedField = function (a, b) {
  return jspb.Message.getField(a, b);
};
jspb.Message.getOptionalFloatingPointField = function (a, b) {
  a = jspb.Message.getField(a, b);
  return null == a ? a : +a;
};
jspb.Message.getBooleanField = function (a, b) {
  a = jspb.Message.getField(a, b);
  return null == a ? a : !!a;
};
jspb.Message.getRepeatedFloatingPointField = function (a, b) {
  var c = jspb.Message.getRepeatedField(a, b);
  a.convertedPrimitiveFields_ || (a.convertedPrimitiveFields_ = {});
  if (!a.convertedPrimitiveFields_[b]) {
    for (var d = 0; d < c.length; d++) c[d] = +c[d];
    a.convertedPrimitiveFields_[b] = !0;
  }
  return c;
};
jspb.Message.getRepeatedBooleanField = function (a, b) {
  var c = jspb.Message.getRepeatedField(a, b);
  a.convertedPrimitiveFields_ || (a.convertedPrimitiveFields_ = {});
  if (!a.convertedPrimitiveFields_[b]) {
    for (var d = 0; d < c.length; d++) c[d] = !!c[d];
    a.convertedPrimitiveFields_[b] = !0;
  }
  return c;
};
jspb.Message.bytesAsB64 = function (a) {
  if (null == a || 'string' === typeof a) return a;
  if (jspb.Message.SUPPORTS_UINT8ARRAY_ && a instanceof Uint8Array)
    return goog.crypt.base64.encodeByteArray(a);
  goog.asserts.fail('Cannot coerce to b64 string: ' + goog.typeOf(a));
  return null;
};
jspb.Message.bytesAsU8 = function (a) {
  if (null == a || a instanceof Uint8Array) return a;
  if ('string' === typeof a)
    return goog.crypt.base64.decodeStringToUint8Array(a);
  goog.asserts.fail('Cannot coerce to Uint8Array: ' + goog.typeOf(a));
  return null;
};
jspb.Message.bytesListAsB64 = function (a) {
  jspb.Message.assertConsistentTypes_(a);
  return a.length && 'string' !== typeof a[0]
    ? goog.array.map(a, jspb.Message.bytesAsB64)
    : a;
};
jspb.Message.bytesListAsU8 = function (a) {
  jspb.Message.assertConsistentTypes_(a);
  return !a.length || a[0] instanceof Uint8Array
    ? a
    : goog.array.map(a, jspb.Message.bytesAsU8);
};
jspb.Message.assertConsistentTypes_ = function (a) {
  if (goog.DEBUG && a && 1 < a.length) {
    var b = goog.typeOf(a[0]);
    goog.array.forEach(a, function (a) {
      goog.typeOf(a) != b &&
        goog.asserts.fail(
          'Inconsistent type in JSPB repeated field array. Got ' +
            goog.typeOf(a) +
            ' expected ' +
            b
        );
    });
  }
};
jspb.Message.getFieldWithDefault = function (a, b, c) {
  a = jspb.Message.getField(a, b);
  return null == a ? c : a;
};
jspb.Message.getBooleanFieldWithDefault = function (a, b, c) {
  a = jspb.Message.getBooleanField(a, b);
  return null == a ? c : a;
};
jspb.Message.getFloatingPointFieldWithDefault = function (a, b, c) {
  a = jspb.Message.getOptionalFloatingPointField(a, b);
  return null == a ? c : a;
};
jspb.Message.getFieldProto3 = jspb.Message.getFieldWithDefault;
jspb.Message.getMapField = function (a, b, c, d) {
  a.wrappers_ || (a.wrappers_ = {});
  if (b in a.wrappers_) return a.wrappers_[b];
  var e = jspb.Message.getField(a, b);
  if (!e) {
    if (c) return;
    e = [];
    jspb.Message.setField(a, b, e);
  }
  return (a.wrappers_[b] = new jspb.Map(e, d));
};
jspb.Message.setField = function (a, b, c) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  b < a.pivot_
    ? (a.array[jspb.Message.getIndex_(a, b)] = c)
    : (jspb.Message.maybeInitEmptyExtensionObject_(a),
      (a.extensionObject_[b] = c));
  return a;
};
jspb.Message.setProto3IntField = function (a, b, c) {
  return jspb.Message.setFieldIgnoringDefault_(a, b, c, 0);
};
jspb.Message.setProto3FloatField = function (a, b, c) {
  return jspb.Message.setFieldIgnoringDefault_(a, b, c, 0);
};
jspb.Message.setProto3BooleanField = function (a, b, c) {
  return jspb.Message.setFieldIgnoringDefault_(a, b, c, !1);
};
jspb.Message.setProto3StringField = function (a, b, c) {
  return jspb.Message.setFieldIgnoringDefault_(a, b, c, '');
};
jspb.Message.setProto3BytesField = function (a, b, c) {
  return jspb.Message.setFieldIgnoringDefault_(a, b, c, '');
};
jspb.Message.setProto3EnumField = function (a, b, c) {
  return jspb.Message.setFieldIgnoringDefault_(a, b, c, 0);
};
jspb.Message.setProto3StringIntField = function (a, b, c) {
  return jspb.Message.setFieldIgnoringDefault_(a, b, c, '0');
};
jspb.Message.setFieldIgnoringDefault_ = function (a, b, c, d) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  c !== d
    ? jspb.Message.setField(a, b, c)
    : b < a.pivot_
    ? (a.array[jspb.Message.getIndex_(a, b)] = null)
    : (jspb.Message.maybeInitEmptyExtensionObject_(a),
      delete a.extensionObject_[b]);
  return a;
};
jspb.Message.addToRepeatedField = function (a, b, c, d) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  b = jspb.Message.getRepeatedField(a, b);
  void 0 != d ? b.splice(d, 0, c) : b.push(c);
  return a;
};
jspb.Message.setOneofField = function (a, b, c, d) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  (c = jspb.Message.computeOneofCase(a, c)) &&
    c !== b &&
    void 0 !== d &&
    (a.wrappers_ && c in a.wrappers_ && (a.wrappers_[c] = void 0),
    jspb.Message.setField(a, c, void 0));
  return jspb.Message.setField(a, b, d);
};
jspb.Message.computeOneofCase = function (a, b) {
  for (var c, d, e = 0; e < b.length; e++) {
    var f = b[e],
      g = jspb.Message.getField(a, f);
    null != g && ((c = f), (d = g), jspb.Message.setField(a, f, void 0));
  }
  return c ? (jspb.Message.setField(a, c, d), c) : 0;
};
jspb.Message.getWrapperField = function (a, b, c, d) {
  a.wrappers_ || (a.wrappers_ = {});
  if (!a.wrappers_[c]) {
    var e = jspb.Message.getField(a, c);
    if (d || e) a.wrappers_[c] = new b(e);
  }
  return a.wrappers_[c];
};
jspb.Message.getRepeatedWrapperField = function (a, b, c) {
  jspb.Message.wrapRepeatedField_(a, b, c);
  b = a.wrappers_[c];
  b == jspb.Message.EMPTY_LIST_SENTINEL_ && (b = a.wrappers_[c] = []);
  return b;
};
jspb.Message.wrapRepeatedField_ = function (a, b, c) {
  a.wrappers_ || (a.wrappers_ = {});
  if (!a.wrappers_[c]) {
    for (
      var d = jspb.Message.getRepeatedField(a, c), e = [], f = 0;
      f < d.length;
      f++
    )
      e[f] = new b(d[f]);
    a.wrappers_[c] = e;
  }
};
jspb.Message.setWrapperField = function (a, b, c) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  a.wrappers_ || (a.wrappers_ = {});
  var d = c ? c.toArray() : c;
  a.wrappers_[b] = c;
  return jspb.Message.setField(a, b, d);
};
jspb.Message.setOneofWrapperField = function (a, b, c, d) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  a.wrappers_ || (a.wrappers_ = {});
  var e = d ? d.toArray() : d;
  a.wrappers_[b] = d;
  return jspb.Message.setOneofField(a, b, c, e);
};
jspb.Message.setRepeatedWrapperField = function (a, b, c) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  a.wrappers_ || (a.wrappers_ = {});
  c = c || [];
  for (var d = [], e = 0; e < c.length; e++) d[e] = c[e].toArray();
  a.wrappers_[b] = c;
  return jspb.Message.setField(a, b, d);
};
jspb.Message.addToRepeatedWrapperField = function (a, b, c, d, e) {
  jspb.Message.wrapRepeatedField_(a, d, b);
  var f = a.wrappers_[b];
  f || (f = a.wrappers_[b] = []);
  c = c ? c : new d();
  a = jspb.Message.getRepeatedField(a, b);
  void 0 != e
    ? (f.splice(e, 0, c), a.splice(e, 0, c.toArray()))
    : (f.push(c), a.push(c.toArray()));
  return c;
};
jspb.Message.toMap = function (a, b, c, d) {
  for (var e = {}, f = 0; f < a.length; f++)
    e[b.call(a[f])] = c ? c.call(a[f], d, a[f]) : a[f];
  return e;
};
jspb.Message.prototype.syncMapFields_ = function () {
  if (this.wrappers_)
    for (var a in this.wrappers_) {
      var b = this.wrappers_[a];
      if (goog.isArray(b))
        for (var c = 0; c < b.length; c++) b[c] && b[c].toArray();
      else b && b.toArray();
    }
};
jspb.Message.prototype.toArray = function () {
  this.syncMapFields_();
  return this.array;
};
jspb.Message.GENERATE_TO_STRING &&
  (jspb.Message.prototype.toString = function () {
    this.syncMapFields_();
    return this.array.toString();
  });
jspb.Message.prototype.getExtension = function (a) {
  if (this.extensionObject_) {
    this.wrappers_ || (this.wrappers_ = {});
    var b = a.fieldIndex;
    if (a.isRepeated) {
      if (a.isMessageType())
        return (
          this.wrappers_[b] ||
            (this.wrappers_[b] = goog.array.map(
              this.extensionObject_[b] || [],
              function (b) {
                return new a.ctor(b);
              }
            )),
          this.wrappers_[b]
        );
    } else if (a.isMessageType())
      return (
        !this.wrappers_[b] &&
          this.extensionObject_[b] &&
          (this.wrappers_[b] = new a.ctor(this.extensionObject_[b])),
        this.wrappers_[b]
      );
    return this.extensionObject_[b];
  }
};
jspb.Message.prototype.setExtension = function (a, b) {
  this.wrappers_ || (this.wrappers_ = {});
  jspb.Message.maybeInitEmptyExtensionObject_(this);
  var c = a.fieldIndex;
  a.isRepeated
    ? ((b = b || []),
      a.isMessageType()
        ? ((this.wrappers_[c] = b),
          (this.extensionObject_[c] = goog.array.map(b, function (a) {
            return a.toArray();
          })))
        : (this.extensionObject_[c] = b))
    : a.isMessageType()
    ? ((this.wrappers_[c] = b),
      (this.extensionObject_[c] = b ? b.toArray() : b))
    : (this.extensionObject_[c] = b);
  return this;
};
jspb.Message.difference = function (a, b) {
  if (!(a instanceof b.constructor))
    throw Error('Messages have different types.');
  var c = a.toArray();
  b = b.toArray();
  var d = [],
    e = 0,
    f = c.length > b.length ? c.length : b.length;
  a.getJsPbMessageId() && ((d[0] = a.getJsPbMessageId()), (e = 1));
  for (; e < f; e++) jspb.Message.compareFields(c[e], b[e]) || (d[e] = b[e]);
  return new a.constructor(d);
};
jspb.Message.equals = function (a, b) {
  return (
    a == b ||
    (!(!a || !b) &&
      a instanceof b.constructor &&
      jspb.Message.compareFields(a.toArray(), b.toArray()))
  );
};
jspb.Message.compareExtensions = function (a, b) {
  a = a || {};
  b = b || {};
  var c = {},
    d;
  for (d in a) c[d] = 0;
  for (d in b) c[d] = 0;
  for (d in c) if (!jspb.Message.compareFields(a[d], b[d])) return !1;
  return !0;
};
jspb.Message.compareFields = function (a, b) {
  if (a == b) return !0;
  if (!goog.isObject(a) || !goog.isObject(b))
    return ('number' === typeof a && isNaN(a)) ||
      ('number' === typeof b && isNaN(b))
      ? String(a) == String(b)
      : !1;
  if (a.constructor != b.constructor) return !1;
  if (jspb.Message.SUPPORTS_UINT8ARRAY_ && a.constructor === Uint8Array) {
    if (a.length != b.length) return !1;
    for (var c = 0; c < a.length; c++) if (a[c] != b[c]) return !1;
    return !0;
  }
  if (a.constructor === Array) {
    var d = void 0,
      e = void 0,
      f = Math.max(a.length, b.length);
    for (c = 0; c < f; c++) {
      var g = a[c],
        h = b[c];
      g &&
        g.constructor == Object &&
        (goog.asserts.assert(void 0 === d),
        goog.asserts.assert(c === a.length - 1),
        (d = g),
        (g = void 0));
      h &&
        h.constructor == Object &&
        (goog.asserts.assert(void 0 === e),
        goog.asserts.assert(c === b.length - 1),
        (e = h),
        (h = void 0));
      if (!jspb.Message.compareFields(g, h)) return !1;
    }
    return d || e
      ? ((d = d || {}), (e = e || {}), jspb.Message.compareExtensions(d, e))
      : !0;
  }
  if (a.constructor === Object) return jspb.Message.compareExtensions(a, b);
  throw Error('Invalid type in JSPB array');
};
jspb.Message.prototype.cloneMessage = function () {
  return jspb.Message.cloneMessage(this);
};
jspb.Message.prototype.clone = function () {
  return jspb.Message.cloneMessage(this);
};
jspb.Message.clone = function (a) {
  return jspb.Message.cloneMessage(a);
};
jspb.Message.cloneMessage = function (a) {
  return new a.constructor(jspb.Message.clone_(a.toArray()));
};
jspb.Message.copyInto = function (a, b) {
  goog.asserts.assertInstanceof(a, jspb.Message);
  goog.asserts.assertInstanceof(b, jspb.Message);
  goog.asserts.assert(
    a.constructor == b.constructor,
    'Copy source and target message should have the same type.'
  );
  a = jspb.Message.clone(a);
  for (
    var c = b.toArray(), d = a.toArray(), e = (c.length = 0);
    e < d.length;
    e++
  )
    c[e] = d[e];
  b.wrappers_ = a.wrappers_;
  b.extensionObject_ = a.extensionObject_;
};
jspb.Message.clone_ = function (a) {
  if (goog.isArray(a)) {
    for (var b = Array(a.length), c = 0; c < a.length; c++) {
      var d = a[c];
      null != d &&
        (b[c] =
          'object' == typeof d
            ? jspb.Message.clone_(goog.asserts.assert(d))
            : d);
    }
    return b;
  }
  if (jspb.Message.SUPPORTS_UINT8ARRAY_ && a instanceof Uint8Array)
    return new Uint8Array(a);
  b = {};
  for (c in a)
    (d = a[c]),
      null != d &&
        (b[c] =
          'object' == typeof d
            ? jspb.Message.clone_(goog.asserts.assert(d))
            : d);
  return b;
};
jspb.Message.registerMessageType = function (a, b) {
  b.messageId = a;
};
jspb.Message.messageSetExtensions = {};
jspb.Message.messageSetExtensionsBinary = {};
jspb.arith = {};
jspb.arith.UInt64 = function (a, b) {
  this.lo = a;
  this.hi = b;
};
jspb.arith.UInt64.prototype.cmp = function (a) {
  return this.hi < a.hi || (this.hi == a.hi && this.lo < a.lo)
    ? -1
    : this.hi == a.hi && this.lo == a.lo
    ? 0
    : 1;
};
jspb.arith.UInt64.prototype.rightShift = function () {
  return new jspb.arith.UInt64(
    ((this.lo >>> 1) | ((this.hi & 1) << 31)) >>> 0,
    (this.hi >>> 1) >>> 0
  );
};
jspb.arith.UInt64.prototype.leftShift = function () {
  return new jspb.arith.UInt64(
    (this.lo << 1) >>> 0,
    ((this.hi << 1) | (this.lo >>> 31)) >>> 0
  );
};
jspb.arith.UInt64.prototype.msb = function () {
  return !!(this.hi & 2147483648);
};
jspb.arith.UInt64.prototype.lsb = function () {
  return !!(this.lo & 1);
};
jspb.arith.UInt64.prototype.zero = function () {
  return 0 == this.lo && 0 == this.hi;
};
jspb.arith.UInt64.prototype.add = function (a) {
  return new jspb.arith.UInt64(
    (((this.lo + a.lo) & 4294967295) >>> 0) >>> 0,
    ((((this.hi + a.hi) & 4294967295) >>> 0) +
      (4294967296 <= this.lo + a.lo ? 1 : 0)) >>>
      0
  );
};
jspb.arith.UInt64.prototype.sub = function (a) {
  return new jspb.arith.UInt64(
    (((this.lo - a.lo) & 4294967295) >>> 0) >>> 0,
    ((((this.hi - a.hi) & 4294967295) >>> 0) - (0 > this.lo - a.lo ? 1 : 0)) >>>
      0
  );
};
jspb.arith.UInt64.mul32x32 = function (a, b) {
  var c = a & 65535;
  a >>>= 16;
  var d = b & 65535,
    e = b >>> 16;
  b = c * d + 65536 * ((c * e) & 65535) + 65536 * ((a * d) & 65535);
  for (c = a * e + ((c * e) >>> 16) + ((a * d) >>> 16); 4294967296 <= b; )
    (b -= 4294967296), (c += 1);
  return new jspb.arith.UInt64(b >>> 0, c >>> 0);
};
jspb.arith.UInt64.prototype.mul = function (a) {
  var b = jspb.arith.UInt64.mul32x32(this.lo, a);
  a = jspb.arith.UInt64.mul32x32(this.hi, a);
  a.hi = a.lo;
  a.lo = 0;
  return b.add(a);
};
jspb.arith.UInt64.prototype.div = function (a) {
  if (0 == a) return [];
  var b = new jspb.arith.UInt64(0, 0),
    c = new jspb.arith.UInt64(this.lo, this.hi);
  a = new jspb.arith.UInt64(a, 0);
  for (var d = new jspb.arith.UInt64(1, 0); !a.msb(); )
    (a = a.leftShift()), (d = d.leftShift());
  for (; !d.zero(); )
    0 >= a.cmp(c) && ((b = b.add(d)), (c = c.sub(a))),
      (a = a.rightShift()),
      (d = d.rightShift());
  return [b, c];
};
jspb.arith.UInt64.prototype.toString = function () {
  for (var a = '', b = this; !b.zero(); ) {
    b = b.div(10);
    var c = b[0];
    a = b[1].lo + a;
    b = c;
  }
  '' == a && (a = '0');
  return a;
};
jspb.arith.UInt64.fromString = function (a) {
  for (
    var b = new jspb.arith.UInt64(0, 0), c = new jspb.arith.UInt64(0, 0), d = 0;
    d < a.length;
    d++
  ) {
    if ('0' > a[d] || '9' < a[d]) return null;
    var e = parseInt(a[d], 10);
    c.lo = e;
    b = b.mul(10).add(c);
  }
  return b;
};
jspb.arith.UInt64.prototype.clone = function () {
  return new jspb.arith.UInt64(this.lo, this.hi);
};
jspb.arith.Int64 = function (a, b) {
  this.lo = a;
  this.hi = b;
};
jspb.arith.Int64.prototype.add = function (a) {
  return new jspb.arith.Int64(
    (((this.lo + a.lo) & 4294967295) >>> 0) >>> 0,
    ((((this.hi + a.hi) & 4294967295) >>> 0) +
      (4294967296 <= this.lo + a.lo ? 1 : 0)) >>>
      0
  );
};
jspb.arith.Int64.prototype.sub = function (a) {
  return new jspb.arith.Int64(
    (((this.lo - a.lo) & 4294967295) >>> 0) >>> 0,
    ((((this.hi - a.hi) & 4294967295) >>> 0) - (0 > this.lo - a.lo ? 1 : 0)) >>>
      0
  );
};
jspb.arith.Int64.prototype.clone = function () {
  return new jspb.arith.Int64(this.lo, this.hi);
};
jspb.arith.Int64.prototype.toString = function () {
  var a = 0 != (this.hi & 2147483648),
    b = new jspb.arith.UInt64(this.lo, this.hi);
  a && (b = new jspb.arith.UInt64(0, 0).sub(b));
  return (a ? '-' : '') + b.toString();
};
jspb.arith.Int64.fromString = function (a) {
  var b = 0 < a.length && '-' == a[0];
  b && (a = a.substring(1));
  a = jspb.arith.UInt64.fromString(a);
  if (null === a) return null;
  b && (a = new jspb.arith.UInt64(0, 0).sub(a));
  return new jspb.arith.Int64(a.lo, a.hi);
};
jspb.BinaryEncoder = function () {
  this.buffer_ = [];
};
jspb.BinaryEncoder.prototype.length = function () {
  return this.buffer_.length;
};
jspb.BinaryEncoder.prototype.end = function () {
  var a = this.buffer_;
  this.buffer_ = [];
  return a;
};
jspb.BinaryEncoder.prototype.writeSplitVarint64 = function (a, b) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(b == Math.floor(b));
  goog.asserts.assert(0 <= a && a < jspb.BinaryConstants.TWO_TO_32);
  for (
    goog.asserts.assert(0 <= b && b < jspb.BinaryConstants.TWO_TO_32);
    0 < b || 127 < a;

  )
    this.buffer_.push((a & 127) | 128),
      (a = ((a >>> 7) | (b << 25)) >>> 0),
      (b >>>= 7);
  this.buffer_.push(a);
};
jspb.BinaryEncoder.prototype.writeSplitFixed64 = function (a, b) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(b == Math.floor(b));
  goog.asserts.assert(0 <= a && a < jspb.BinaryConstants.TWO_TO_32);
  goog.asserts.assert(0 <= b && b < jspb.BinaryConstants.TWO_TO_32);
  this.writeUint32(a);
  this.writeUint32(b);
};
jspb.BinaryEncoder.prototype.writeUnsignedVarint32 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  for (
    goog.asserts.assert(0 <= a && a < jspb.BinaryConstants.TWO_TO_32);
    127 < a;

  )
    this.buffer_.push((a & 127) | 128), (a >>>= 7);
  this.buffer_.push(a);
};
jspb.BinaryEncoder.prototype.writeSignedVarint32 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    a >= -jspb.BinaryConstants.TWO_TO_31 && a < jspb.BinaryConstants.TWO_TO_31
  );
  if (0 <= a) this.writeUnsignedVarint32(a);
  else {
    for (var b = 0; 9 > b; b++) this.buffer_.push((a & 127) | 128), (a >>= 7);
    this.buffer_.push(1);
  }
};
jspb.BinaryEncoder.prototype.writeUnsignedVarint64 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(0 <= a && a < jspb.BinaryConstants.TWO_TO_64);
  jspb.utils.splitInt64(a);
  this.writeSplitVarint64(jspb.utils.split64Low, jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeSignedVarint64 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    a >= -jspb.BinaryConstants.TWO_TO_63 && a < jspb.BinaryConstants.TWO_TO_63
  );
  jspb.utils.splitInt64(a);
  this.writeSplitVarint64(jspb.utils.split64Low, jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeZigzagVarint32 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    a >= -jspb.BinaryConstants.TWO_TO_31 && a < jspb.BinaryConstants.TWO_TO_31
  );
  this.writeUnsignedVarint32(((a << 1) ^ (a >> 31)) >>> 0);
};
jspb.BinaryEncoder.prototype.writeZigzagVarint64 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    a >= -jspb.BinaryConstants.TWO_TO_63 && a < jspb.BinaryConstants.TWO_TO_63
  );
  jspb.utils.splitZigzag64(a);
  this.writeSplitVarint64(jspb.utils.split64Low, jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeZigzagVarint64String = function (a) {
  this.writeZigzagVarintHash64(jspb.utils.decimalStringToHash64(a));
};
jspb.BinaryEncoder.prototype.writeZigzagVarintHash64 = function (a) {
  var b = this;
  jspb.utils.splitHash64(a);
  jspb.utils.toZigzag64(
    jspb.utils.split64Low,
    jspb.utils.split64High,
    function (a, d) {
      b.writeSplitVarint64(a >>> 0, d >>> 0);
    }
  );
};
jspb.BinaryEncoder.prototype.writeUint8 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(0 <= a && 256 > a);
  this.buffer_.push((a >>> 0) & 255);
};
jspb.BinaryEncoder.prototype.writeUint16 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(0 <= a && 65536 > a);
  this.buffer_.push((a >>> 0) & 255);
  this.buffer_.push((a >>> 8) & 255);
};
jspb.BinaryEncoder.prototype.writeUint32 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(0 <= a && a < jspb.BinaryConstants.TWO_TO_32);
  this.buffer_.push((a >>> 0) & 255);
  this.buffer_.push((a >>> 8) & 255);
  this.buffer_.push((a >>> 16) & 255);
  this.buffer_.push((a >>> 24) & 255);
};
jspb.BinaryEncoder.prototype.writeUint64 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(0 <= a && a < jspb.BinaryConstants.TWO_TO_64);
  jspb.utils.splitUint64(a);
  this.writeUint32(jspb.utils.split64Low);
  this.writeUint32(jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeInt8 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(-128 <= a && 128 > a);
  this.buffer_.push((a >>> 0) & 255);
};
jspb.BinaryEncoder.prototype.writeInt16 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(-32768 <= a && 32768 > a);
  this.buffer_.push((a >>> 0) & 255);
  this.buffer_.push((a >>> 8) & 255);
};
jspb.BinaryEncoder.prototype.writeInt32 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    a >= -jspb.BinaryConstants.TWO_TO_31 && a < jspb.BinaryConstants.TWO_TO_31
  );
  this.buffer_.push((a >>> 0) & 255);
  this.buffer_.push((a >>> 8) & 255);
  this.buffer_.push((a >>> 16) & 255);
  this.buffer_.push((a >>> 24) & 255);
};
jspb.BinaryEncoder.prototype.writeInt64 = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    a >= -jspb.BinaryConstants.TWO_TO_63 && a < jspb.BinaryConstants.TWO_TO_63
  );
  jspb.utils.splitInt64(a);
  this.writeSplitFixed64(jspb.utils.split64Low, jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeInt64String = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    +a >= -jspb.BinaryConstants.TWO_TO_63 && +a < jspb.BinaryConstants.TWO_TO_63
  );
  jspb.utils.splitHash64(jspb.utils.decimalStringToHash64(a));
  this.writeSplitFixed64(jspb.utils.split64Low, jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeFloat = function (a) {
  goog.asserts.assert(
    Infinity === a ||
      -Infinity === a ||
      isNaN(a) ||
      (a >= -jspb.BinaryConstants.FLOAT32_MAX &&
        a <= jspb.BinaryConstants.FLOAT32_MAX)
  );
  jspb.utils.splitFloat32(a);
  this.writeUint32(jspb.utils.split64Low);
};
jspb.BinaryEncoder.prototype.writeDouble = function (a) {
  goog.asserts.assert(
    Infinity === a ||
      -Infinity === a ||
      isNaN(a) ||
      (a >= -jspb.BinaryConstants.FLOAT64_MAX &&
        a <= jspb.BinaryConstants.FLOAT64_MAX)
  );
  jspb.utils.splitFloat64(a);
  this.writeUint32(jspb.utils.split64Low);
  this.writeUint32(jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeBool = function (a) {
  goog.asserts.assert('boolean' === typeof a || 'number' === typeof a);
  this.buffer_.push(a ? 1 : 0);
};
jspb.BinaryEncoder.prototype.writeEnum = function (a) {
  goog.asserts.assert(a == Math.floor(a));
  goog.asserts.assert(
    a >= -jspb.BinaryConstants.TWO_TO_31 && a < jspb.BinaryConstants.TWO_TO_31
  );
  this.writeSignedVarint32(a);
};
jspb.BinaryEncoder.prototype.writeBytes = function (a) {
  this.buffer_.push.apply(this.buffer_, a);
};
jspb.BinaryEncoder.prototype.writeVarintHash64 = function (a) {
  jspb.utils.splitHash64(a);
  this.writeSplitVarint64(jspb.utils.split64Low, jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeFixedHash64 = function (a) {
  jspb.utils.splitHash64(a);
  this.writeUint32(jspb.utils.split64Low);
  this.writeUint32(jspb.utils.split64High);
};
jspb.BinaryEncoder.prototype.writeString = function (a) {
  for (var b = this.buffer_.length, c = 0; c < a.length; c++) {
    var d = a.charCodeAt(c);
    if (128 > d) this.buffer_.push(d);
    else if (2048 > d)
      this.buffer_.push((d >> 6) | 192), this.buffer_.push((d & 63) | 128);
    else if (65536 > d)
      if (55296 <= d && 56319 >= d && c + 1 < a.length) {
        var e = a.charCodeAt(c + 1);
        56320 <= e &&
          57343 >= e &&
          ((d = 1024 * (d - 55296) + e - 56320 + 65536),
          this.buffer_.push((d >> 18) | 240),
          this.buffer_.push(((d >> 12) & 63) | 128),
          this.buffer_.push(((d >> 6) & 63) | 128),
          this.buffer_.push((d & 63) | 128),
          c++);
      } else
        this.buffer_.push((d >> 12) | 224),
          this.buffer_.push(((d >> 6) & 63) | 128),
          this.buffer_.push((d & 63) | 128);
  }
  return this.buffer_.length - b;
};
jspb.BinaryWriter = function () {
  this.blocks_ = [];
  this.totalLength_ = 0;
  this.encoder_ = new jspb.BinaryEncoder();
  this.bookmarks_ = [];
};
jspb.BinaryWriter.prototype.appendUint8Array_ = function (a) {
  var b = this.encoder_.end();
  this.blocks_.push(b);
  this.blocks_.push(a);
  this.totalLength_ += b.length + a.length;
};
jspb.BinaryWriter.prototype.beginDelimited_ = function (a) {
  this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED);
  a = this.encoder_.end();
  this.blocks_.push(a);
  this.totalLength_ += a.length;
  a.push(this.totalLength_);
  return a;
};
jspb.BinaryWriter.prototype.endDelimited_ = function (a) {
  var b = a.pop();
  b = this.totalLength_ + this.encoder_.length() - b;
  for (goog.asserts.assert(0 <= b); 127 < b; )
    a.push((b & 127) | 128), (b >>>= 7), this.totalLength_++;
  a.push(b);
  this.totalLength_++;
};
jspb.BinaryWriter.prototype.writeSerializedMessage = function (a, b, c) {
  this.appendUint8Array_(a.subarray(b, c));
};
jspb.BinaryWriter.prototype.maybeWriteSerializedMessage = function (a, b, c) {
  null != a && null != b && null != c && this.writeSerializedMessage(a, b, c);
};
jspb.BinaryWriter.prototype.reset = function () {
  this.blocks_ = [];
  this.encoder_.end();
  this.totalLength_ = 0;
  this.bookmarks_ = [];
};
jspb.BinaryWriter.prototype.getResultBuffer = function () {
  goog.asserts.assert(0 == this.bookmarks_.length);
  for (
    var a = new Uint8Array(this.totalLength_ + this.encoder_.length()),
      b = this.blocks_,
      c = b.length,
      d = 0,
      e = 0;
    e < c;
    e++
  ) {
    var f = b[e];
    a.set(f, d);
    d += f.length;
  }
  b = this.encoder_.end();
  a.set(b, d);
  d += b.length;
  goog.asserts.assert(d == a.length);
  this.blocks_ = [a];
  return a;
};
jspb.BinaryWriter.prototype.getResultBase64String = function (a) {
  return goog.crypt.base64.encodeByteArray(this.getResultBuffer(), a);
};
jspb.BinaryWriter.prototype.beginSubMessage = function (a) {
  this.bookmarks_.push(this.beginDelimited_(a));
};
jspb.BinaryWriter.prototype.endSubMessage = function () {
  goog.asserts.assert(0 <= this.bookmarks_.length);
  this.endDelimited_(this.bookmarks_.pop());
};
jspb.BinaryWriter.prototype.writeFieldHeader_ = function (a, b) {
  goog.asserts.assert(1 <= a && a == Math.floor(a));
  this.encoder_.writeUnsignedVarint32(8 * a + b);
};
jspb.BinaryWriter.prototype.writeAny = function (a, b, c) {
  var d = jspb.BinaryConstants.FieldType;
  switch (a) {
    case d.DOUBLE:
      this.writeDouble(b, c);
      break;
    case d.FLOAT:
      this.writeFloat(b, c);
      break;
    case d.INT64:
      this.writeInt64(b, c);
      break;
    case d.UINT64:
      this.writeUint64(b, c);
      break;
    case d.INT32:
      this.writeInt32(b, c);
      break;
    case d.FIXED64:
      this.writeFixed64(b, c);
      break;
    case d.FIXED32:
      this.writeFixed32(b, c);
      break;
    case d.BOOL:
      this.writeBool(b, c);
      break;
    case d.STRING:
      this.writeString(b, c);
      break;
    case d.GROUP:
      goog.asserts.fail('Group field type not supported in writeAny()');
      break;
    case d.MESSAGE:
      goog.asserts.fail('Message field type not supported in writeAny()');
      break;
    case d.BYTES:
      this.writeBytes(b, c);
      break;
    case d.UINT32:
      this.writeUint32(b, c);
      break;
    case d.ENUM:
      this.writeEnum(b, c);
      break;
    case d.SFIXED32:
      this.writeSfixed32(b, c);
      break;
    case d.SFIXED64:
      this.writeSfixed64(b, c);
      break;
    case d.SINT32:
      this.writeSint32(b, c);
      break;
    case d.SINT64:
      this.writeSint64(b, c);
      break;
    case d.FHASH64:
      this.writeFixedHash64(b, c);
      break;
    case d.VHASH64:
      this.writeVarintHash64(b, c);
      break;
    default:
      goog.asserts.fail('Invalid field type in writeAny()');
  }
};
jspb.BinaryWriter.prototype.writeUnsignedVarint32_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeUnsignedVarint32(b));
};
jspb.BinaryWriter.prototype.writeSignedVarint32_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeSignedVarint32(b));
};
jspb.BinaryWriter.prototype.writeUnsignedVarint64_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeUnsignedVarint64(b));
};
jspb.BinaryWriter.prototype.writeSignedVarint64_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeSignedVarint64(b));
};
jspb.BinaryWriter.prototype.writeZigzagVarint32_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeZigzagVarint32(b));
};
jspb.BinaryWriter.prototype.writeZigzagVarint64_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeZigzagVarint64(b));
};
jspb.BinaryWriter.prototype.writeZigzagVarint64String_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeZigzagVarint64String(b));
};
jspb.BinaryWriter.prototype.writeZigzagVarintHash64_ = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeZigzagVarintHash64(b));
};
jspb.BinaryWriter.prototype.writeInt32 = function (a, b) {
  null != b &&
    (goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_31 && b < jspb.BinaryConstants.TWO_TO_31
    ),
    this.writeSignedVarint32_(a, b));
};
jspb.BinaryWriter.prototype.writeInt32String = function (a, b) {
  null != b &&
    ((b = parseInt(b, 10)),
    goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_31 && b < jspb.BinaryConstants.TWO_TO_31
    ),
    this.writeSignedVarint32_(a, b));
};
jspb.BinaryWriter.prototype.writeInt64 = function (a, b) {
  null != b &&
    (goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_63 && b < jspb.BinaryConstants.TWO_TO_63
    ),
    this.writeSignedVarint64_(a, b));
};
jspb.BinaryWriter.prototype.writeInt64String = function (a, b) {
  null != b &&
    ((b = jspb.arith.Int64.fromString(b)),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeSplitVarint64(b.lo, b.hi));
};
jspb.BinaryWriter.prototype.writeUint32 = function (a, b) {
  null != b &&
    (goog.asserts.assert(0 <= b && b < jspb.BinaryConstants.TWO_TO_32),
    this.writeUnsignedVarint32_(a, b));
};
jspb.BinaryWriter.prototype.writeUint32String = function (a, b) {
  null != b &&
    ((b = parseInt(b, 10)),
    goog.asserts.assert(0 <= b && b < jspb.BinaryConstants.TWO_TO_32),
    this.writeUnsignedVarint32_(a, b));
};
jspb.BinaryWriter.prototype.writeUint64 = function (a, b) {
  null != b &&
    (goog.asserts.assert(0 <= b && b < jspb.BinaryConstants.TWO_TO_64),
    this.writeUnsignedVarint64_(a, b));
};
jspb.BinaryWriter.prototype.writeUint64String = function (a, b) {
  null != b &&
    ((b = jspb.arith.UInt64.fromString(b)),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeSplitVarint64(b.lo, b.hi));
};
jspb.BinaryWriter.prototype.writeSint32 = function (a, b) {
  null != b &&
    (goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_31 && b < jspb.BinaryConstants.TWO_TO_31
    ),
    this.writeZigzagVarint32_(a, b));
};
jspb.BinaryWriter.prototype.writeSint64 = function (a, b) {
  null != b &&
    (goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_63 && b < jspb.BinaryConstants.TWO_TO_63
    ),
    this.writeZigzagVarint64_(a, b));
};
jspb.BinaryWriter.prototype.writeSintHash64 = function (a, b) {
  null != b && this.writeZigzagVarintHash64_(a, b);
};
jspb.BinaryWriter.prototype.writeSint64String = function (a, b) {
  null != b && this.writeZigzagVarint64String_(a, b);
};
jspb.BinaryWriter.prototype.writeFixed32 = function (a, b) {
  null != b &&
    (goog.asserts.assert(0 <= b && b < jspb.BinaryConstants.TWO_TO_32),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED32),
    this.encoder_.writeUint32(b));
};
jspb.BinaryWriter.prototype.writeFixed64 = function (a, b) {
  null != b &&
    (goog.asserts.assert(0 <= b && b < jspb.BinaryConstants.TWO_TO_64),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED64),
    this.encoder_.writeUint64(b));
};
jspb.BinaryWriter.prototype.writeFixed64String = function (a, b) {
  null != b &&
    ((b = jspb.arith.UInt64.fromString(b)),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED64),
    this.encoder_.writeSplitFixed64(b.lo, b.hi));
};
jspb.BinaryWriter.prototype.writeSfixed32 = function (a, b) {
  null != b &&
    (goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_31 && b < jspb.BinaryConstants.TWO_TO_31
    ),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED32),
    this.encoder_.writeInt32(b));
};
jspb.BinaryWriter.prototype.writeSfixed64 = function (a, b) {
  null != b &&
    (goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_63 && b < jspb.BinaryConstants.TWO_TO_63
    ),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED64),
    this.encoder_.writeInt64(b));
};
jspb.BinaryWriter.prototype.writeSfixed64String = function (a, b) {
  null != b &&
    ((b = jspb.arith.Int64.fromString(b)),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED64),
    this.encoder_.writeSplitFixed64(b.lo, b.hi));
};
jspb.BinaryWriter.prototype.writeFloat = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED32),
    this.encoder_.writeFloat(b));
};
jspb.BinaryWriter.prototype.writeDouble = function (a, b) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED64),
    this.encoder_.writeDouble(b));
};
jspb.BinaryWriter.prototype.writeBool = function (a, b) {
  null != b &&
    (goog.asserts.assert('boolean' === typeof b || 'number' === typeof b),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeBool(b));
};
jspb.BinaryWriter.prototype.writeEnum = function (a, b) {
  null != b &&
    (goog.asserts.assert(
      b >= -jspb.BinaryConstants.TWO_TO_31 && b < jspb.BinaryConstants.TWO_TO_31
    ),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeSignedVarint32(b));
};
jspb.BinaryWriter.prototype.writeString = function (a, b) {
  null != b &&
    ((a = this.beginDelimited_(a)),
    this.encoder_.writeString(b),
    this.endDelimited_(a));
};
jspb.BinaryWriter.prototype.writeBytes = function (a, b) {
  null != b &&
    ((b = jspb.utils.byteSourceToUint8Array(b)),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
    this.encoder_.writeUnsignedVarint32(b.length),
    this.appendUint8Array_(b));
};
jspb.BinaryWriter.prototype.writeMessage = function (a, b, c) {
  null != b &&
    ((a = this.beginDelimited_(a)), c(b, this), this.endDelimited_(a));
};
jspb.BinaryWriter.prototype.writeMessageSet = function (a, b, c) {
  null != b &&
    (this.writeFieldHeader_(1, jspb.BinaryConstants.WireType.START_GROUP),
    this.writeFieldHeader_(2, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeSignedVarint32(a),
    (a = this.beginDelimited_(3)),
    c(b, this),
    this.endDelimited_(a),
    this.writeFieldHeader_(1, jspb.BinaryConstants.WireType.END_GROUP));
};
jspb.BinaryWriter.prototype.writeGroup = function (a, b, c) {
  null != b &&
    (this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.START_GROUP),
    c(b, this),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.END_GROUP));
};
jspb.BinaryWriter.prototype.writeFixedHash64 = function (a, b) {
  null != b &&
    (goog.asserts.assert(8 == b.length),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED64),
    this.encoder_.writeFixedHash64(b));
};
jspb.BinaryWriter.prototype.writeVarintHash64 = function (a, b) {
  null != b &&
    (goog.asserts.assert(8 == b.length),
    this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT),
    this.encoder_.writeVarintHash64(b));
};
jspb.BinaryWriter.prototype.writeSplitFixed64 = function (a, b, c) {
  this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.FIXED64);
  this.encoder_.writeSplitFixed64(b, c);
};
jspb.BinaryWriter.prototype.writeSplitVarint64 = function (a, b, c) {
  this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT);
  this.encoder_.writeSplitVarint64(b, c);
};
jspb.BinaryWriter.prototype.writeSplitZigzagVarint64 = function (a, b, c) {
  this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.VARINT);
  var d = this.encoder_;
  jspb.utils.toZigzag64(b, c, function (a, b) {
    d.writeSplitVarint64(a >>> 0, b >>> 0);
  });
};
jspb.BinaryWriter.prototype.writeRepeatedInt32 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeSignedVarint32_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedInt32String = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeInt32String(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedInt64 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeSignedVarint64_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSplitFixed64 = function (a, b, c, d) {
  if (null != b)
    for (var e = 0; e < b.length; e++)
      this.writeSplitFixed64(a, c(b[e]), d(b[e]));
};
jspb.BinaryWriter.prototype.writeRepeatedSplitVarint64 = function (a, b, c, d) {
  if (null != b)
    for (var e = 0; e < b.length; e++)
      this.writeSplitVarint64(a, c(b[e]), d(b[e]));
};
jspb.BinaryWriter.prototype.writeRepeatedSplitZigzagVarint64 = function (
  a,
  b,
  c,
  d
) {
  if (null != b)
    for (var e = 0; e < b.length; e++)
      this.writeSplitZigzagVarint64(a, c(b[e]), d(b[e]));
};
jspb.BinaryWriter.prototype.writeRepeatedInt64String = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeInt64String(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedUint32 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeUnsignedVarint32_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedUint32String = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeUint32String(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedUint64 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeUnsignedVarint64_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedUint64String = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeUint64String(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSint32 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeZigzagVarint32_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSint64 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeZigzagVarint64_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSint64String = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeZigzagVarint64String_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSintHash64 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeZigzagVarintHash64_(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedFixed32 = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeFixed32(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedFixed64 = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeFixed64(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedFixed64String = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeFixed64String(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSfixed32 = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeSfixed32(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSfixed64 = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeSfixed64(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedSfixed64String = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeSfixed64String(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedFloat = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeFloat(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedDouble = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeDouble(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedBool = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeBool(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedEnum = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeEnum(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedString = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeString(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedBytes = function (a, b) {
  if (null != b) for (var c = 0; c < b.length; c++) this.writeBytes(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedMessage = function (a, b, c) {
  if (null != b)
    for (var d = 0; d < b.length; d++) {
      var e = this.beginDelimited_(a);
      c(b[d], this);
      this.endDelimited_(e);
    }
};
jspb.BinaryWriter.prototype.writeRepeatedGroup = function (a, b, c) {
  if (null != b)
    for (var d = 0; d < b.length; d++)
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.START_GROUP),
        c(b[d], this),
        this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.END_GROUP);
};
jspb.BinaryWriter.prototype.writeRepeatedFixedHash64 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeFixedHash64(a, b[c]);
};
jspb.BinaryWriter.prototype.writeRepeatedVarintHash64 = function (a, b) {
  if (null != b)
    for (var c = 0; c < b.length; c++) this.writeVarintHash64(a, b[c]);
};
jspb.BinaryWriter.prototype.writePackedInt32 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) this.encoder_.writeSignedVarint32(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedInt32String = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++)
      this.encoder_.writeSignedVarint32(parseInt(b[c], 10));
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedInt64 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) this.encoder_.writeSignedVarint64(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedSplitFixed64 = function (a, b, c, d) {
  if (null != b) {
    a = this.beginDelimited_(a);
    for (var e = 0; e < b.length; e++)
      this.encoder_.writeSplitFixed64(c(b[e]), d(b[e]));
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedSplitVarint64 = function (a, b, c, d) {
  if (null != b) {
    a = this.beginDelimited_(a);
    for (var e = 0; e < b.length; e++)
      this.encoder_.writeSplitVarint64(c(b[e]), d(b[e]));
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedSplitZigzagVarint64 = function (
  a,
  b,
  c,
  d
) {
  if (null != b) {
    a = this.beginDelimited_(a);
    for (var e = this.encoder_, f = 0; f < b.length; f++)
      jspb.utils.toZigzag64(c(b[f]), d(b[f]), function (a, b) {
        e.writeSplitVarint64(a >>> 0, b >>> 0);
      });
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedInt64String = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) {
      var d = jspb.arith.Int64.fromString(b[c]);
      this.encoder_.writeSplitVarint64(d.lo, d.hi);
    }
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedUint32 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++)
      this.encoder_.writeUnsignedVarint32(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedUint32String = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++)
      this.encoder_.writeUnsignedVarint32(parseInt(b[c], 10));
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedUint64 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++)
      this.encoder_.writeUnsignedVarint64(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedUint64String = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) {
      var d = jspb.arith.UInt64.fromString(b[c]);
      this.encoder_.writeSplitVarint64(d.lo, d.hi);
    }
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedSint32 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) this.encoder_.writeZigzagVarint32(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedSint64 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) this.encoder_.writeZigzagVarint64(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedSint64String = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++)
      this.encoder_.writeZigzagVarintHash64(
        jspb.utils.decimalStringToHash64(b[c])
      );
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedSintHash64 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++)
      this.encoder_.writeZigzagVarintHash64(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedFixed32 = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(4 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeUint32(b[a]);
};
jspb.BinaryWriter.prototype.writePackedFixed64 = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(8 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeUint64(b[a]);
};
jspb.BinaryWriter.prototype.writePackedFixed64String = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(8 * b.length),
        a = 0;
      a < b.length;
      a++
    ) {
      var c = jspb.arith.UInt64.fromString(b[a]);
      this.encoder_.writeSplitFixed64(c.lo, c.hi);
    }
};
jspb.BinaryWriter.prototype.writePackedSfixed32 = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(4 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeInt32(b[a]);
};
jspb.BinaryWriter.prototype.writePackedSfixed64 = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(8 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeInt64(b[a]);
};
jspb.BinaryWriter.prototype.writePackedSfixed64String = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(8 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeInt64String(b[a]);
};
jspb.BinaryWriter.prototype.writePackedFloat = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(4 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeFloat(b[a]);
};
jspb.BinaryWriter.prototype.writePackedDouble = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(8 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeDouble(b[a]);
};
jspb.BinaryWriter.prototype.writePackedBool = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeBool(b[a]);
};
jspb.BinaryWriter.prototype.writePackedEnum = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) this.encoder_.writeEnum(b[c]);
    this.endDelimited_(a);
  }
};
jspb.BinaryWriter.prototype.writePackedFixedHash64 = function (a, b) {
  if (null != b && b.length)
    for (
      this.writeFieldHeader_(a, jspb.BinaryConstants.WireType.DELIMITED),
        this.encoder_.writeUnsignedVarint32(8 * b.length),
        a = 0;
      a < b.length;
      a++
    )
      this.encoder_.writeFixedHash64(b[a]);
};
jspb.BinaryWriter.prototype.writePackedVarintHash64 = function (a, b) {
  if (null != b && b.length) {
    a = this.beginDelimited_(a);
    for (var c = 0; c < b.length; c++) this.encoder_.writeVarintHash64(b[c]);
    this.endDelimited_(a);
  }
};
jspb.Export = {};
exports.Map = jspb.Map;
exports.Message = jspb.Message;
exports.BinaryReader = jspb.BinaryReader;
exports.BinaryWriter = jspb.BinaryWriter;
exports.ExtensionFieldInfo = jspb.ExtensionFieldInfo;
exports.ExtensionFieldBinaryInfo = jspb.ExtensionFieldBinaryInfo;
exports.exportSymbol = goog.exportSymbol;
exports.inherits = goog.inherits;
exports.object = {
  extend: goog.object.extend,
};
exports.typeOf = goog.typeOf;