API tools faq
paste
Guest User

Untitled

a guest
Aug 31st, 2015
477
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 269.34 KB | None | 0 0
raw download clone embed print report
  1. this._ = this._ || {};
  2. (function(self) {
  3.   var window = this;
  4.   try {
  5.     if (window.google.timers) {
  6.       if (window.google.timers.load) {
  7.         if (window.google.timers.load.t) {
  8.           window.google.timers.load.t.xjses = window.google.time();
  9.         }
  10.       }
  11.     }
  12.     var wc;
  13.     var dictSize;
  14.     var bound;
  15.     var $goog$bindJs_$;
  16.     self.aaa = self.aaa || {};
  17.     self.ca = this;
  18.     /**
  19.      * @param {?} property
  20.      * @return {?}
  21.      */
  22.     self.Uf = function(property) {
  23.       return void 0 !== property;
  24.     };
  25.     /**
  26.      * @param {string} pair
  27.      * @param {(Document|string)} autoplay
  28.      * @return {?}
  29.      */
  30.     self.aa = function(pair, autoplay) {
  31.       var pathConfig = pair.split(".");
  32.       var cur = autoplay || self.ca;
  33.       var dir;
  34.       for (;dir = pathConfig.shift();) {
  35.         if (null != cur[dir]) {
  36.           cur = cur[dir];
  37.         } else {
  38.           return null;
  39.         }
  40.       }
  41.       return cur;
  42.     };
  43.     /**
  44.      * @return {undefined}
  45.      */
  46.     self.R = function() {
  47.     };
  48.     /**
  49.      * @param {Function} res
  50.      * @return {undefined}
  51.      */
  52.     self.ea = function(res) {
  53.       /**
  54.        * @return {?}
  55.        */
  56.       res.Sa = function() {
  57.         return res.wu ? res.wu : res.wu = new res;
  58.       };
  59.     };
  60.     /**
  61.      * @param {?} value
  62.      * @return {?}
  63.      */
  64.     self.ja = function(value) {
  65.       /** @type {string} */
  66.       var $s = typeof value;
  67.       if ("object" == $s) {
  68.         if (value) {
  69.           if (value instanceof Array) {
  70.             return "array";
  71.           }
  72.           if (value instanceof Object) {
  73.             return $s;
  74.           }
  75.           /** @type {string} */
  76.           var isFunction = Object.prototype.toString.call(value);
  77.           if ("[object Window]" == isFunction) {
  78.             return "object";
  79.           }
  80.           if ("[object Array]" == isFunction || "number" == typeof value.length && ("undefined" != typeof value.splice && ("undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("splice")))) {
  81.             return "array";
  82.           }
  83.           if ("[object Function]" == isFunction || "undefined" != typeof value.call && ("undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("call"))) {
  84.             return "function";
  85.           }
  86.         } else {
  87.           return "null";
  88.         }
  89.       } else {
  90.         if ("function" == $s && "undefined" == typeof value.call) {
  91.           return "object";
  92.         }
  93.       }
  94.       return $s;
  95.     };
  96.     /**
  97.      * @param {number} dataAndEvents
  98.      * @return {?}
  99.      */
  100.     self.baa = function(dataAndEvents) {
  101.       return null === dataAndEvents;
  102.     };
  103.     /**
  104.      * @param {string} dataAndEvents
  105.      * @return {?}
  106.      */
  107.     self.Caa = function(dataAndEvents) {
  108.       return null != dataAndEvents;
  109.     };
  110.     /**
  111.      * @param {?} opt_attributes
  112.      * @return {?}
  113.      */
  114.     self.ka = function(opt_attributes) {
  115.       return "array" == self.ja(opt_attributes);
  116.     };
  117.     /**
  118.      * @param {?} opt_attributes
  119.      * @return {?}
  120.      */
  121.     self.la = function(opt_attributes) {
  122.       var $type = self.ja(opt_attributes);
  123.       return "array" == $type || "object" == $type && "number" == typeof opt_attributes.length;
  124.     };
  125.     /**
  126.      * @param {?} opt_attributes
  127.      * @return {?}
  128.      */
  129.     self.ma = function(opt_attributes) {
  130.       return "string" == typeof opt_attributes;
  131.     };
  132.     /**
  133.      * @param {?} val
  134.      * @return {?}
  135.      */
  136.     self.oa = function(val) {
  137.       return "number" == typeof val;
  138.     };
  139.     /**
  140.      * @param {?} str
  141.      * @return {?}
  142.      */
  143.     self.pa = function(str) {
  144.       return "function" == self.ja(str);
  145.     };
  146.     /**
  147.      * @param {?} opt_attributes
  148.      * @return {?}
  149.      */
  150.     self.qa = function(opt_attributes) {
  151.       /** @type {string} */
  152.       var $s = typeof opt_attributes;
  153.       return "object" == $s && null != opt_attributes || "function" == $s;
  154.     };
  155.     /**
  156.      * @param {?} opt_attributes
  157.      * @return {?}
  158.      */
  159.     self.ra = function(opt_attributes) {
  160.       return opt_attributes[wc] || (opt_attributes[wc] = ++dictSize);
  161.     };
  162.     /** @type {string} */
  163.     wc = "closure_uid_" + (1E9 * Math.random() >>> 0);
  164.     /** @type {number} */
  165.     dictSize = 0;
  166.     /**
  167.      * @param {Function} cb
  168.      * @param {?} lower
  169.      * @param {?} num
  170.      * @return {?}
  171.      */
  172.     bound = function(cb, lower, num) {
  173.       return cb.call.apply(cb.bind, arguments);
  174.     };
  175.     /**
  176.      * @param {Function} matcherFunction
  177.      * @param {Object} $selfObj$$
  178.      * @param {?} $var_args$$
  179.      * @return {?}
  180.      */
  181.     $goog$bindJs_$ = function(matcherFunction, $selfObj$$, $var_args$$) {
  182.       if (!matcherFunction) {
  183.         throw Error();
  184.       }
  185.       if (2 < arguments.length) {
  186.         /** @type {Array.<?>} */
  187.         var args = Array.prototype.slice.call(arguments, 2);
  188.         return function() {
  189.           /** @type {Array.<?>} */
  190.           var recurring = Array.prototype.slice.call(arguments);
  191.           Array.prototype.unshift.apply(recurring, args);
  192.           return matcherFunction.apply($selfObj$$, recurring);
  193.         };
  194.       }
  195.       return function() {
  196.         return matcherFunction.apply($selfObj$$, arguments);
  197.       };
  198.     };
  199.     /**
  200.      * @param {Function} v
  201.      * @param {?} l
  202.      * @param {?} y
  203.      * @return {?}
  204.      */
  205.     self.p = function(v, l, y) {
  206.       self.p = Function.prototype.bind && -1 != Function.prototype.bind.toString().indexOf("native code") ? bound : $goog$bindJs_$;
  207.       return self.p.apply(null, arguments);
  208.     };
  209.     /**
  210.      * @param {Function} method
  211.      * @param {Function} o
  212.      * @return {?}
  213.      */
  214.     self.sa = function(method, o) {
  215.       /** @type {Array.<?>} */
  216.       var args = Array.prototype.slice.call(arguments, 1);
  217.       return function() {
  218.         /** @type {Array.<?>} */
  219.         var newArgs = args.slice();
  220.         newArgs.push.apply(newArgs, arguments);
  221.         return method.apply(this, newArgs);
  222.       };
  223.     };
  224.     /** @type {function (): number} */
  225.     self.q = Date.now || function() {
  226.       return+new Date;
  227.     };
  228.     /**
  229.      * @param {string} pair
  230.      * @param {Function} o
  231.      * @return {undefined}
  232.      */
  233.     self.ua = function(pair, o) {
  234.       var parts = pair.split(".");
  235.       var cur = self.ca;
  236.       if (!(parts[0] in cur)) {
  237.         if (!!cur.execScript) {
  238.           cur.execScript("var " + parts[0]);
  239.         }
  240.       }
  241.       var i;
  242.       for (;parts.length && (i = parts.shift());) {
  243.         if (!parts.length && self.Uf(o)) {
  244.           /** @type {Function} */
  245.           cur[i] = o;
  246.         } else {
  247.           if (cur[i]) {
  248.             cur = cur[i];
  249.           } else {
  250.             cur = cur[i] = {};
  251.           }
  252.         }
  253.       }
  254.     };
  255.     /**
  256.      * @param {Function} obj
  257.      * @param {?} parentClass
  258.      * @return {undefined}
  259.      */
  260.     self.r = function(obj, parentClass) {
  261.       /**
  262.        * @return {undefined}
  263.        */
  264.       function emptyConstructor() {
  265.       }
  266.       emptyConstructor.prototype = parentClass.prototype;
  267.       obj.Ba = parentClass.prototype;
  268.       obj.prototype = new emptyConstructor;
  269.       /** @type {Function} */
  270.       obj.prototype.constructor = obj;
  271.       /**
  272.        * @param {?} recurring
  273.        * @param {?} methodname
  274.        * @param {?} dataAndEvents
  275.        * @return {?}
  276.        */
  277.       obj.Rd = function(recurring, methodname, dataAndEvents) {
  278.         /** @type {Array} */
  279.         var args = Array(arguments.length - 2);
  280.         /** @type {number} */
  281.         var i = 2;
  282.         for (;i < arguments.length;i++) {
  283.           args[i - 2] = arguments[i];
  284.         }
  285.         return parentClass.prototype[methodname].apply(recurring, args);
  286.       };
  287.     };
  288.     /**
  289.      * @param {?} opt_msg
  290.      * @return {undefined}
  291.      */
  292.     self.va = function(opt_msg) {
  293.       if (Error.captureStackTrace) {
  294.         Error.captureStackTrace(this, self.va);
  295.       } else {
  296.         /** @type {string} */
  297.         var stack = Error().stack;
  298.         if (stack) {
  299.           /** @type {string} */
  300.           this.stack = stack;
  301.         }
  302.       }
  303.       if (opt_msg) {
  304.         /** @type {string} */
  305.         this.message = String(opt_msg);
  306.       }
  307.     };
  308.     self.r(self.va, Error);
  309.     /** @type {string} */
  310.     self.va.prototype.name = "CustomError";
  311.     var hasMembers;
  312.     var rreturn;
  313.     var regExclamation;
  314.     var regexTrim;
  315.     var splatParam;
  316.     var unsafe_chars;
  317.     var rclass;
  318.     var rneedsContext;
  319.     var run;
  320.     var download;
  321.     var rmsPrefix;
  322.     var cmp;
  323.     /**
  324.      * @param {string} str
  325.      * @param {string} prefix
  326.      * @return {?}
  327.      */
  328.     self.wa = function(str, prefix) {
  329.       return 0 == str.lastIndexOf(prefix, 0);
  330.     };
  331.     /**
  332.      * @param {?} opt_attributes
  333.      * @param {Object} name
  334.      * @return {?}
  335.      */
  336.     self.xa = function(opt_attributes, name) {
  337.       /** @type {number} */
  338.       var startIndex = opt_attributes.length - name.length;
  339.       return 0 <= startIndex && opt_attributes.indexOf(name, startIndex) == startIndex;
  340.     };
  341.     /**
  342.      * @param {?} opt_attributes
  343.      * @param {Object} name
  344.      * @return {?}
  345.      */
  346.     self.ya = function(opt_attributes, name) {
  347.       return opt_attributes.toLowerCase() == name.toLowerCase();
  348.     };
  349.     /**
  350.      * @param {?} opt_attributes
  351.      * @param {Object} name
  352.      * @return {?}
  353.      */
  354.     self.za = function(opt_attributes, name) {
  355.       var namespaces = opt_attributes.split("%s");
  356.       /** @type {string} */
  357.       var optsData = "";
  358.       /** @type {Array.<?>} */
  359.       var resolveValues = Array.prototype.slice.call(arguments, 1);
  360.       for (;resolveValues.length && 1 < namespaces.length;) {
  361.         optsData += namespaces.shift() + resolveValues.shift();
  362.       }
  363.       return optsData + namespaces.join("%s");
  364.     };
  365.     /**
  366.      * @param {?} opt_attributes
  367.      * @return {?}
  368.      */
  369.     self.Ma = function(opt_attributes) {
  370.       return/^[\s\xa0]*$/.test(opt_attributes);
  371.     };
  372.     /**
  373.      * @param {string} messageFormat
  374.      * @return {?}
  375.      */
  376.     self.haa = function(messageFormat) {
  377.       return messageFormat.replace(/(\r\n|\r|\n)/g, "\n");
  378.     };
  379.     /** @type {function (?): ?} */
  380.     self.Da = String.prototype.trim ? function(opt_attributes) {
  381.       return opt_attributes.trim();
  382.     } : function(opt_attributes) {
  383.       return opt_attributes.replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
  384.     };
  385.     /**
  386.      * @param {?} opt_attributes
  387.      * @return {?}
  388.      */
  389.     self.Ea = function(opt_attributes) {
  390.       return(0, window.encodeURIComponent)(String(opt_attributes));
  391.     };
  392.     /**
  393.      * @param {string} messageFormat
  394.      * @return {?}
  395.      */
  396.     self.Fa = function(messageFormat) {
  397.       return(0, window.decodeURIComponent)(messageFormat.replace(/\+/g, " "));
  398.     };
  399.     /**
  400.      * @param {string} selectors
  401.      * @return {?}
  402.      */
  403.     self.Ga = function(selectors) {
  404.       if (!rneedsContext.test(selectors)) {
  405.         return selectors;
  406.       }
  407.       if (-1 != selectors.indexOf("&")) {
  408.         selectors = selectors.replace(rreturn, "&amp;");
  409.       }
  410.       if (-1 != selectors.indexOf("<")) {
  411.         selectors = selectors.replace(regExclamation, "&lt;");
  412.       }
  413.       if (-1 != selectors.indexOf(">")) {
  414.         selectors = selectors.replace(regexTrim, "&gt;");
  415.       }
  416.       if (-1 != selectors.indexOf('"')) {
  417.         selectors = selectors.replace(splatParam, "&quot;");
  418.       }
  419.       if (-1 != selectors.indexOf("'")) {
  420.         selectors = selectors.replace(unsafe_chars, "&#39;");
  421.       }
  422.       if (-1 != selectors.indexOf("\x00")) {
  423.         selectors = selectors.replace(rclass, "&#0;");
  424.       }
  425.       return selectors;
  426.     };
  427.     /** @type {RegExp} */
  428.     rreturn = /&/g;
  429.     /** @type {RegExp} */
  430.     regExclamation = /</g;
  431.     /** @type {RegExp} */
  432.     regexTrim = />/g;
  433.     /** @type {RegExp} */
  434.     splatParam = /"/g;
  435.     /** @type {RegExp} */
  436.     unsafe_chars = /'/g;
  437.     /** @type {RegExp} */
  438.     rclass = /\x00/g;
  439.     /** @type {RegExp} */
  440.     rneedsContext = /[\x00&<>"']/;
  441.     /**
  442.      * @param {?} attributes
  443.      * @return {?}
  444.      */
  445.     self.Ka = function(attributes) {
  446.       return self.Ja(attributes, "&") ? "document" in self.ca ? run(attributes) : download(attributes) : attributes;
  447.     };
  448.     /**
  449.      * @param {?} string
  450.      * @return {?}
  451.      */
  452.     run = function(string) {
  453.       var values = {
  454.         "&amp;" : "&",
  455.         "&lt;" : "<",
  456.         "&gt;" : ">",
  457.         "&quot;" : '"'
  458.       };
  459.       var div;
  460.       div = self.ca.document.createElement("div");
  461.       return string.replace(rmsPrefix, function(s, entity) {
  462.         var value = values[s];
  463.         if (value) {
  464.           return value;
  465.         }
  466.         if ("#" == entity.charAt(0)) {
  467.           /** @type {number} */
  468.           var b = Number("0" + entity.substr(1));
  469.           if (!(0, window.isNaN)(b)) {
  470.             /** @type {string} */
  471.             value = String.fromCharCode(b);
  472.           }
  473.         }
  474.         if (!value) {
  475.           /** @type {string} */
  476.           div.innerHTML = s + " ";
  477.           value = div.firstChild.nodeValue.slice(0, -1);
  478.         }
  479.         return values[s] = value;
  480.       });
  481.     };
  482.     /**
  483.      * @param {?} target
  484.      * @return {?}
  485.      */
  486.     download = function(target) {
  487.       return target.replace(/&([^;]+);/g, function(file, entity) {
  488.         switch(entity) {
  489.           case "amp":
  490.             return "&";
  491.           case "lt":
  492.             return "<";
  493.           case "gt":
  494.             return ">";
  495.           case "quot":
  496.             return'"';
  497.           default:
  498.             if ("#" == entity.charAt(0)) {
  499.               /** @type {number} */
  500.               var b = Number("0" + entity.substr(1));
  501.               if (!(0, window.isNaN)(b)) {
  502.                 return String.fromCharCode(b);
  503.               }
  504.             }
  505.             return file;
  506.         }
  507.       });
  508.     };
  509.     /** @type {RegExp} */
  510.     rmsPrefix = /&([^;\s<&]+);?/g;
  511.     /**
  512.      * @param {?} opt_attributes
  513.      * @param {Object} name
  514.      * @return {?}
  515.      */
  516.     self.Ja = function(opt_attributes, name) {
  517.       return-1 != opt_attributes.indexOf(name);
  518.     };
  519.     /**
  520.      * @param {?} name
  521.      * @param {?} attributes
  522.      * @return {?}
  523.      */
  524.     self.saa = function(name, attributes) {
  525.       /** @type {RegExp} */
  526.       var re = new RegExp(self.Na(attributes), "");
  527.       return name.replace(re, "");
  528.     };
  529.     /**
  530.      * @param {?} opt_attributes
  531.      * @return {?}
  532.      */
  533.     self.Na = function(opt_attributes) {
  534.       return String(opt_attributes).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08");
  535.     };
  536.     /**
  537.      * @param {string} delimit2
  538.      * @param {number} len
  539.      * @return {?}
  540.      */
  541.     self.Oa = function(delimit2, len) {
  542.       return Array(len + 1).join(delimit2);
  543.     };
  544.     /**
  545.      * @param {string} arg
  546.      * @param {undefined} width
  547.      * @param {number} i
  548.      * @return {?}
  549.      */
  550.     self.Vo = function(arg, width, i) {
  551.       arg = self.Uf(i) ? arg.toFixed(i) : String(arg);
  552.       i = arg.indexOf(".");
  553.       if (-1 == i) {
  554.         i = arg.length;
  555.       }
  556.       return self.Oa("0", Math.max(0, width - i)) + arg;
  557.     };
  558.     /**
  559.      * @param {?} opt_attributes
  560.      * @return {?}
  561.      */
  562.     self.Ba = function(opt_attributes) {
  563.       return null == opt_attributes ? "" : String(opt_attributes);
  564.     };
  565.     /**
  566.      * @param {?} opt_message
  567.      * @param {?} obj
  568.      * @return {?}
  569.      */
  570.     self.Pa = function(opt_message, obj) {
  571.       /** @type {number} */
  572.       var year = 0;
  573.       var v1Subs = (0, self.Da)(String(opt_message)).split(".");
  574.       var v2Subs = (0, self.Da)(String(obj)).split(".");
  575.       /** @type {number} */
  576.       var month = Math.max(v1Subs.length, v2Subs.length);
  577.       /** @type {number} */
  578.       var subIdx = 0;
  579.       for (;0 == year && subIdx < month;subIdx++) {
  580.         var value = v1Subs[subIdx] || "";
  581.         var v2Sub = v2Subs[subIdx] || "";
  582.         /** @type {RegExp} */
  583.         var re = RegExp("(\\d*)(\\D*)", "g");
  584.         /** @type {RegExp} */
  585.         var regex = RegExp("(\\d*)(\\D*)", "g");
  586.         do {
  587.           /** @type {Array} */
  588.           var a = re.exec(value) || ["", "", ""];
  589.           /** @type {Array} */
  590.           var b = regex.exec(v2Sub) || ["", "", ""];
  591.           if (0 == a[0].length && 0 == b[0].length) {
  592.             break;
  593.           }
  594.           year = cmp(0 == a[1].length ? 0 : (0, window.parseInt)(a[1], 10), 0 == b[1].length ? 0 : (0, window.parseInt)(b[1], 10)) || (cmp(0 == a[2].length, 0 == b[2].length) || cmp(a[2], b[2]));
  595.         } while (0 == year);
  596.       }
  597.       return year;
  598.     };
  599.     /**
  600.      * @param {(boolean|number|string)} a
  601.      * @param {(boolean|number|string)} b
  602.      * @return {?}
  603.      */
  604.     cmp = function(a, b) {
  605.       return a < b ? -1 : a > b ? 1 : 0;
  606.     };
  607.     /** @type {number} */
  608.     self.uaa = 2147483648 * Math.random() | 0;
  609.     /**
  610.      * @param {?} attributes
  611.      * @return {?}
  612.      */
  613.     self.Qa = function(attributes) {
  614.       /** @type {number} */
  615.       var b = Number(attributes);
  616.       return 0 == b && self.Ma(attributes) ? window.NaN : b;
  617.     };
  618.     /**
  619.      * @param {?} value
  620.      * @return {?}
  621.      */
  622.     self.Ra = function(value) {
  623.       return String(value).replace(/\-([a-z])/g, function(dataAndEvents, letter) {
  624.         return letter.toUpperCase();
  625.       });
  626.     };
  627.     /**
  628.      * @param {string} arg
  629.      * @return {?}
  630.      */
  631.     self.Sa = function(arg) {
  632.       return String(arg).replace(/([A-Z])/g, "-$1").toLowerCase();
  633.     };
  634.     /**
  635.      * @param {string} str
  636.      * @return {?}
  637.      */
  638.     self.Ta = function(str) {
  639.       var charset = self.ma(void 0) ? self.Na(void 0) : "\\s";
  640.       return str.replace(new RegExp("(^" + (charset ? "|[" + charset + "]+" : "") + ")([a-z])", "g"), function(dataAndEvents, deepDataAndEvents, letter) {
  641.         return deepDataAndEvents + letter.toUpperCase();
  642.       });
  643.     };
  644.     /**
  645.      * @param {Array} first
  646.      * @return {?}
  647.      */
  648.     self.Ua = function(first) {
  649.       return first[first.length - 1];
  650.     };
  651.     self.Wa = Array.prototype;
  652.     /** @type {function (?, ?, ?): ?} */
  653.     self.Xa = self.Wa.indexOf ? function(next_scope, mapper, graphics) {
  654.       return self.Wa.indexOf.call(next_scope, mapper, graphics);
  655.     } : function(attributes, opt_attributes, from) {
  656.       from = null == from ? 0 : 0 > from ? Math.max(0, attributes.length + from) : from;
  657.       if (self.ma(attributes)) {
  658.         return self.ma(opt_attributes) && 1 == opt_attributes.length ? attributes.indexOf(opt_attributes, from) : -1;
  659.       }
  660.       for (;from < attributes.length;from++) {
  661.         if (from in attributes && attributes[from] === opt_attributes) {
  662.           return from;
  663.         }
  664.       }
  665.       return-1;
  666.     };
  667.     /** @type {function (?, Object, (boolean|number|string)): undefined} */
  668.     self.u = self.Wa.forEach ? function(opt_attributes, name, attributes) {
  669.       self.Wa.forEach.call(opt_attributes, name, attributes);
  670.     } : function(opt_attributes, name, attributes) {
  671.       var valuesLen = opt_attributes.length;
  672.       var arr2 = self.ma(opt_attributes) ? opt_attributes.split("") : opt_attributes;
  673.       /** @type {number} */
  674.       var i = 0;
  675.       for (;i < valuesLen;i++) {
  676.         if (i in arr2) {
  677.           name.call(attributes, arr2[i], i, opt_attributes);
  678.         }
  679.       }
  680.     };
  681.     /**
  682.      * @param {?} opt_attributes
  683.      * @param {Object} name
  684.      * @param {(boolean|number|string)} attributes
  685.      * @return {undefined}
  686.      */
  687.     self.Ya = function(opt_attributes, name, attributes) {
  688.       var arr2 = self.ma(opt_attributes) ? opt_attributes.split("") : opt_attributes;
  689.       /** @type {number} */
  690.       var i = opt_attributes.length - 1;
  691.       for (;0 <= i;--i) {
  692.         if (i in arr2) {
  693.           name.call(attributes, arr2[i], i, opt_attributes);
  694.         }
  695.       }
  696.     };
  697.     /** @type {function (?, Object, (boolean|number|string)): ?} */
  698.     self.Za = self.Wa.filter ? function(opt_attributes, name, attributes) {
  699.       return self.Wa.filter.call(opt_attributes, name, attributes);
  700.     } : function(opt_attributes, name, attributes) {
  701.       var valuesLen = opt_attributes.length;
  702.       /** @type {Array} */
  703.       var res = [];
  704.       /** @type {number} */
  705.       var resLength = 0;
  706.       var arr2 = self.ma(opt_attributes) ? opt_attributes.split("") : opt_attributes;
  707.       /** @type {number} */
  708.       var i = 0;
  709.       for (;i < valuesLen;i++) {
  710.         if (i in arr2) {
  711.           var val = arr2[i];
  712.           if (name.call(attributes, val, i, opt_attributes)) {
  713.             res[resLength++] = val;
  714.           }
  715.         }
  716.       }
  717.       return res;
  718.     };
  719.     /** @type {function (?, ?, ?): ?} */
  720.     self.$a = self.Wa.map ? function(next_scope, mapper, graphics) {
  721.       return self.Wa.map.call(next_scope, mapper, graphics);
  722.     } : function(attributes, callback, thisArg) {
  723.       var n = attributes.length;
  724.       /** @type {Array} */
  725.       var result = Array(n);
  726.       var arr2 = self.ma(attributes) ? attributes.split("") : attributes;
  727.       /** @type {number} */
  728.       var i = 0;
  729.       for (;i < n;i++) {
  730.         if (i in arr2) {
  731.           result[i] = callback.call(thisArg, arr2[i], i, attributes);
  732.         }
  733.       }
  734.       return result;
  735.     };
  736.     /** @type {function (?, Text, ?, ?): ?} */
  737.     self.ab = self.Wa.reduce ? function(next_scope, callback, graphics, thisObj) {
  738.       if (thisObj) {
  739.         callback = (0, self.p)(callback, thisObj);
  740.       }
  741.       return self.Wa.reduce.call(next_scope, callback, graphics);
  742.     } : function(arr, f, val, opt_obj) {
  743.       var rval = val;
  744.       (0, self.u)(arr, function(val, index) {
  745.         rval = f.call(opt_obj, rval, val, index, arr);
  746.       });
  747.       return rval;
  748.     };
  749.     /** @type {function (?, ?, ?): ?} */
  750.     self.bb = self.Wa.some ? function(next_scope, mapper, graphics) {
  751.       return self.Wa.some.call(next_scope, mapper, graphics);
  752.     } : function(attributes, f, opt_obj) {
  753.       var aLength = attributes.length;
  754.       var arr2 = self.ma(attributes) ? attributes.split("") : attributes;
  755.       /** @type {number} */
  756.       var i = 0;
  757.       for (;i < aLength;i++) {
  758.         if (i in arr2 && f.call(opt_obj, arr2[i], i, attributes)) {
  759.           return true;
  760.         }
  761.       }
  762.       return false;
  763.     };
  764.     /** @type {function (?, ?, ?): ?} */
  765.     self.cb = self.Wa.every ? function(next_scope, mapper, graphics) {
  766.       return self.Wa.every.call(next_scope, mapper, graphics);
  767.     } : function(attributes, callback, T) {
  768.       var aLength = attributes.length;
  769.       var arr2 = self.ma(attributes) ? attributes.split("") : attributes;
  770.       /** @type {number} */
  771.       var i = 0;
  772.       for (;i < aLength;i++) {
  773.         if (i in arr2 && !callback.call(T, arr2[i], i, attributes)) {
  774.           return false;
  775.         }
  776.       }
  777.       return true;
  778.     };
  779.     /**
  780.      * @param {?} attributes
  781.      * @param {number} p
  782.      * @param {?} db
  783.      * @return {?}
  784.      */
  785.     self.eb = function(attributes, p, db) {
  786.       p = self.db(attributes, p, db);
  787.       return 0 > p ? null : self.ma(attributes) ? attributes.charAt(p) : attributes[p];
  788.     };
  789.     /**
  790.      * @param {?} attributes
  791.      * @param {Function} f
  792.      * @param {?} opt_obj
  793.      * @return {?}
  794.      */
  795.     self.db = function(attributes, f, opt_obj) {
  796.       var aLength = attributes.length;
  797.       var arr2 = self.ma(attributes) ? attributes.split("") : attributes;
  798.       /** @type {number} */
  799.       var i = 0;
  800.       for (;i < aLength;i++) {
  801.         if (i in arr2 && f.call(opt_obj, arr2[i], i, attributes)) {
  802.           return i;
  803.         }
  804.       }
  805.       return-1;
  806.     };
  807.     /**
  808.      * @param {?} opt_attributes
  809.      * @param {?} name
  810.      * @return {?}
  811.      */
  812.     self.fb = function(opt_attributes, name) {
  813.       return 0 <= (0, self.Xa)(opt_attributes, name);
  814.     };
  815.     /**
  816.      * @param {Array} keepData
  817.      * @return {?}
  818.      */
  819.     self.gb = function(keepData) {
  820.       return 0 == keepData.length;
  821.     };
  822.     /**
  823.      * @param {?} attributes
  824.      * @return {undefined}
  825.      */
  826.     self.hb = function(attributes) {
  827.       if (!self.ka(attributes)) {
  828.         /** @type {number} */
  829.         var macKey = attributes.length - 1;
  830.         for (;0 <= macKey;macKey--) {
  831.           delete attributes[macKey];
  832.         }
  833.       }
  834.       /** @type {number} */
  835.       attributes.length = 0;
  836.     };
  837.     /**
  838.      * @param {Array} attributes
  839.      * @param {?} k
  840.      * @return {undefined}
  841.      */
  842.     self.ib = function(attributes, k) {
  843.       if (!self.fb(attributes, k)) {
  844.         attributes.push(k);
  845.       }
  846.     };
  847.     /**
  848.      * @param {?} bytes
  849.      * @param {?} first
  850.      * @return {?}
  851.      */
  852.     self.kb = function(bytes, first) {
  853.       var d = (0, self.Xa)(bytes, first);
  854.       var ls;
  855.       if (ls = 0 <= d) {
  856.         self.jb(bytes, d);
  857.       }
  858.       return ls;
  859.     };
  860.     /**
  861.      * @param {?} string
  862.      * @param {number} val
  863.      * @return {undefined}
  864.      */
  865.     self.jb = function(string, val) {
  866.       self.Wa.splice.call(string, val, 1);
  867.     };
  868.     /**
  869.      * @param {?} dataAndEvents
  870.      * @return {?}
  871.      */
  872.     self.lb = function(dataAndEvents) {
  873.       return self.Wa.concat.apply(self.Wa, arguments);
  874.     };
  875.     /**
  876.      * @param {?} properties
  877.      * @return {?}
  878.      */
  879.     self.nb = function(properties) {
  880.       var length = properties.length;
  881.       if (0 < length) {
  882.         /** @type {Array} */
  883.         var result = Array(length);
  884.         /** @type {number} */
  885.         var i = 0;
  886.         for (;i < length;i++) {
  887.           result[i] = properties[i];
  888.         }
  889.         return result;
  890.       }
  891.       return[];
  892.     };
  893.     /**
  894.      * @param {Array} obj
  895.      * @param {?} a
  896.      * @return {undefined}
  897.      */
  898.     self.ob = function(obj, a) {
  899.       /** @type {number} */
  900.       var i = 1;
  901.       for (;i < arguments.length;i++) {
  902.         var def = arguments[i];
  903.         if (self.la(def)) {
  904.           var n = obj.length || 0;
  905.           var step = def.length || 0;
  906.           obj.length = n + step;
  907.           /** @type {number} */
  908.           var k = 0;
  909.           for (;k < step;k++) {
  910.             obj[n + k] = def[k];
  911.           }
  912.         } else {
  913.           obj.push(def);
  914.         }
  915.       }
  916.     };
  917.     /**
  918.      * @param {?} recurring
  919.      * @param {number} g
  920.      * @param {number} v33
  921.      * @param {Array} dataAndEvents
  922.      * @return {?}
  923.      */
  924.     self.qb = function(recurring, g, v33, dataAndEvents) {
  925.       return self.Wa.splice.apply(recurring, self.pb(arguments, 1));
  926.     };
  927.     /**
  928.      * @param {?} opt_attributes
  929.      * @param {Object} name
  930.      * @param {(boolean|number|string)} attributes
  931.      * @return {?}
  932.      */
  933.     self.pb = function(opt_attributes, name, attributes) {
  934.       return 2 >= arguments.length ? self.Wa.slice.call(opt_attributes, name) : self.Wa.slice.call(opt_attributes, name, attributes);
  935.     };
  936.     /**
  937.      * @param {Array} obj
  938.      * @param {Object} thisObj
  939.      * @param {Function} type
  940.      * @return {undefined}
  941.      */
  942.     self.sb = function(obj, thisObj, type) {
  943.       thisObj = thisObj || obj;
  944.       /**
  945.        * @param {?} attributes
  946.        * @return {?}
  947.        */
  948.       var fx = function(attributes) {
  949.         return self.qa(attributes) ? "o" + self.ra(attributes) : (typeof attributes).charAt(0) + attributes;
  950.       };
  951.       type = type || fx;
  952.       fx = {};
  953.       /** @type {number} */
  954.       var pos = 0;
  955.       /** @type {number} */
  956.       var i = 0;
  957.       for (;i < obj.length;) {
  958.         var item = obj[i++];
  959.         var name = type(item);
  960.         if (!Object.prototype.hasOwnProperty.call(fx, name)) {
  961.           /** @type {boolean} */
  962.           fx[name] = true;
  963.           thisObj[pos++] = item;
  964.         }
  965.       }
  966.       /** @type {number} */
  967.       thisObj.length = pos;
  968.     };
  969.     /**
  970.      * @param {Array} arr
  971.      * @param {string} opt_compareFn
  972.      * @return {undefined}
  973.      */
  974.     self.ub = function(arr, opt_compareFn) {
  975.       arr.sort(opt_compareFn || self.tb);
  976.     };
  977.     /**
  978.      * @param {Array} arr
  979.      * @param {string} v11
  980.      * @return {undefined}
  981.      */
  982.     self.waa = function(arr, v11) {
  983.       /** @type {number} */
  984.       var i = 0;
  985.       for (;i < arr.length;i++) {
  986.         arr[i] = {
  987.           index : i,
  988.           value : arr[i]
  989.         };
  990.       }
  991.       var valueCompareFn = v11 || self.tb;
  992.       self.ub(arr, function(obj1, obj2) {
  993.         return valueCompareFn(obj1.value, obj2.value) || obj1.index - obj2.index;
  994.       });
  995.       /** @type {number} */
  996.       i = 0;
  997.       for (;i < arr.length;i++) {
  998.         arr[i] = arr[i].value;
  999.       }
  1000.     };
  1001.     /**
  1002.      * @param {(boolean|number|string)} a
  1003.      * @param {(boolean|number|string)} b
  1004.      * @return {?}
  1005.      */
  1006.     self.tb = function(a, b) {
  1007.       return a > b ? 1 : a < b ? -1 : 0;
  1008.     };
  1009.     /**
  1010.      * @param {Array} params
  1011.      * @param {Function} cb
  1012.      * @param {?} _this
  1013.      * @return {?}
  1014.      */
  1015.     self.xaa = function(params, cb, _this) {
  1016.       var paramNames = {};
  1017.       /** @type {number} */
  1018.       var i = 0;
  1019.       for (;i < params.length;i++) {
  1020.         var param = params[i];
  1021.         var p = cb.call(_this, param, i, params);
  1022.         if (self.Uf(p)) {
  1023.           (paramNames[p] || (paramNames[p] = [])).push(param);
  1024.         }
  1025.       }
  1026.       return paramNames;
  1027.     };
  1028.     /**
  1029.      * @param {number} i
  1030.      * @param {number} end1
  1031.      * @param {number} step
  1032.      * @return {?}
  1033.      */
  1034.     self.n6a = function(i, end1, step) {
  1035.       /** @type {Array} */
  1036.       var bProperties = [];
  1037.       /** @type {number} */
  1038.       var start = 0;
  1039.       /** @type {number} */
  1040.       var end = i;
  1041.       step = step || 1;
  1042.       if (void 0 !== end1) {
  1043.         /** @type {number} */
  1044.         start = i;
  1045.         /** @type {number} */
  1046.         end = end1;
  1047.       }
  1048.       if (0 > step * (end - start)) {
  1049.         return[];
  1050.       }
  1051.       if (0 < step) {
  1052.         i = start;
  1053.         for (;i < end;i += step) {
  1054.           bProperties.push(i);
  1055.         }
  1056.       } else {
  1057.         i = start;
  1058.         for (;i > end;i += step) {
  1059.           bProperties.push(i);
  1060.         }
  1061.       }
  1062.       return bProperties;
  1063.     };
  1064.     /**
  1065.      * @param {?} data
  1066.      * @param {number} dataAndEvents
  1067.      * @return {?}
  1068.      */
  1069.     self.vb = function(data, dataAndEvents) {
  1070.       /** @type {Array} */
  1071.       var statesData = [];
  1072.       /** @type {number} */
  1073.       var unlock = 0;
  1074.       for (;unlock < dataAndEvents;unlock++) {
  1075.         statesData[unlock] = data;
  1076.       }
  1077.       return statesData;
  1078.     };
  1079.     /**
  1080.      * @return {undefined}
  1081.      */
  1082.     self.wb = function() {
  1083.       this.Xa = this.Xa;
  1084.       this.Za = this.Za;
  1085.     };
  1086.     /** @type {boolean} */
  1087.     self.wb.prototype.Xa = false;
  1088.     /**
  1089.      * @return {?}
  1090.      */
  1091.     self.wb.prototype.isDisposed = function() {
  1092.       return this.Xa;
  1093.     };
  1094.     /**
  1095.      * @return {undefined}
  1096.      */
  1097.     self.wb.prototype.Ka = function() {
  1098.       if (!this.Xa) {
  1099.         /** @type {boolean} */
  1100.         this.Xa = true;
  1101.         this.Ha();
  1102.       }
  1103.     };
  1104.     /**
  1105.      * @param {?} opt_attributes
  1106.      * @param {Object} name
  1107.      * @return {undefined}
  1108.      */
  1109.     self.v = function(opt_attributes, name) {
  1110.       self.xb(opt_attributes, self.sa(self.yb, name));
  1111.     };
  1112.     /**
  1113.      * @param {?} attributes
  1114.      * @param {Function} fn
  1115.      * @param {?} bind
  1116.      * @return {undefined}
  1117.      */
  1118.     self.xb = function(attributes, fn, bind) {
  1119.       if (attributes.Xa) {
  1120.         fn.call(bind);
  1121.       } else {
  1122.         if (!attributes.Za) {
  1123.           /** @type {Array} */
  1124.           attributes.Za = [];
  1125.         }
  1126.         attributes.Za.push(self.Uf(bind) ? (0, self.p)(fn, bind) : fn);
  1127.       }
  1128.     };
  1129.     /**
  1130.      * @return {undefined}
  1131.      */
  1132.     self.wb.prototype.Ha = function() {
  1133.       if (this.Za) {
  1134.         for (;this.Za.length;) {
  1135.           this.Za.shift()();
  1136.         }
  1137.       }
  1138.     };
  1139.     /**
  1140.      * @param {?} opt_attributes
  1141.      * @return {undefined}
  1142.      */
  1143.     self.yb = function(opt_attributes) {
  1144.       if (opt_attributes) {
  1145.         if ("function" == typeof opt_attributes.Ka) {
  1146.           opt_attributes.Ka();
  1147.         }
  1148.       }
  1149.     };
  1150.     /**
  1151.      * @param {?} opt_attributes
  1152.      * @return {undefined}
  1153.      */
  1154.     self.zb = function(opt_attributes) {
  1155.       /** @type {number} */
  1156.       var i = 0;
  1157.       /** @type {number} */
  1158.       var argLength = arguments.length;
  1159.       for (;i < argLength;++i) {
  1160.         var attributes = arguments[i];
  1161.         if (self.la(attributes)) {
  1162.           self.zb.apply(null, attributes);
  1163.         } else {
  1164.           self.yb(attributes);
  1165.         }
  1166.       }
  1167.     };
  1168.     var runInContext;
  1169.     var createCallback;
  1170.     /**
  1171.      * @return {?}
  1172.      */
  1173.     runInContext = function() {
  1174.       var parent = self.ca.navigator;
  1175.       return parent && (parent = parent.userAgent) ? parent : "";
  1176.     };
  1177.     self.La = runInContext();
  1178.     /**
  1179.      * @param {Object} optgroup
  1180.      * @return {?}
  1181.      */
  1182.     self.Ab = function(optgroup) {
  1183.       return self.Ja(self.La, optgroup);
  1184.     };
  1185.     /**
  1186.      * @param {?} item
  1187.      * @return {?}
  1188.      */
  1189.     createCallback = function(item) {
  1190.       /** @type {RegExp} */
  1191.       var re = RegExp("(\\w[\\w ]+)/([^\\s]+)\\s*(?:\\((.*?)\\))?", "g");
  1192.       /** @type {Array} */
  1193.       var func = [];
  1194.       var found;
  1195.       for (;found = re.exec(item);) {
  1196.         func.push([found[1], found[2], found[3] || void 0]);
  1197.       }
  1198.       return func;
  1199.     };
  1200.     var key;
  1201.     var desc;
  1202.     /**
  1203.      * @param {Object} obj
  1204.      * @param {Function} f
  1205.      * @param {?} opt_this
  1206.      * @return {undefined}
  1207.      */
  1208.     self.hc = function(obj, f, opt_this) {
  1209.       var key;
  1210.       for (key in obj) {
  1211.         f.call(opt_this, obj[key], key, obj);
  1212.       }
  1213.     };
  1214.     /**
  1215.      * @param {?} obj
  1216.      * @param {Function} f
  1217.      * @param {?} opt_this
  1218.      * @return {?}
  1219.      */
  1220.     self.ic = function(obj, f, opt_this) {
  1221.       var copy = {};
  1222.       var key;
  1223.       for (key in obj) {
  1224.         if (f.call(opt_this, obj[key], key, obj)) {
  1225.           copy[key] = obj[key];
  1226.         }
  1227.       }
  1228.       return copy;
  1229.     };
  1230.     /**
  1231.      * @param {Object} obj
  1232.      * @param {Function} f
  1233.      * @param {?} opt_obj
  1234.      * @return {?}
  1235.      */
  1236.     self.Ih = function(obj, f, opt_obj) {
  1237.       var res = {};
  1238.       var key;
  1239.       for (key in obj) {
  1240.         res[key] = f.call(opt_obj, obj[key], key, obj);
  1241.       }
  1242.       return res;
  1243.     };
  1244.     /**
  1245.      * @param {?} opt_attributes
  1246.      * @return {?}
  1247.      */
  1248.     self.jc = function(opt_attributes) {
  1249.       /** @type {number} */
  1250.       var jc = 0;
  1251.       var c;
  1252.       for (c in opt_attributes) {
  1253.         jc++;
  1254.       }
  1255.       return jc;
  1256.     };
  1257.     /**
  1258.      * @param {?} obj
  1259.      * @return {?}
  1260.      */
  1261.     self.kc = function(obj) {
  1262.       /** @type {Array} */
  1263.       var res = [];
  1264.       /** @type {number} */
  1265.       var resLength = 0;
  1266.       var key;
  1267.       for (key in obj) {
  1268.         res[resLength++] = obj[key];
  1269.       }
  1270.       return res;
  1271.     };
  1272.     /**
  1273.      * @param {?} first
  1274.      * @return {?}
  1275.      */
  1276.     self.lc = function(first) {
  1277.       /** @type {Array} */
  1278.       var res = [];
  1279.       /** @type {number} */
  1280.       var resLength = 0;
  1281.       var key;
  1282.       for (key in first) {
  1283.         /** @type {string} */
  1284.         res[resLength++] = key;
  1285.       }
  1286.       return res;
  1287.     };
  1288.     /**
  1289.      * @param {Object} index
  1290.      * @param {?} k
  1291.      * @return {?}
  1292.      */
  1293.     key = function(index, k) {
  1294.       return k in index;
  1295.     };
  1296.     /**
  1297.      * @param {?} a
  1298.      * @return {?}
  1299.      */
  1300.     self.mc = function(a) {
  1301.       var prefix;
  1302.       for (prefix in a) {
  1303.         return false;
  1304.       }
  1305.       return true;
  1306.     };
  1307.     /**
  1308.      * @param {Object} arr2
  1309.      * @param {?} i
  1310.      * @return {undefined}
  1311.      */
  1312.     self.nc = function(arr2, i) {
  1313.       if (i in arr2) {
  1314.         delete arr2[i];
  1315.       }
  1316.     };
  1317.     /**
  1318.      * @param {Object} benchmarks
  1319.      * @param {string} name
  1320.      * @param {?} ref
  1321.      * @return {undefined}
  1322.      */
  1323.     self.Taa = function(benchmarks, name, ref) {
  1324.       if (name in benchmarks) {
  1325.         throw Error("b`" + name);
  1326.       }
  1327.       benchmarks[name] = ref;
  1328.     };
  1329.     /**
  1330.      * @param {Object} meta
  1331.      * @param {?} a
  1332.      * @param {?} dataAndEvents
  1333.      * @return {?}
  1334.      */
  1335.     self.oc = function(meta, a, dataAndEvents) {
  1336.       return a in meta ? meta[a] : dataAndEvents;
  1337.     };
  1338.     /**
  1339.      * @param {Object} attrs
  1340.      * @param {Object} value
  1341.      * @return {?}
  1342.      */
  1343.     self.wga = function(attrs, value) {
  1344.       var key;
  1345.       for (key in attrs) {
  1346.         if (!(key in value) || attrs[key] !== value[key]) {
  1347.           return false;
  1348.         }
  1349.       }
  1350.       for (key in value) {
  1351.         if (!(key in attrs)) {
  1352.           return false;
  1353.         }
  1354.       }
  1355.       return true;
  1356.     };
  1357.     /**
  1358.      * @param {Object} extended
  1359.      * @return {?}
  1360.      */
  1361.     self.pc = function(extended) {
  1362.       var original = {};
  1363.       var key;
  1364.       for (key in extended) {
  1365.         original[key] = extended[key];
  1366.       }
  1367.       return original;
  1368.     };
  1369.     /**
  1370.      * @param {Object} obj
  1371.      * @return {?}
  1372.      */
  1373.     self.qc = function(obj) {
  1374.       var transposed = {};
  1375.       var key;
  1376.       for (key in obj) {
  1377.         /** @type {string} */
  1378.         transposed[obj[key]] = key;
  1379.       }
  1380.       return transposed;
  1381.     };
  1382.     /** @type {Array.<string>} */
  1383.     desc = "constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
  1384.     /**
  1385.      * @param {?} target
  1386.      * @param {?} array
  1387.      * @return {undefined}
  1388.      */
  1389.     self.rc = function(target, array) {
  1390.       var key;
  1391.       var source;
  1392.       /** @type {number} */
  1393.       var i = 1;
  1394.       for (;i < arguments.length;i++) {
  1395.         source = arguments[i];
  1396.         for (key in source) {
  1397.           target[key] = source[key];
  1398.         }
  1399.         /** @type {number} */
  1400.         var j = 0;
  1401.         for (;j < desc.length;j++) {
  1402.           key = desc[j];
  1403.           if (Object.prototype.hasOwnProperty.call(source, key)) {
  1404.             target[key] = source[key];
  1405.           }
  1406.         }
  1407.       }
  1408.     };
  1409.     /**
  1410.      * @param {?} dataAndEvents
  1411.      * @return {?}
  1412.      */
  1413.     self.sc = function(dataAndEvents) {
  1414.       /** @type {number} */
  1415.       var argLength = arguments.length;
  1416.       if (1 == argLength && self.ka(arguments[0])) {
  1417.         return self.sc.apply(null, arguments[0]);
  1418.       }
  1419.       if (argLength % 2) {
  1420.         throw Error("c");
  1421.       }
  1422.       var rv = {};
  1423.       /** @type {number} */
  1424.       var i = 0;
  1425.       for (;i < argLength;i += 2) {
  1426.         rv[arguments[i]] = arguments[i + 1];
  1427.       }
  1428.       return rv;
  1429.     };
  1430.     /**
  1431.      * @param {?} opt_attributes
  1432.      * @return {?}
  1433.      */
  1434.     self.tc = function(opt_attributes) {
  1435.       /** @type {number} */
  1436.       var argLength = arguments.length;
  1437.       if (1 == argLength && self.ka(arguments[0])) {
  1438.         return self.tc.apply(null, arguments[0]);
  1439.       }
  1440.       var wkw = {};
  1441.       /** @type {number} */
  1442.       var i = 0;
  1443.       for (;i < argLength;i++) {
  1444.         /** @type {boolean} */
  1445.         wkw[arguments[i]] = true;
  1446.       }
  1447.       return wkw;
  1448.     };
  1449.     var detect;
  1450.     var span_;
  1451.     /**
  1452.      * @return {?}
  1453.      */
  1454.     self.Bb = function() {
  1455.       return self.Ab("Opera") || self.Ab("OPR");
  1456.     };
  1457.     /**
  1458.      * @return {?}
  1459.      */
  1460.     self.Eb = function() {
  1461.       return(self.Ab("Chrome") || self.Ab("CriOS")) && (!self.Bb() && !self.Ab("Edge"));
  1462.     };
  1463.     /**
  1464.      * @return {?}
  1465.      */
  1466.     self.Cb = function() {
  1467.       return self.Ab("Trident") || self.Ab("MSIE");
  1468.     };
  1469.     /**
  1470.      * @return {?}
  1471.      */
  1472.     self.wh = function() {
  1473.       return self.Ab("Firefox");
  1474.     };
  1475.     /**
  1476.      * @return {?}
  1477.      */
  1478.     self.Db = function() {
  1479.       return self.Ab("Safari") && !(self.Eb() || (self.Ab("Coast") || (self.Bb() || (self.Ab("Edge") || (self.Ab("Silk") || self.Ab("Android"))))));
  1480.     };
  1481.     /**
  1482.      * @return {?}
  1483.      */
  1484.     self.Ik = function() {
  1485.       return self.Ab("Android") && !(self.Eb() || (self.wh() || (self.Bb() || self.Ab("Silk"))));
  1486.     };
  1487.     /**
  1488.      * @return {?}
  1489.      */
  1490.     detect = function() {
  1491.       /**
  1492.        * @param {(Array|string)} attribute
  1493.        * @return {?}
  1494.        */
  1495.       function validator(attribute) {
  1496.         attribute = self.eb(attribute, i);
  1497.         return a[attribute] || "";
  1498.       }
  1499.       var callback = self.La;
  1500.       if (self.Cb()) {
  1501.         return span_(callback);
  1502.       }
  1503.       callback = createCallback(callback);
  1504.       var a = {};
  1505.       (0, self.u)(callback, function(b) {
  1506.         a[b[0]] = b[1];
  1507.       });
  1508.       var i = self.sa(key, a);
  1509.       return self.Bb() ? validator(["Version", "Opera", "OPR"]) : self.Ab("Edge") ? validator(["Edge"]) : self.Eb() ? validator(["Chrome", "CriOS"]) : (callback = callback[2]) && callback[1] || "";
  1510.     };
  1511.     /**
  1512.      * @param {number} opt_attributes
  1513.      * @return {?}
  1514.      */
  1515.     self.Fb = function(opt_attributes) {
  1516.       return 0 <= self.Pa(detect(), opt_attributes);
  1517.     };
  1518.     /**
  1519.      * @param {Object} style
  1520.      * @return {?}
  1521.      */
  1522.     span_ = function(style) {
  1523.       /** @type {(Array.<string>|null)} */
  1524.       var match = /rv: *([\d\.]*)/.exec(style);
  1525.       if (match && match[1]) {
  1526.         return match[1];
  1527.       }
  1528.       /** @type {string} */
  1529.       match = "";
  1530.       /** @type {(Array.<string>|null)} */
  1531.       var target = /MSIE +([\d\.]+)/.exec(style);
  1532.       if (target && target[1]) {
  1533.         if (style = /Trident\/(\d.\d)/.exec(style), "7.0" == target[1]) {
  1534.           if (style && style[1]) {
  1535.             switch(style[1]) {
  1536.               case "4.0":
  1537.                 /** @type {string} */
  1538.                 match = "8.0";
  1539.                 break;
  1540.               case "5.0":
  1541.                 /** @type {string} */
  1542.                 match = "9.0";
  1543.                 break;
  1544.               case "6.0":
  1545.                 /** @type {string} */
  1546.                 match = "10.0";
  1547.                 break;
  1548.               case "7.0":
  1549.                 /** @type {string} */
  1550.                 match = "11.0";
  1551.             }
  1552.           } else {
  1553.             /** @type {string} */
  1554.             match = "7.0";
  1555.           }
  1556.         } else {
  1557.           /** @type {string} */
  1558.           match = target[1];
  1559.         }
  1560.       }
  1561.       return match;
  1562.     };
  1563.     var initEvent;
  1564.     /**
  1565.      * @return {?}
  1566.      */
  1567.     self.ch = function() {
  1568.       return self.Ab("Presto");
  1569.     };
  1570.     /**
  1571.      * @return {?}
  1572.      */
  1573.     initEvent = function() {
  1574.       return self.Ab("Trident") || self.Ab("MSIE");
  1575.     };
  1576.     /**
  1577.      * @return {?}
  1578.      */
  1579.     self.ta = function() {
  1580.       return self.Ja(self.La.toLowerCase(), "webkit") && !self.Ab("Edge");
  1581.     };
  1582.     /**
  1583.      * @return {?}
  1584.      */
  1585.     self.Hb = function() {
  1586.       return self.Ab("Gecko") && (!self.ta() && (!initEvent() && !self.Ab("Edge")));
  1587.     };
  1588.     /**
  1589.      * @return {?}
  1590.      */
  1591.     self.jf = function() {
  1592.       return self.Ab("Android");
  1593.     };
  1594.     /**
  1595.      * @return {?}
  1596.      */
  1597.     self.kf = function() {
  1598.       return self.Ab("iPhone") && (!self.Ab("iPod") && !self.Ab("iPad"));
  1599.     };
  1600.     /**
  1601.      * @return {?}
  1602.      */
  1603.     self.dh = function() {
  1604.       return self.Ab("iPad");
  1605.     };
  1606.     /**
  1607.      * @return {?}
  1608.      */
  1609.     self.mf = function() {
  1610.       return self.kf() || (self.dh() || self.Ab("iPod"));
  1611.     };
  1612.     /**
  1613.      * @return {?}
  1614.      */
  1615.     self.Faa = function() {
  1616.       var match = self.La;
  1617.       /** @type {string} */
  1618.       var ret = "";
  1619.       if (self.Ab("Windows")) {
  1620.         /** @type {RegExp} */
  1621.         ret = /Windows (?:NT|Phone) ([0-9.]+)/;
  1622.         /** @type {string} */
  1623.         ret = (match = ret.exec(match)) ? match[1] : "0.0";
  1624.       } else {
  1625.         if (self.mf()) {
  1626.           /** @type {RegExp} */
  1627.           ret = /(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/;
  1628.           /** @type {(null|string)} */
  1629.           ret = (match = ret.exec(match)) && match[1].replace(/_/g, ".");
  1630.         } else {
  1631.           if (self.Ab("Macintosh")) {
  1632.             /** @type {RegExp} */
  1633.             ret = /Mac OS X ([0-9_.]+)/;
  1634.             /** @type {string} */
  1635.             ret = (match = ret.exec(match)) ? match[1].replace(/_/g, ".") : "10";
  1636.           } else {
  1637.             if (self.jf()) {
  1638.               /** @type {RegExp} */
  1639.               ret = /Android\s+([^\);]+)(\)|;)/;
  1640.               /** @type {(null|string)} */
  1641.               ret = (match = ret.exec(match)) && match[1];
  1642.             } else {
  1643.               if (self.Ab("CrOS")) {
  1644.                 /** @type {RegExp} */
  1645.                 ret = /(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/;
  1646.                 /** @type {(null|string)} */
  1647.                 ret = (match = ret.exec(match)) && match[1];
  1648.               }
  1649.             }
  1650.           }
  1651.         }
  1652.       }
  1653.       return ret || "";
  1654.     };
  1655.     /**
  1656.      * @param {?} walkers
  1657.      * @return {?}
  1658.      */
  1659.     self.nf = function(walkers) {
  1660.       return 0 <= self.Pa(self.Faa(), walkers);
  1661.     };
  1662.     var prompt;
  1663.     var iframeCssFixes;
  1664.     var collection;
  1665.     var doc;
  1666.     self.Mb = self.Bb();
  1667.     self.Aa = self.Cb();
  1668.     self.fa = self.Ab("Edge");
  1669.     self.Ob = self.Hb();
  1670.     self.Pb = self.ta();
  1671.     self.Qb = self.Pb && self.Ab("Mobile");
  1672.     self.Ib = self.Ab("Macintosh");
  1673.     self.Jb = self.Ab("Windows");
  1674.     self.vaa = self.Ab("Linux") || self.Ab("CrOS");
  1675.     self.Kb = self.jf();
  1676.     self.Baa = self.kf();
  1677.     self.Daa = self.dh();
  1678.     /**
  1679.      * @return {?}
  1680.      */
  1681.     prompt = function() {
  1682.       var xhtml = self.La;
  1683.       if (self.Ob) {
  1684.         return/rv\:([^\);]+)(\)|;)/.exec(xhtml);
  1685.       }
  1686.       if (self.fa) {
  1687.         return/Edge\/([\d\.]+)/.exec(xhtml);
  1688.       }
  1689.       if (self.Aa) {
  1690.         return/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(xhtml);
  1691.       }
  1692.       if (self.Pb) {
  1693.         return/WebKit\/(\S+)/.exec(xhtml);
  1694.       }
  1695.     };
  1696.     /**
  1697.      * @return {?}
  1698.      */
  1699.     iframeCssFixes = function() {
  1700.       var doc = self.ca.document;
  1701.       return doc ? doc.documentMode : void 0;
  1702.     };
  1703.     self.Tb = function() {
  1704.       if (self.Mb && self.ca.opera) {
  1705.         var v = self.ca.opera.version;
  1706.         return self.pa(v) ? v() : v;
  1707.       }
  1708.       /** @type {string} */
  1709.       v = "";
  1710.       var r = prompt();
  1711.       if (r) {
  1712.         v = r ? r[1] : "";
  1713.       }
  1714.       return self.Aa && (r = iframeCssFixes(), r > (0, window.parseFloat)(v)) ? String(r) : v;
  1715.     }();
  1716.     collection = {};
  1717.     /**
  1718.      * @param {string} method
  1719.      * @return {?}
  1720.      */
  1721.     self.Ub = function(method) {
  1722.       return collection[method] || (collection[method] = 0 <= self.Pa(self.Tb, method));
  1723.     };
  1724.     doc = self.ca.document;
  1725.     self.Jaa = doc && self.Aa ? iframeCssFixes() || ("CSS1Compat" == doc.compatMode ? (0, window.parseInt)(self.Tb, 10) : 5) : void 0;
  1726.     /** @type {boolean} */
  1727.     var endInstead = !self.Aa || 9 <= self.Jaa;
  1728.     var Maa = !self.Ob && !self.Aa || (self.Aa && 9 <= self.Jaa || self.Ob && self.Ub("1.9.1"));
  1729.     var innerText = self.Aa && !self.Ub("9");
  1730.     var Oaa = self.Aa || (self.Mb || self.Pb);
  1731.     /**
  1732.      * @return {undefined}
  1733.      */
  1734.     self.on = function() {
  1735.       /** @type {string} */
  1736.       this.$ = "";
  1737.       this.ia = self.Hqa;
  1738.     };
  1739.     /** @type {boolean} */
  1740.     self.on.prototype.qu = true;
  1741.     self.Hqa = {};
  1742.     /**
  1743.      * @return {?}
  1744.      */
  1745.     self.on.prototype.yo = function() {
  1746.       return this.$;
  1747.     };
  1748.     /**
  1749.      * @param {(Object|string)} value
  1750.      * @return {?}
  1751.      */
  1752.     self.tda = function(value) {
  1753.       var element = new self.on;
  1754.       /** @type {(Object|string)} */
  1755.       element.$ = value;
  1756.       return element;
  1757.     };
  1758.     self.Jqa = self.tda("");
  1759.     /** @type {RegExp} */
  1760.     self.zqa = RegExp("[A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]");
  1761.     /** @type {RegExp} */
  1762.     self.Aqa = RegExp("^[^A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]*[\u0591-\u06ef\u06fa-\u07ff\u200f\ufb1d-\ufdff\ufe70-\ufefc]");
  1763.     /** @type {RegExp} */
  1764.     self.Cqa = RegExp("[A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff][^\u0591-\u06ef\u06fa-\u07ff\u200f\ufb1d-\ufdff\ufe70-\ufefc]*$");
  1765.     /** @type {RegExp} */
  1766.     self.Dqa = RegExp("[\u0591-\u06ef\u06fa-\u07ff\u200f\ufb1d-\ufdff\ufe70-\ufefc][^A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]*$");
  1767.     var rchecked;
  1768.     var TEXT;
  1769.     /**
  1770.      * @return {undefined}
  1771.      */
  1772.     self.pn = function() {
  1773.       /** @type {string} */
  1774.       this.$ = "";
  1775.       this.ia = TEXT;
  1776.     };
  1777.     /** @type {boolean} */
  1778.     self.pn.prototype.qu = true;
  1779.     /**
  1780.      * @return {?}
  1781.      */
  1782.     self.pn.prototype.yo = function() {
  1783.       return this.$;
  1784.     };
  1785.     /** @type {boolean} */
  1786.     self.pn.prototype.aL = true;
  1787.     /**
  1788.      * @return {?}
  1789.      */
  1790.     self.pn.prototype.Vq = function() {
  1791.       return 1;
  1792.     };
  1793.     /**
  1794.      * @param {Object} item
  1795.      * @return {?}
  1796.      */
  1797.     self.ysa = function(item) {
  1798.       return item instanceof self.pn && (item.constructor === self.pn && item.ia === TEXT) ? item.$ : "type_error:SafeUrl";
  1799.     };
  1800.     /** @type {RegExp} */
  1801.     rchecked = /^(?:(?:https?|mailto|ftp):|[^&:/?#]*(?:[/?#]|$))/i;
  1802.     /**
  1803.      * @param {(Object|string)} value
  1804.      * @return {?}
  1805.      */
  1806.     self.qra = function(value) {
  1807.       if (value instanceof self.pn) {
  1808.         return value;
  1809.       }
  1810.       value = value.qu ? value.yo() : String(value);
  1811.       if (!rchecked.test(value)) {
  1812.         /** @type {string} */
  1813.         value = "about:invalid#zClosurez";
  1814.       }
  1815.       var element = new self.pn;
  1816.       /** @type {(Object|string)} */
  1817.       element.$ = value;
  1818.       return element;
  1819.     };
  1820.     TEXT = {};
  1821.     var column;
  1822.     /**
  1823.      * @return {undefined}
  1824.      */
  1825.     self.qn = function() {
  1826.       /** @type {string} */
  1827.       this.$ = "";
  1828.       this.ga = column;
  1829.       /** @type {null} */
  1830.       this.ia = null;
  1831.     };
  1832.     /** @type {boolean} */
  1833.     self.qn.prototype.aL = true;
  1834.     /**
  1835.      * @return {?}
  1836.      */
  1837.     self.qn.prototype.Vq = function() {
  1838.       return this.ia;
  1839.     };
  1840.     /** @type {boolean} */
  1841.     self.qn.prototype.qu = true;
  1842.     /**
  1843.      * @return {?}
  1844.      */
  1845.     self.qn.prototype.yo = function() {
  1846.       return this.$;
  1847.     };
  1848.     /**
  1849.      * @param {Object} item
  1850.      * @return {?}
  1851.      */
  1852.     self.Lo = function(item) {
  1853.       return item instanceof self.qn && (item.constructor === self.qn && item.ga === column) ? item.$ : "type_error:SafeHtml";
  1854.     };
  1855.     /**
  1856.      * @param {Text} arg
  1857.      * @return {?}
  1858.      */
  1859.     self.xsa = function(arg) {
  1860.       if (arg instanceof self.qn) {
  1861.         return arg;
  1862.       }
  1863.       /** @type {null} */
  1864.       var recurring = null;
  1865.       if (arg.aL) {
  1866.         recurring = arg.Vq();
  1867.       }
  1868.       arg = self.Ga(arg.qu ? arg.yo() : String(arg));
  1869.       return self.lh(arg, recurring);
  1870.     };
  1871.     column = {};
  1872.     /**
  1873.      * @param {string} value
  1874.      * @param {number} recurring
  1875.      * @return {?}
  1876.      */
  1877.     self.lh = function(value, recurring) {
  1878.       var element = new self.qn;
  1879.       /** @type {string} */
  1880.       element.$ = value;
  1881.       /** @type {number} */
  1882.       element.ia = recurring;
  1883.       return element;
  1884.     };
  1885.     self.lh("<!DOCTYPE html>", 0);
  1886.     self.tn = self.lh("", 0);
  1887.     /**
  1888.      * @param {Element} style
  1889.      * @param {Object} x
  1890.      * @return {undefined}
  1891.      */
  1892.     self.Mo = function(style, x) {
  1893.       style.innerHTML = self.Lo(x);
  1894.     };
  1895.     /**
  1896.      * @param {?} value
  1897.      * @param {?} min
  1898.      * @param {?} l2
  1899.      * @return {?}
  1900.      */
  1901.     self.cc = function(value, min, l2) {
  1902.       return Math.min(Math.max(value, min), l2);
  1903.     };
  1904.     /**
  1905.      * @param {number} a
  1906.      * @param {number} b
  1907.      * @param {number} x
  1908.      * @return {?}
  1909.      */
  1910.     self.Sb = function(a, b, x) {
  1911.       return a + x * (b - a);
  1912.     };
  1913.     self.Nk = Math.sign || function(date2) {
  1914.       return 0 < date2 ? 1 : 0 > date2 ? -1 : date2;
  1915.     };
  1916.     /**
  1917.      * @param {?} x
  1918.      * @param {?} y
  1919.      * @return {undefined}
  1920.      */
  1921.     self.dc = function(x, y) {
  1922.       this.x = self.Uf(x) ? x : 0;
  1923.       this.y = self.Uf(y) ? y : 0;
  1924.     };
  1925.     /**
  1926.      * @return {?}
  1927.      */
  1928.     self.dc.prototype.clone = function() {
  1929.       return new self.dc(this.x, this.y);
  1930.     };
  1931.     /**
  1932.      * @param {Object} a
  1933.      * @param {Object} b
  1934.      * @return {?}
  1935.      */
  1936.     self.pua = function(a, b) {
  1937.       return a == b ? true : a && b ? a.x == b.x && a.y == b.y : false;
  1938.     };
  1939.     /**
  1940.      * @param {?} $point_2
  1941.      * @param {?} $point_1
  1942.      * @return {?}
  1943.      */
  1944.     self.$l = function($point_2, $point_1) {
  1945.       /** @type {number} */
  1946.       var z0 = $point_2.x - $point_1.x;
  1947.       /** @type {number} */
  1948.       var z1 = $point_2.y - $point_1.y;
  1949.       return Math.sqrt(z0 * z0 + z1 * z1);
  1950.     };
  1951.     /**
  1952.      * @param {?} $point_2
  1953.      * @param {?} $point_1
  1954.      * @return {?}
  1955.      */
  1956.     self.Gk = function($point_2, $point_1) {
  1957.       return new self.dc($point_2.x - $point_1.x, $point_2.y - $point_1.y);
  1958.     };
  1959.     self.h = self.dc.prototype;
  1960.     /**
  1961.      * @return {?}
  1962.      */
  1963.     self.h.ceil = function() {
  1964.       /** @type {number} */
  1965.       this.x = Math.ceil(this.x);
  1966.       /** @type {number} */
  1967.       this.y = Math.ceil(this.y);
  1968.       return this;
  1969.     };
  1970.     /**
  1971.      * @return {?}
  1972.      */
  1973.     self.h.floor = function() {
  1974.       /** @type {number} */
  1975.       this.x = Math.floor(this.x);
  1976.       /** @type {number} */
  1977.       this.y = Math.floor(this.y);
  1978.       return this;
  1979.     };
  1980.     /**
  1981.      * @return {?}
  1982.      */
  1983.     self.h.round = function() {
  1984.       /** @type {number} */
  1985.       this.x = Math.round(this.x);
  1986.       /** @type {number} */
  1987.       this.y = Math.round(this.y);
  1988.       return this;
  1989.     };
  1990.     /**
  1991.      * @param {?} v
  1992.      * @param {?} y
  1993.      * @return {?}
  1994.      */
  1995.     self.h.translate = function(v, y) {
  1996.       if (v instanceof self.dc) {
  1997.         this.x += v.x;
  1998.         this.y += v.y;
  1999.       } else {
  2000.         this.x += v;
  2001.         if (self.oa(y)) {
  2002.           this.y += y;
  2003.         }
  2004.       }
  2005.       return this;
  2006.     };
  2007.     /**
  2008.      * @param {number} f
  2009.      * @param {number} v
  2010.      * @return {?}
  2011.      */
  2012.     self.h.scale = function(f, v) {
  2013.       var n = self.oa(v) ? v : f;
  2014.       this.x *= f;
  2015.       this.y *= n;
  2016.       return this;
  2017.     };
  2018.     /**
  2019.      * @param {?} pixelWidth
  2020.      * @param {?} pixelHeight
  2021.      * @return {undefined}
  2022.      */
  2023.     self.ec = function(pixelWidth, pixelHeight) {
  2024.       this.width = pixelWidth;
  2025.       this.height = pixelHeight;
  2026.     };
  2027.     /**
  2028.      * @param {Object} a
  2029.      * @param {Object} b
  2030.      * @return {?}
  2031.      */
  2032.     self.gc = function(a, b) {
  2033.       return a == b ? true : a && b ? a.width == b.width && a.height == b.height : false;
  2034.     };
  2035.     self.h = self.ec.prototype;
  2036.     /**
  2037.      * @return {?}
  2038.      */
  2039.     self.h.clone = function() {
  2040.       return new self.ec(this.width, this.height);
  2041.     };
  2042.     /**
  2043.      * @return {?}
  2044.      */
  2045.     self.h.gJ = function() {
  2046.       return this.width / this.height;
  2047.     };
  2048.     /**
  2049.      * @return {?}
  2050.      */
  2051.     self.h.isEmpty = function() {
  2052.       return!(this.width * this.height);
  2053.     };
  2054.     /**
  2055.      * @return {?}
  2056.      */
  2057.     self.h.ceil = function() {
  2058.       /** @type {number} */
  2059.       this.width = Math.ceil(this.width);
  2060.       /** @type {number} */
  2061.       this.height = Math.ceil(this.height);
  2062.       return this;
  2063.     };
  2064.     /**
  2065.      * @return {?}
  2066.      */
  2067.     self.h.floor = function() {
  2068.       /** @type {number} */
  2069.       this.width = Math.floor(this.width);
  2070.       /** @type {number} */
  2071.       this.height = Math.floor(this.height);
  2072.       return this;
  2073.     };
  2074.     /**
  2075.      * @return {?}
  2076.      */
  2077.     self.h.round = function() {
  2078.       /** @type {number} */
  2079.       this.width = Math.round(this.width);
  2080.       /** @type {number} */
  2081.       this.height = Math.round(this.height);
  2082.       return this;
  2083.     };
  2084.     /**
  2085.      * @param {number} sx
  2086.      * @param {number} opt_sy
  2087.      * @return {?}
  2088.      */
  2089.     self.h.scale = function(sx, opt_sy) {
  2090.       var sy = self.oa(opt_sy) ? opt_sy : sx;
  2091.       this.width *= sx;
  2092.       this.height *= sy;
  2093.       return this;
  2094.     };
  2095.     var names;
  2096.     var getWindowSize;
  2097.     var offset;
  2098.     var ready;
  2099.     var setText;
  2100.     var h;
  2101.     var skipEmptyTextNodes;
  2102.     var IFRAME;
  2103.     var tmp;
  2104.     var makeArray;
  2105.     /**
  2106.      * @param {?} n
  2107.      * @return {?}
  2108.      */
  2109.     self.wc = function(n) {
  2110.       return n ? new self.uc(self.vc(n)) : hasMembers || (hasMembers = new self.uc);
  2111.     };
  2112.     /**
  2113.      * @param {?} optgroup
  2114.      * @return {?}
  2115.      */
  2116.     self.x = function(optgroup) {
  2117.       return self.xc(window.document, optgroup);
  2118.     };
  2119.     /**
  2120.      * @param {?} opt_attributes
  2121.      * @param {?} attributes
  2122.      * @return {?}
  2123.      */
  2124.     self.xc = function(opt_attributes, attributes) {
  2125.       return self.ma(attributes) ? opt_attributes.getElementById(attributes) : attributes;
  2126.     };
  2127.     /**
  2128.      * @param {Object} optgroup
  2129.      * @return {?}
  2130.      */
  2131.     self.yc = function(optgroup) {
  2132.       return self.xc(window.document, optgroup);
  2133.     };
  2134.     /**
  2135.      * @param {?} opt_attributes
  2136.      * @param {Object} name
  2137.      * @param {Object} attributes
  2138.      * @return {?}
  2139.      */
  2140.     self.Ac = function(opt_attributes, name, attributes) {
  2141.       return self.zc(window.document, opt_attributes, name, attributes);
  2142.     };
  2143.     /**
  2144.      * @param {string} name
  2145.      * @param {Node} b
  2146.      * @return {?}
  2147.      */
  2148.     self.y = function(name, b) {
  2149.       var parent = b || window.document;
  2150.       return parent.querySelectorAll && parent.querySelector ? parent.querySelectorAll("." + name) : self.zc(window.document, "*", name, b);
  2151.     };
  2152.     /**
  2153.      * @param {?} attributes
  2154.      * @param {Node} ctx
  2155.      * @return {?}
  2156.      */
  2157.     self.z = function(attributes, ctx) {
  2158.       var context = ctx || window.document;
  2159.       /** @type {null} */
  2160.       var d = null;
  2161.       if (context.getElementsByClassName) {
  2162.         d = context.getElementsByClassName(attributes)[0];
  2163.       } else {
  2164.         if (context.querySelectorAll && context.querySelector) {
  2165.           d = context.querySelector("." + attributes);
  2166.         } else {
  2167.           d = self.zc(window.document, "*", attributes, ctx)[0];
  2168.         }
  2169.       }
  2170.       return d || null;
  2171.     };
  2172.     /**
  2173.      * @param {Object} root
  2174.      * @param {string} tagName
  2175.      * @param {?} attributes
  2176.      * @param {Object} args
  2177.      * @return {?}
  2178.      */
  2179.     self.zc = function(root, tagName, attributes, args) {
  2180.       root = args || root;
  2181.       tagName = tagName && "*" != tagName ? tagName.toUpperCase() : "";
  2182.       if (root.querySelectorAll && (root.querySelector && (tagName || attributes))) {
  2183.         return root.querySelectorAll(tagName + (attributes ? "." + attributes : ""));
  2184.       }
  2185.       if (attributes && root.getElementsByClassName) {
  2186.         root = root.getElementsByClassName(attributes);
  2187.         if (tagName) {
  2188.           args = {};
  2189.           /** @type {number} */
  2190.           var i = 0;
  2191.           /** @type {number} */
  2192.           var name = 0;
  2193.           var el;
  2194.           for (;el = root[name];name++) {
  2195.             if (tagName == el.nodeName) {
  2196.               args[i++] = el;
  2197.             }
  2198.           }
  2199.           /** @type {number} */
  2200.           args.length = i;
  2201.           return args;
  2202.         }
  2203.         return root;
  2204.       }
  2205.       root = root.getElementsByTagName(tagName || "*");
  2206.       if (attributes) {
  2207.         args = {};
  2208.         /** @type {number} */
  2209.         name = i = 0;
  2210.         for (;el = root[name];name++) {
  2211.           tagName = el.className;
  2212.           if ("function" == typeof tagName.split) {
  2213.             if (self.fb(tagName.split(/\s+/), attributes)) {
  2214.               args[i++] = el;
  2215.             }
  2216.           }
  2217.         }
  2218.         /** @type {number} */
  2219.         args.length = i;
  2220.         return args;
  2221.       }
  2222.       return root;
  2223.     };
  2224.     /**
  2225.      * @param {Element} element
  2226.      * @param {Object} properties
  2227.      * @return {undefined}
  2228.      */
  2229.     self.Bc = function(element, properties) {
  2230.       self.hc(properties, function(val, key) {
  2231.         if ("style" == key) {
  2232.           element.style.cssText = val;
  2233.         } else {
  2234.           if ("class" == key) {
  2235.             element.className = val;
  2236.           } else {
  2237.             if ("for" == key) {
  2238.               element.htmlFor = val;
  2239.             } else {
  2240.               if (names.hasOwnProperty(key)) {
  2241.                 element.setAttribute(names[key], val);
  2242.               } else {
  2243.                 if (self.wa(key, "aria-") || self.wa(key, "data-")) {
  2244.                   element.setAttribute(key, val);
  2245.                 } else {
  2246.                   element[key] = val;
  2247.                 }
  2248.               }
  2249.             }
  2250.           }
  2251.         }
  2252.       });
  2253.     };
  2254.     names = {
  2255.       cellpadding : "cellPadding",
  2256.       cellspacing : "cellSpacing",
  2257.       colspan : "colSpan",
  2258.       frameborder : "frameBorder",
  2259.       height : "height",
  2260.       maxlength : "maxLength",
  2261.       role : "role",
  2262.       rowspan : "rowSpan",
  2263.       type : "type",
  2264.       usemap : "useMap",
  2265.       valign : "vAlign",
  2266.       width : "width"
  2267.     };
  2268.     /**
  2269.      * @param {(Document|string)} opt_parentWin
  2270.      * @return {?}
  2271.      */
  2272.     self.Cc = function(opt_parentWin) {
  2273.       return getWindowSize(opt_parentWin || window);
  2274.     };
  2275.     /**
  2276.      * @param {Object} doc
  2277.      * @return {?}
  2278.      */
  2279.     getWindowSize = function(doc) {
  2280.       doc = doc.document;
  2281.       doc = h(doc) ? doc.documentElement : doc.body;
  2282.       return new self.ec(doc.clientWidth, doc.clientHeight);
  2283.     };
  2284.     /**
  2285.      * @return {?}
  2286.      */
  2287.     self.Ec = function() {
  2288.       var vh = window;
  2289.       var sh = vh.document;
  2290.       /** @type {number} */
  2291.       var body = 0;
  2292.       if (sh) {
  2293.         body = sh.body;
  2294.         var docEl = sh.documentElement;
  2295.         if (!docEl || !body) {
  2296.           return 0;
  2297.         }
  2298.         vh = getWindowSize(vh).height;
  2299.         if (h(sh) && docEl.scrollHeight) {
  2300.           body = docEl.scrollHeight != vh ? docEl.scrollHeight : docEl.offsetHeight;
  2301.         } else {
  2302.           sh = docEl.scrollHeight;
  2303.           var oh = docEl.offsetHeight;
  2304.           if (docEl.clientHeight != oh) {
  2305.             sh = body.scrollHeight;
  2306.             oh = body.offsetHeight;
  2307.           }
  2308.           body = sh > vh ? sh > oh ? sh : oh : sh < oh ? sh : oh;
  2309.         }
  2310.       }
  2311.       return body;
  2312.     };
  2313.     /**
  2314.      * @return {?}
  2315.      */
  2316.     self.Fc = function() {
  2317.       return offset(window.document);
  2318.     };
  2319.     /**
  2320.      * @param {Object} doc
  2321.      * @return {?}
  2322.      */
  2323.     offset = function(doc) {
  2324.       var el = self.Gc(doc);
  2325.       doc = doc.parentWindow || doc.defaultView;
  2326.       return self.Aa && (self.Ub("10") && doc.pageYOffset != el.scrollTop) ? new self.dc(el.scrollLeft, el.scrollTop) : new self.dc(doc.pageXOffset || el.scrollLeft, doc.pageYOffset || el.scrollTop);
  2327.     };
  2328.     /**
  2329.      * @param {Object} doc
  2330.      * @return {?}
  2331.      */
  2332.     self.Gc = function(doc) {
  2333.       return doc.scrollingElement ? doc.scrollingElement : !self.Pb && h(doc) ? doc.documentElement : doc.body || doc.documentElement;
  2334.     };
  2335.     /**
  2336.      * @param {Object} doc
  2337.      * @return {?}
  2338.      */
  2339.     self.Hc = function(doc) {
  2340.       return doc ? doc.parentWindow || doc.defaultView : window;
  2341.     };
  2342.     /**
  2343.      * @param {?} timeObject
  2344.      * @param {?} b
  2345.      * @param {?} m
  2346.      * @return {?}
  2347.      */
  2348.     self.A = function(timeObject, b, m) {
  2349.       return ready(window.document, arguments);
  2350.     };
  2351.     /**
  2352.      * @param {Document} e
  2353.      * @param {Arguments} args
  2354.      * @return {?}
  2355.      */
  2356.     ready = function(e, args) {
  2357.       var html = args[0];
  2358.       var attributes = args[1];
  2359.       if (!endInstead && (attributes && (attributes.name || attributes.type))) {
  2360.         /** @type {Array} */
  2361.         html = ["<", html];
  2362.         if (attributes.name) {
  2363.           html.push(' name="', self.Ga(attributes.name), '"');
  2364.         }
  2365.         if (attributes.type) {
  2366.           html.push(' type="', self.Ga(attributes.type), '"');
  2367.           var arg = {};
  2368.           self.rc(arg, attributes);
  2369.           delete arg.type;
  2370.           attributes = arg;
  2371.         }
  2372.         html.push(">");
  2373.         /** @type {string} */
  2374.         html = html.join("");
  2375.       }
  2376.       html = e.createElement(html);
  2377.       if (attributes) {
  2378.         if (self.ma(attributes)) {
  2379.           html.className = attributes;
  2380.         } else {
  2381.           if (self.ka(attributes)) {
  2382.             html.className = attributes.join(" ");
  2383.           } else {
  2384.             self.Bc(html, attributes);
  2385.           }
  2386.         }
  2387.       }
  2388.       if (2 < args.length) {
  2389.         setText(e, html, args, 2);
  2390.       }
  2391.       return html;
  2392.     };
  2393.     /**
  2394.      * @param {Document} el
  2395.      * @param {Object} text
  2396.      * @param {Object} args
  2397.      * @param {?} i
  2398.      * @return {undefined}
  2399.      */
  2400.     setText = function(el, text, args, i) {
  2401.       /**
  2402.        * @param {?} attributes
  2403.        * @return {undefined}
  2404.        */
  2405.       function add(attributes) {
  2406.         if (attributes) {
  2407.           text.appendChild(self.ma(attributes) ? el.createTextNode(attributes) : attributes);
  2408.         }
  2409.       }
  2410.       for (;i < args.length;i++) {
  2411.         var attributes = args[i];
  2412.         if (!self.la(attributes) || self.qa(attributes) && 0 < attributes.nodeType) {
  2413.           add(attributes);
  2414.         } else {
  2415.           (0, self.u)(makeArray(attributes) ? self.nb(attributes) : attributes, add);
  2416.         }
  2417.       }
  2418.     };
  2419.     /**
  2420.      * @param {?} opt_attributes
  2421.      * @return {?}
  2422.      */
  2423.     self.Ic = function(opt_attributes) {
  2424.       return window.document.createElement(opt_attributes);
  2425.     };
  2426.     /**
  2427.      * @param {?} obj
  2428.      * @return {?}
  2429.      */
  2430.     self.wi = function(obj) {
  2431.       return window.document.createTextNode(String(obj));
  2432.     };
  2433.     /**
  2434.      * @param {Document} Assert
  2435.      * @param {number} high
  2436.      * @param {number} b
  2437.      * @return {?}
  2438.      */
  2439.     self.Jc = function(Assert, high, b) {
  2440.       var TABLE = Assert.createElement("TABLE");
  2441.       var containerEl = TABLE.appendChild(Assert.createElement("TBODY"));
  2442.       /** @type {number} */
  2443.       var low = 0;
  2444.       for (;low < high;low++) {
  2445.         var docFrag = Assert.createElement("TR");
  2446.         /** @type {number} */
  2447.         var a = 0;
  2448.         for (;a < b;a++) {
  2449.           docFrag.appendChild(Assert.createElement("TD"));
  2450.         }
  2451.         containerEl.appendChild(docFrag);
  2452.       }
  2453.       return TABLE;
  2454.     };
  2455.     /**
  2456.      * @param {Document} a
  2457.      * @return {?}
  2458.      */
  2459.     h = function(a) {
  2460.       return "CSS1Compat" == a.compatMode;
  2461.     };
  2462.     /**
  2463.      * @param {?} child
  2464.      * @param {Array} f
  2465.      * @return {undefined}
  2466.      */
  2467.     self.Kc = function(child, f) {
  2468.       child.appendChild(f);
  2469.     };
  2470.     /**
  2471.      * @param {Object} msg
  2472.      * @param {?} v12
  2473.      * @return {undefined}
  2474.      */
  2475.     self.Lc = function(msg, v12) {
  2476.       setText(self.vc(msg), msg, arguments, 1);
  2477.     };
  2478.     /**
  2479.      * @param {HTMLElement} parent
  2480.      * @return {undefined}
  2481.      */
  2482.     self.Mc = function(parent) {
  2483.       var node;
  2484.       for (;node = parent.firstChild;) {
  2485.         parent.removeChild(node);
  2486.       }
  2487.     };
  2488.     /**
  2489.      * @param {?} relatedNode
  2490.      * @param {Node} s
  2491.      * @return {undefined}
  2492.      */
  2493.     self.Nc = function(relatedNode, s) {
  2494.       if (s.parentNode) {
  2495.         s.parentNode.insertBefore(relatedNode, s);
  2496.       }
  2497.     };
  2498.     /**
  2499.      * @param {?} relatedNode
  2500.      * @param {Node} el
  2501.      * @return {undefined}
  2502.      */
  2503.     self.Oc = function(relatedNode, el) {
  2504.       if (el.parentNode) {
  2505.         el.parentNode.insertBefore(relatedNode, el.nextSibling);
  2506.       }
  2507.     };
  2508.     /**
  2509.      * @param {?} opt_attributes
  2510.      * @param {Object} name
  2511.      * @param {(boolean|number|string)} attributes
  2512.      * @return {undefined}
  2513.      */
  2514.     self.Pc = function(opt_attributes, name, attributes) {
  2515.       opt_attributes.insertBefore(name, opt_attributes.childNodes[attributes] || null);
  2516.     };
  2517.     /**
  2518.      * @param {Object} node
  2519.      * @return {?}
  2520.      */
  2521.     self.Qc = function(node) {
  2522.       return node && node.parentNode ? node.parentNode.removeChild(node) : null;
  2523.     };
  2524.     /**
  2525.      * @param {?} opt_attributes
  2526.      * @return {?}
  2527.      */
  2528.     self.Rc = function(opt_attributes) {
  2529.       return Maa && void 0 != opt_attributes.children ? opt_attributes.children : (0, self.Za)(opt_attributes.childNodes, function(dest) {
  2530.         return 1 == dest.nodeType;
  2531.       });
  2532.     };
  2533.     /**
  2534.      * @param {Node} div
  2535.      * @return {?}
  2536.      */
  2537.     self.Uc = function(div) {
  2538.       return self.Uf(div.firstElementChild) ? div.firstElementChild : skipEmptyTextNodes(div.firstChild, true);
  2539.     };
  2540.     /**
  2541.      * @param {Node} div
  2542.      * @return {?}
  2543.      */
  2544.     self.Vc = function(div) {
  2545.       return self.Uf(div.lastElementChild) ? div.lastElementChild : skipEmptyTextNodes(div.lastChild, false);
  2546.     };
  2547.     /**
  2548.      * @param {Node} elem
  2549.      * @return {?}
  2550.      */
  2551.     self.Wc = function(elem) {
  2552.       return self.Uf(elem.nextElementSibling) ? elem.nextElementSibling : skipEmptyTextNodes(elem.nextSibling, true);
  2553.     };
  2554.     /**
  2555.      * @param {Node} el
  2556.      * @return {?}
  2557.      */
  2558.     self.Xc = function(el) {
  2559.       return self.Uf(el.previousElementSibling) ? el.previousElementSibling : skipEmptyTextNodes(el.previousSibling, false);
  2560.     };
  2561.     /**
  2562.      * @param {Object} node
  2563.      * @param {boolean} forwards
  2564.      * @return {?}
  2565.      */
  2566.     skipEmptyTextNodes = function(node, forwards) {
  2567.       for (;node && 1 != node.nodeType;) {
  2568.         node = forwards ? node.nextSibling : node.previousSibling;
  2569.       }
  2570.       return node;
  2571.     };
  2572.     /**
  2573.      * @param {?} attributes
  2574.      * @return {?}
  2575.      */
  2576.     self.Yc = function(attributes) {
  2577.       return self.qa(attributes) && 1 == attributes.nodeType;
  2578.     };
  2579.     /**
  2580.      * @param {string} element
  2581.      * @return {?}
  2582.      */
  2583.     self.Zc = function(element) {
  2584.       var parent;
  2585.       if (Oaa && (!(self.Aa && (self.Ub("9") && (!self.Ub("10") && (self.ca.SVGElement && element instanceof self.ca.SVGElement)))) && (parent = element.parentElement))) {
  2586.         return parent;
  2587.       }
  2588.       parent = element.parentNode;
  2589.       return self.Yc(parent) ? parent : null;
  2590.     };
  2591.     /**
  2592.      * @param {Object} parent
  2593.      * @param {Object} descendant
  2594.      * @return {?}
  2595.      */
  2596.     self.$c = function(parent, descendant) {
  2597.       if (parent.contains && 1 == descendant.nodeType) {
  2598.         return parent == descendant || parent.contains(descendant);
  2599.       }
  2600.       if ("undefined" != typeof parent.compareDocumentPosition) {
  2601.         return parent == descendant || Boolean(parent.compareDocumentPosition(descendant) & 16);
  2602.       }
  2603.       for (;descendant && parent != descendant;) {
  2604.         descendant = descendant.parentNode;
  2605.       }
  2606.       return descendant == parent;
  2607.     };
  2608.     /**
  2609.      * @param {Object} el
  2610.      * @return {?}
  2611.      */
  2612.     self.vc = function(el) {
  2613.       return 9 == el.nodeType ? el : el.ownerDocument || el.document;
  2614.     };
  2615.     /**
  2616.      * @param {Element} iframe
  2617.      * @return {?}
  2618.      */
  2619.     self.qpa = function(iframe) {
  2620.       return iframe.contentDocument || iframe.contentWindow.document;
  2621.     };
  2622.     /**
  2623.      * @param {HTMLElement} element
  2624.      * @param {?} value
  2625.      * @return {undefined}
  2626.      */
  2627.     self.ad = function(element, value) {
  2628.       if ("textContent" in element) {
  2629.         element.textContent = value;
  2630.       } else {
  2631.         if (3 == element.nodeType) {
  2632.           element.data = value;
  2633.         } else {
  2634.           if (element.firstChild && 3 == element.firstChild.nodeType) {
  2635.             for (;element.lastChild != element.firstChild;) {
  2636.               element.removeChild(element.lastChild);
  2637.             }
  2638.             element.firstChild.data = value;
  2639.           } else {
  2640.             self.Mc(element);
  2641.             element.appendChild(self.vc(element).createTextNode(String(value)));
  2642.           }
  2643.         }
  2644.       }
  2645.     };
  2646.     IFRAME = {
  2647.       SCRIPT : 1,
  2648.       STYLE : 1,
  2649.       HEAD : 1,
  2650.       IFRAME : 1,
  2651.       OBJECT : 1
  2652.     };
  2653.     tmp = {
  2654.       IMG : " ",
  2655.       BR : "\n"
  2656.     };
  2657.     /**
  2658.      * @param {string} el
  2659.      * @return {?}
  2660.      */
  2661.     self.bd = function(el) {
  2662.       if (innerText && "innerText" in el) {
  2663.         el = self.haa(el.innerText);
  2664.       } else {
  2665.         /** @type {Array} */
  2666.         var results = [];
  2667.         self.gba(el, results, true);
  2668.         /** @type {string} */
  2669.         el = results.join("");
  2670.       }
  2671.       el = el.replace(/ \xAD /g, " ").replace(/\xAD/g, "");
  2672.       el = el.replace(/\u200B/g, "");
  2673.       if (!innerText) {
  2674.         el = el.replace(/ +/g, " ");
  2675.       }
  2676.       if (" " != el) {
  2677.         el = el.replace(/^\s*/, "");
  2678.       }
  2679.       return el;
  2680.     };
  2681.     /**
  2682.      * @param {Node} el
  2683.      * @param {Array} nodes
  2684.      * @param {boolean} allowIntersection
  2685.      * @return {undefined}
  2686.      */
  2687.     self.gba = function(el, nodes, allowIntersection) {
  2688.       if (!(el.nodeName in IFRAME)) {
  2689.         if (3 == el.nodeType) {
  2690.           if (allowIntersection) {
  2691.             nodes.push(String(el.nodeValue).replace(/(\r\n|\r|\n)/g, ""));
  2692.           } else {
  2693.             nodes.push(el.nodeValue);
  2694.           }
  2695.         } else {
  2696.           if (el.nodeName in tmp) {
  2697.             nodes.push(tmp[el.nodeName]);
  2698.           } else {
  2699.             el = el.firstChild;
  2700.             for (;el;) {
  2701.               self.gba(el, nodes, allowIntersection);
  2702.               el = el.nextSibling;
  2703.             }
  2704.           }
  2705.         }
  2706.       }
  2707.     };
  2708.     /**
  2709.      * @param {?} attributes
  2710.      * @return {?}
  2711.      */
  2712.     makeArray = function(attributes) {
  2713.       if (attributes && "number" == typeof attributes.length) {
  2714.         if (self.qa(attributes)) {
  2715.           return "function" == typeof attributes.item || "string" == typeof attributes.item;
  2716.         }
  2717.         if (self.pa(attributes)) {
  2718.           return "function" == typeof attributes.item;
  2719.         }
  2720.       }
  2721.       return false;
  2722.     };
  2723.     /**
  2724.      * @param {?} element
  2725.      * @param {string} tag
  2726.      * @param {string} d
  2727.      * @param {number} cb
  2728.      * @return {?}
  2729.      */
  2730.     self.dd = function(element, tag, d, cb) {
  2731.       if (!tag && !d) {
  2732.         return null;
  2733.       }
  2734.       var nodeName = tag ? tag.toUpperCase() : null;
  2735.       return self.cd(element, function(child) {
  2736.         return(!nodeName || child.nodeName == nodeName) && (!d || self.ma(child.className) && self.fb(child.className.split(/\s+/), d));
  2737.       }, true, cb);
  2738.     };
  2739.     /**
  2740.      * @param {?} container
  2741.      * @param {string} millis
  2742.      * @param {number} done
  2743.      * @return {?}
  2744.      */
  2745.     self.ed = function(container, millis, done) {
  2746.       return self.dd(container, null, millis, done);
  2747.     };
  2748.     /**
  2749.      * @param {Object} element
  2750.      * @param {Function} proceed
  2751.      * @param {boolean} dataAndEvents
  2752.      * @param {number} delegate
  2753.      * @return {?}
  2754.      */
  2755.     self.cd = function(element, proceed, dataAndEvents, delegate) {
  2756.       if (!dataAndEvents) {
  2757.         element = element.parentNode;
  2758.       }
  2759.       /** @type {boolean} */
  2760.       dataAndEvents = null == delegate;
  2761.       /** @type {number} */
  2762.       var e = 0;
  2763.       for (;element && (dataAndEvents || e <= delegate);) {
  2764.         if (proceed(element)) {
  2765.           return element;
  2766.         }
  2767.         element = element.parentNode;
  2768.         e++;
  2769.       }
  2770.       return null;
  2771.     };
  2772.     /**
  2773.      * @param {Document} doc
  2774.      * @return {?}
  2775.      */
  2776.     self.fd = function(doc) {
  2777.       try {
  2778.         return doc && doc.activeElement;
  2779.       } catch (b) {
  2780.       }
  2781.       return null;
  2782.     };
  2783.     /**
  2784.      * @param {(Document|string)} dataAndEvents
  2785.      * @return {undefined}
  2786.      */
  2787.     self.uc = function(dataAndEvents) {
  2788.       this.pb = dataAndEvents || (self.ca.document || window.document);
  2789.     };
  2790.     /**
  2791.      * @param {Object} optgroup
  2792.      * @return {?}
  2793.      */
  2794.     self.uc.prototype.va = function(optgroup) {
  2795.       return self.xc(this.pb, optgroup);
  2796.     };
  2797.     /** @type {function (Element, Object): undefined} */
  2798.     self.uc.prototype.setProperties = self.Bc;
  2799.     /**
  2800.      * @param {?} opt_attributes
  2801.      * @param {Object} name
  2802.      * @param {(boolean|number|string)} attributes
  2803.      * @return {?}
  2804.      */
  2805.     self.uc.prototype.$ = function(opt_attributes, name, attributes) {
  2806.       return ready(this.pb, arguments);
  2807.     };
  2808.     /**
  2809.      * @param {string} tag
  2810.      * @return {?}
  2811.      */
  2812.     self.uc.prototype.createElement = function(tag) {
  2813.       return this.pb.createElement(tag);
  2814.     };
  2815.     /**
  2816.      * @param {?} opt_attributes
  2817.      * @param {Object} name
  2818.      * @return {?}
  2819.      */
  2820.     self.id = function(opt_attributes, name) {
  2821.       return opt_attributes.pb.createTextNode(String(name));
  2822.     };
  2823.     /**
  2824.      * @param {string} var_args
  2825.      * @return {?}
  2826.      */
  2827.     self.jd = function(var_args) {
  2828.       return h(var_args.pb);
  2829.     };
  2830.     /**
  2831.      * @param {Object} doc
  2832.      * @return {?}
  2833.      */
  2834.     self.Lb = function(doc) {
  2835.       doc = doc.pb;
  2836.       return doc.parentWindow || doc.defaultView;
  2837.     };
  2838.     /**
  2839.      * @param {?} dataAndEvents
  2840.      * @return {?}
  2841.      */
  2842.     self.ld = function(dataAndEvents) {
  2843.       return self.Gc(dataAndEvents.pb);
  2844.     };
  2845.     /**
  2846.      * @param {?} prm
  2847.      * @return {?}
  2848.      */
  2849.     self.md = function(prm) {
  2850.       return offset(prm.pb);
  2851.     };
  2852.     self.h = self.uc.prototype;
  2853.     /** @type {function (?, Array): undefined} */
  2854.     self.h.appendChild = self.Kc;
  2855.     /** @type {function (Object, ?): undefined} */
  2856.     self.h.append = self.Lc;
  2857.     /** @type {function (HTMLElement): undefined} */
  2858.     self.h.hm = self.Mc;
  2859.     /** @type {function (?, Node): undefined} */
  2860.     self.h.gL = self.Nc;
  2861.     /** @type {function (?, Object, (boolean|number|string)): undefined} */
  2862.     self.h.fL = self.Pc;
  2863.     /** @type {function (Object): ?} */
  2864.     self.h.qh = self.Qc;
  2865.     /** @type {function (?): ?} */
  2866.     self.h.getChildren = self.Rc;
  2867.     /** @type {function (Node): ?} */
  2868.     self.h.OI = self.Uc;
  2869.     /** @type {function (Node): ?} */
  2870.     self.h.XI = self.Xc;
  2871.     /** @type {function (?): ?} */
  2872.     self.h.l1 = self.Yc;
  2873.     /** @type {function (string): ?} */
  2874.     self.h.BV = self.Zc;
  2875.     /** @type {function (Object, Object): ?} */
  2876.     self.h.contains = self.$c;
  2877.     /** @type {function (HTMLElement, ?): undefined} */
  2878.     self.h.Lb = self.ad;
  2879.     /** @type {function (string): ?} */
  2880.     self.h.ux = self.bd;
  2881.     /** @type {function (?, string, number): ?} */
  2882.     self.h.IB = self.ed;
  2883.     var inspect;
  2884.     /**
  2885.      * @return {?}
  2886.      */
  2887.     self.nd = function() {
  2888.       return self.Pb ? "Webkit" : self.Ob ? "Moz" : self.Aa ? "ms" : self.Mb ? "O" : null;
  2889.     };
  2890.     /**
  2891.      * @return {?}
  2892.      */
  2893.     self.od = function() {
  2894.       return self.Pb ? "-webkit" : self.Ob ? "-moz" : self.Aa ? "-ms" : self.Mb ? "-o" : null;
  2895.     };
  2896.     /**
  2897.      * @param {string} str
  2898.      * @param {Object} obj
  2899.      * @return {?}
  2900.      */
  2901.     inspect = function(str, obj) {
  2902.       if (obj && str in obj) {
  2903.         return str;
  2904.       }
  2905.       var part = self.nd();
  2906.       return part ? (part = part.toLowerCase(), part += self.Ta(str), !self.Uf(obj) || part in obj ? part : null) : null;
  2907.     };
  2908.     var jba;
  2909.     var named;
  2910.     var lba;
  2911.     /** @type {boolean} */
  2912.     jba = !self.Aa || 9 <= self.Jaa;
  2913.     /** @type {boolean} */
  2914.     named = !self.Aa || 9 <= self.Jaa;
  2915.     lba = self.Aa && !self.Ub("9");
  2916.     self.mba = !self.Pb || self.Ub("528");
  2917.     self.nba = self.Ob && self.Ub("1.9b") || (self.Aa && self.Ub("8") || (self.Mb && self.Ub("9.5") || self.Pb && self.Ub("528")));
  2918.     self.oba = self.Ob && !self.Ub("8") || self.Aa && !self.Ub("9");
  2919.     /** @type {boolean} */
  2920.     self.pba = "ontouchstart" in self.ca || (!!(self.ca.document && (window.document.documentElement && "ontouchstart" in window.document.documentElement)) || !(!self.ca.navigator || !self.ca.navigator.msMaxTouchPoints));
  2921.     /**
  2922.      * @param {?} obj
  2923.      * @param {Object} $opt_target$$1
  2924.      * @return {undefined}
  2925.      */
  2926.     self.pd = function(obj, $opt_target$$1) {
  2927.       this.type = "undefined" != typeof self.fda && obj instanceof self.fda ? String(obj) : obj;
  2928.       this.currentTarget = this.target = $opt_target$$1;
  2929.       /** @type {boolean} */
  2930.       this.ma = false;
  2931.       /** @type {boolean} */
  2932.       this.tN = true;
  2933.     };
  2934.     /**
  2935.      * @return {undefined}
  2936.      */
  2937.     self.pd.prototype.stopPropagation = function() {
  2938.       /** @type {boolean} */
  2939.       this.ma = true;
  2940.     };
  2941.     /**
  2942.      * @return {undefined}
  2943.      */
  2944.     self.pd.prototype.preventDefault = function() {
  2945.       /** @type {boolean} */
  2946.       this.tN = false;
  2947.     };
  2948.     /**
  2949.      * @param {Object} types
  2950.      * @return {undefined}
  2951.      */
  2952.     self.oda = function(types) {
  2953.       types.preventDefault();
  2954.     };
  2955.     var normalizeEvent;
  2956.     /**
  2957.      * @param {string} eventName
  2958.      * @return {?}
  2959.      */
  2960.     normalizeEvent = function(eventName) {
  2961.       return self.Pb ? "webkit" + eventName : self.Mb ? "o" + eventName.toLowerCase() : eventName.toLowerCase();
  2962.     };
  2963.     /** @type {string} */
  2964.     self.qd = self.Aa ? "focusin" : "DOMFocusIn";
  2965.     /** @type {string} */
  2966.     self.rba = self.Aa ? "focusout" : "DOMFocusOut";
  2967.     self.sba = normalizeEvent("AnimationEnd");
  2968.     self.rd = normalizeEvent("TransitionEnd");
  2969.     /**
  2970.      * @param {?} td
  2971.      * @return {?}
  2972.      */
  2973.     self.td = function(td) {
  2974.       self.td[" "](td);
  2975.       return td;
  2976.     };
  2977.     /** @type {function (): undefined} */
  2978.     self.td[" "] = self.R;
  2979.     /**
  2980.      * @param {?} attributes
  2981.      * @param {Object} optgroup
  2982.      * @return {undefined}
  2983.      */
  2984.     self.ud = function(attributes, optgroup) {
  2985.       self.pd.call(this, attributes ? attributes.type : "");
  2986.       /** @type {null} */
  2987.       this.relatedTarget = this.currentTarget = this.target = null;
  2988.       /** @type {number} */
  2989.       this.charCode = this.keyCode = this.button = this.screenY = this.screenX = this.clientY = this.clientX = this.offsetY = this.offsetX = 0;
  2990.       /** @type {boolean} */
  2991.       this.metaKey = this.shiftKey = this.altKey = this.ctrlKey = false;
  2992.       /** @type {null} */
  2993.       this.state = null;
  2994.       /** @type {boolean} */
  2995.       this.ka = false;
  2996.       /** @type {null} */
  2997.       this.$ = null;
  2998.       if (attributes) {
  2999.         this.init(attributes, optgroup);
  3000.       }
  3001.     };
  3002.     self.r(self.ud, self.pd);
  3003.     /** @type {Array} */
  3004.     var tba = [1, 4, 2];
  3005.     /**
  3006.      * @param {?} opt_attributes
  3007.      * @param {Object} name
  3008.      * @return {undefined}
  3009.      */
  3010.     self.ud.prototype.init = function(opt_attributes, name) {
  3011.       var $type$$52 = this.type = opt_attributes.type;
  3012.       var touch = opt_attributes.changedTouches ? opt_attributes.changedTouches[0] : null;
  3013.       this.target = opt_attributes.target || opt_attributes.srcElement;
  3014.       /** @type {Object} */
  3015.       this.currentTarget = name;
  3016.       var relatedTarget = opt_attributes.relatedTarget;
  3017.       if (relatedTarget) {
  3018.         if (self.Ob) {
  3019.           var f;
  3020.           a: {
  3021.             try {
  3022.               self.td(relatedTarget.nodeName);
  3023.               /** @type {boolean} */
  3024.               f = true;
  3025.               break a;
  3026.             } catch (g) {
  3027.             }
  3028.             /** @type {boolean} */
  3029.             f = false;
  3030.           }
  3031.           if (!f) {
  3032.             /** @type {null} */
  3033.             relatedTarget = null;
  3034.           }
  3035.         }
  3036.       } else {
  3037.         if ("mouseover" == $type$$52) {
  3038.           relatedTarget = opt_attributes.fromElement;
  3039.         } else {
  3040.           if ("mouseout" == $type$$52) {
  3041.             relatedTarget = opt_attributes.toElement;
  3042.           }
  3043.         }
  3044.       }
  3045.       this.relatedTarget = relatedTarget;
  3046.       if (null === touch) {
  3047.         this.offsetX = self.Pb || void 0 !== opt_attributes.offsetX ? opt_attributes.offsetX : opt_attributes.layerX;
  3048.         this.offsetY = self.Pb || void 0 !== opt_attributes.offsetY ? opt_attributes.offsetY : opt_attributes.layerY;
  3049.         this.clientX = void 0 !== opt_attributes.clientX ? opt_attributes.clientX : opt_attributes.pageX;
  3050.         this.clientY = void 0 !== opt_attributes.clientY ? opt_attributes.clientY : opt_attributes.pageY;
  3051.         this.screenX = opt_attributes.screenX || 0;
  3052.         this.screenY = opt_attributes.screenY || 0;
  3053.       } else {
  3054.         this.clientX = void 0 !== touch.clientX ? touch.clientX : touch.pageX;
  3055.         this.clientY = void 0 !== touch.clientY ? touch.clientY : touch.pageY;
  3056.         this.screenX = touch.screenX || 0;
  3057.         this.screenY = touch.screenY || 0;
  3058.       }
  3059.       this.button = opt_attributes.button;
  3060.       this.keyCode = opt_attributes.keyCode || 0;
  3061.       this.charCode = opt_attributes.charCode || ("keypress" == $type$$52 ? opt_attributes.keyCode : 0);
  3062.       this.ctrlKey = opt_attributes.ctrlKey;
  3063.       this.altKey = opt_attributes.altKey;
  3064.       this.shiftKey = opt_attributes.shiftKey;
  3065.       this.metaKey = opt_attributes.metaKey;
  3066.       this.ka = self.Ib ? opt_attributes.metaKey : opt_attributes.ctrlKey;
  3067.       this.state = opt_attributes.state;
  3068.       this.$ = opt_attributes;
  3069.       if (opt_attributes.defaultPrevented) {
  3070.         this.preventDefault();
  3071.       }
  3072.     };
  3073.     /**
  3074.      * @param {Object} e
  3075.      * @return {?}
  3076.      */
  3077.     self.uba = function(e) {
  3078.       return jba ? 0 == e.$.button : "click" == e.type ? true : !!(e.$.button & tba[0]);
  3079.     };
  3080.     /**
  3081.      * @return {?}
  3082.      */
  3083.     self.ud.prototype.Ii = function() {
  3084.       return self.uba(this) && !(self.Pb && (self.Ib && this.ctrlKey));
  3085.     };
  3086.     /**
  3087.      * @return {undefined}
  3088.      */
  3089.     self.ud.prototype.stopPropagation = function() {
  3090.       self.ud.Ba.stopPropagation.call(this);
  3091.       if (this.$.stopPropagation) {
  3092.         this.$.stopPropagation();
  3093.       } else {
  3094.         /** @type {boolean} */
  3095.         this.$.cancelBubble = true;
  3096.       }
  3097.     };
  3098.     /**
  3099.      * @return {undefined}
  3100.      */
  3101.     self.ud.prototype.preventDefault = function() {
  3102.       self.ud.Ba.preventDefault.call(this);
  3103.       var ev = this.$;
  3104.       if (ev.preventDefault) {
  3105.         ev.preventDefault();
  3106.       } else {
  3107.         if (ev.returnValue = false, lba) {
  3108.           try {
  3109.             if (ev.ctrlKey || 112 <= ev.keyCode && 123 >= ev.keyCode) {
  3110.               /** @type {number} */
  3111.               ev.keyCode = -1;
  3112.             }
  3113.           } catch (b) {
  3114.           }
  3115.         }
  3116.       }
  3117.     };
  3118.     var functionName;
  3119.     var nextKey;
  3120.     /** @type {string} */
  3121.     functionName = "closure_listenable_" + (1E6 * Math.random() | 0);
  3122.     /**
  3123.      * @param {?} object
  3124.      * @return {?}
  3125.      */
  3126.     self.vd = function(object) {
  3127.       return!(!object || !object[functionName]);
  3128.     };
  3129.     /** @type {number} */
  3130.     nextKey = 0;
  3131.     /**
  3132.      * @param {Function} listener
  3133.      * @param {?} url
  3134.      * @param {?} type
  3135.      * @param {?} opt_vars
  3136.      * @param {?} y
  3137.      * @return {undefined}
  3138.      */
  3139.     var Player = function(listener, url, type, opt_vars, y) {
  3140.       /** @type {Function} */
  3141.       this.listener = listener;
  3142.       /** @type {null} */
  3143.       this.proxy = null;
  3144.       this.src = url;
  3145.       this.type = type;
  3146.       /** @type {boolean} */
  3147.       this.Ns = !!opt_vars;
  3148.       this.ay = y;
  3149.       /** @type {number} */
  3150.       this.key = ++nextKey;
  3151.       /** @type {boolean} */
  3152.       this.removed = this.fw = false;
  3153.     };
  3154.     /**
  3155.      * @param {Object} listener
  3156.      * @return {undefined}
  3157.      */
  3158.     var addListener = function(listener) {
  3159.       /** @type {boolean} */
  3160.       listener.removed = true;
  3161.       /** @type {null} */
  3162.       listener.listener = null;
  3163.       /** @type {null} */
  3164.       listener.proxy = null;
  3165.       /** @type {null} */
  3166.       listener.src = null;
  3167.       /** @type {null} */
  3168.       listener.ay = null;
  3169.     };
  3170.     /**
  3171.      * @param {?} src
  3172.      * @return {undefined}
  3173.      */
  3174.     var ctor = function(src) {
  3175.       this.src = src;
  3176.       this.Ad = {};
  3177.       /** @type {number} */
  3178.       this.$ = 0;
  3179.     };
  3180.     var Event;
  3181.     /**
  3182.      * @param {?} type
  3183.      * @param {?} key
  3184.      * @param {boolean} b
  3185.      * @param {Function} child
  3186.      * @param {Array} selector
  3187.      * @return {?}
  3188.      */
  3189.     ctor.prototype.add = function(type, key, b, child, selector) {
  3190.       var j = type.toString();
  3191.       type = this.Ad[j];
  3192.       if (!type) {
  3193.         /** @type {Array} */
  3194.         type = this.Ad[j] = [];
  3195.         this.$++;
  3196.       }
  3197.       var ret = Event(type, key, child, selector);
  3198.       if (-1 < ret) {
  3199.         key = type[ret];
  3200.         if (!b) {
  3201.           /** @type {boolean} */
  3202.           key.fw = false;
  3203.         }
  3204.       } else {
  3205.         key = new Player(key, this.src, j, !!child, selector);
  3206.         /** @type {boolean} */
  3207.         key.fw = b;
  3208.         type.push(key);
  3209.       }
  3210.       return key;
  3211.     };
  3212.     /**
  3213.      * @param {?} opt_attributes
  3214.      * @param {number} event
  3215.      * @param {boolean} listener
  3216.      * @param {Array} options
  3217.      * @return {?}
  3218.      */
  3219.     ctor.prototype.remove = function(opt_attributes, event, listener, options) {
  3220.       opt_attributes = opt_attributes.toString();
  3221.       if (!(opt_attributes in this.Ad)) {
  3222.         return false;
  3223.       }
  3224.       var type = this.Ad[opt_attributes];
  3225.       event = Event(type, event, listener, options);
  3226.       return-1 < event ? (addListener(type[event]), self.jb(type, event), 0 == type.length && (delete this.Ad[opt_attributes], this.$--), true) : false;
  3227.     };
  3228.     /**
  3229.      * @param {?} events
  3230.      * @param {Object} event
  3231.      * @return {?}
  3232.      */
  3233.     var connect = function(events, event) {
  3234.       var eventType = event.type;
  3235.       if (!(eventType in events.Ad)) {
  3236.         return false;
  3237.       }
  3238.       var conn = self.kb(events.Ad[eventType], event);
  3239.       if (conn) {
  3240.         addListener(event);
  3241.         if (0 == events.Ad[eventType].length) {
  3242.           delete events.Ad[eventType];
  3243.           events.$--;
  3244.         }
  3245.       }
  3246.       return conn;
  3247.     };
  3248.     /**
  3249.      * @param {Object} opt_type
  3250.      * @return {?}
  3251.      */
  3252.     ctor.prototype.removeAll = function(opt_type) {
  3253.       opt_type = opt_type && opt_type.toString();
  3254.       /** @type {number} */
  3255.       var count = 0;
  3256.       var type;
  3257.       for (type in this.Ad) {
  3258.         if (!opt_type || type == opt_type) {
  3259.           var codeSegments = this.Ad[type];
  3260.           /** @type {number} */
  3261.           var i = 0;
  3262.           for (;i < codeSegments.length;i++) {
  3263.             ++count;
  3264.             addListener(codeSegments[i]);
  3265.           }
  3266.           delete this.Ad[type];
  3267.           this.$--;
  3268.         }
  3269.       }
  3270.       return count;
  3271.     };
  3272.     /**
  3273.      * @param {?} dstUri
  3274.      * @param {?} deepDataAndEvents
  3275.      * @return {?}
  3276.      */
  3277.     ctor.prototype.ox = function(dstUri, deepDataAndEvents) {
  3278.       var codeSegments = this.Ad[dstUri.toString()];
  3279.       /** @type {Array} */
  3280.       var eventPath = [];
  3281.       if (codeSegments) {
  3282.         /** @type {number} */
  3283.         var i = 0;
  3284.         for (;i < codeSegments.length;++i) {
  3285.           var cur = codeSegments[i];
  3286.           if (cur.Ns == deepDataAndEvents) {
  3287.             eventPath.push(cur);
  3288.           }
  3289.         }
  3290.       }
  3291.       return eventPath;
  3292.     };
  3293.     /**
  3294.      * @param {Object} type
  3295.      * @param {number} key
  3296.      * @param {Object} c
  3297.      * @param {boolean} listener
  3298.      * @param {Array} params
  3299.      * @return {?}
  3300.      */
  3301.     self.Aba = function(type, key, c, listener, params) {
  3302.       type = type.Ad[key.toString()];
  3303.       /** @type {number} */
  3304.       key = -1;
  3305.       if (type) {
  3306.         key = Event(type, c, listener, params);
  3307.       }
  3308.       return-1 < key ? type[key] : null;
  3309.     };
  3310.     /**
  3311.      * @param {Array} tests
  3312.      * @param {?} listener
  3313.      * @param {boolean} type
  3314.      * @param {Array} target
  3315.      * @return {?}
  3316.      */
  3317.     Event = function(tests, listener, type, target) {
  3318.       /** @type {number} */
  3319.       var i = 0;
  3320.       for (;i < tests.length;++i) {
  3321.         var self = tests[i];
  3322.         if (!self.removed && (self.listener == listener && (self.Ns == !!type && self.ay == target))) {
  3323.           return i;
  3324.         }
  3325.       }
  3326.       return-1;
  3327.     };
  3328.     var _i;
  3329.     var args;
  3330.     var Dba;
  3331.     var addEventListener;
  3332.     var map;
  3333.     var attachEvent;
  3334.     var isArray;
  3335.     var objectToString;
  3336.     var visit;
  3337.     var LISTENER_SCRIPT_DATA;
  3338.     /** @type {string} */
  3339.     _i = "closure_lm_" + (1E6 * Math.random() | 0);
  3340.     args = {};
  3341.     /** @type {number} */
  3342.     Dba = 0;
  3343.     /**
  3344.      * @param {Object} name
  3345.      * @param {?} attributes
  3346.      * @param {Function} type
  3347.      * @param {?} obj
  3348.      * @param {Array} event
  3349.      * @return {?}
  3350.      */
  3351.     self.C = function(name, attributes, type, obj, event) {
  3352.       if (self.ka(attributes)) {
  3353.         /** @type {number} */
  3354.         var i = 0;
  3355.         for (;i < attributes.length;i++) {
  3356.           self.C(name, attributes[i], type, obj, event);
  3357.         }
  3358.         return null;
  3359.       }
  3360.       type = self.yd(type);
  3361.       return self.vd(name) ? name.listen(attributes, type, obj, event) : addEventListener(name, attributes, type, false, obj, event);
  3362.     };
  3363.     /**
  3364.      * @param {Object} src
  3365.      * @param {?} obj
  3366.      * @param {Object} listener
  3367.      * @param {Object} f
  3368.      * @param {Function} label
  3369.      * @param {Array} selector
  3370.      * @return {?}
  3371.      */
  3372.     addEventListener = function(src, obj, listener, f, label, selector) {
  3373.       if (!obj) {
  3374.         throw Error("d");
  3375.       }
  3376.       /** @type {boolean} */
  3377.       var capture = !!label;
  3378.       var listenerMap = self.zd(src);
  3379.       if (!listenerMap) {
  3380.         src[_i] = listenerMap = new ctor(src);
  3381.       }
  3382.       listener = listenerMap.add(obj, listener, f, label, selector);
  3383.       if (listener.proxy) {
  3384.         return listener;
  3385.       }
  3386.       f = map();
  3387.       /** @type {Object} */
  3388.       listener.proxy = f;
  3389.       /** @type {Object} */
  3390.       f.src = src;
  3391.       /** @type {Object} */
  3392.       f.listener = listener;
  3393.       if (src.addEventListener) {
  3394.         src.addEventListener(obj.toString(), f, capture);
  3395.       } else {
  3396.         if (src.attachEvent) {
  3397.           src.attachEvent(attachEvent(obj.toString()), f);
  3398.         } else {
  3399.           throw Error("lc");
  3400.         }
  3401.       }
  3402.       Dba++;
  3403.       return listener;
  3404.     };
  3405.     /**
  3406.      * @return {?}
  3407.      */
  3408.     map = function() {
  3409.       var proxyCallbackFunction = visit;
  3410.       /** @type {function (?): ?} */
  3411.       var f = named ? function(eventObject) {
  3412.         return proxyCallbackFunction.call(f.src, f.listener, eventObject);
  3413.       } : function(result) {
  3414.         result = proxyCallbackFunction.call(f.src, f.listener, result);
  3415.         if (!result) {
  3416.           return result;
  3417.         }
  3418.       };
  3419.       return f;
  3420.     };
  3421.     /**
  3422.      * @param {?} node
  3423.      * @param {?} attributes
  3424.      * @param {Array} type
  3425.      * @param {Function} label
  3426.      * @param {Array} until
  3427.      * @return {?}
  3428.      */
  3429.     self.Ad = function(node, attributes, type, label, until) {
  3430.       if (self.ka(attributes)) {
  3431.         /** @type {number} */
  3432.         var i = 0;
  3433.         for (;i < attributes.length;i++) {
  3434.           self.Ad(node, attributes[i], type, label, until);
  3435.         }
  3436.         return null;
  3437.       }
  3438.       type = self.yd(type);
  3439.       return self.vd(node) ? node.hj.add(String(attributes), type, true, label, until) : addEventListener(node, attributes, type, true, label, until);
  3440.     };
  3441.     /**
  3442.      * @param {Object} model
  3443.      * @param {?} attributes
  3444.      * @param {Function} type
  3445.      * @param {boolean} callback
  3446.      * @param {Array} opt_capt
  3447.      * @return {?}
  3448.      */
  3449.     self.Bd = function(model, attributes, type, callback, opt_capt) {
  3450.       if (self.ka(attributes)) {
  3451.         /** @type {number} */
  3452.         var i = 0;
  3453.         for (;i < attributes.length;i++) {
  3454.           self.Bd(model, attributes[i], type, callback, opt_capt);
  3455.         }
  3456.         return null;
  3457.       }
  3458.       type = self.yd(type);
  3459.       if (self.vd(model)) {
  3460.         return model.unlisten(attributes, type, callback, opt_capt);
  3461.       }
  3462.       if (!model) {
  3463.         return false;
  3464.       }
  3465.       if (model = self.zd(model)) {
  3466.         if (attributes = self.Aba(model, attributes, type, !!callback, opt_capt)) {
  3467.           return self.Cd(attributes);
  3468.         }
  3469.       }
  3470.       return false;
  3471.     };
  3472.     /**
  3473.      * @param {Object} listener
  3474.      * @return {?}
  3475.      */
  3476.     self.Cd = function(listener) {
  3477.       if (self.oa(listener) || (!listener || listener.removed)) {
  3478.         return false;
  3479.       }
  3480.       var src = listener.src;
  3481.       if (self.vd(src)) {
  3482.         return connect(src.hj, listener);
  3483.       }
  3484.       var type = listener.type;
  3485.       var proxy = listener.proxy;
  3486.       if (src.removeEventListener) {
  3487.         src.removeEventListener(type, proxy, listener.Ns);
  3488.       } else {
  3489.         if (src.detachEvent) {
  3490.           src.detachEvent(attachEvent(type), proxy);
  3491.         }
  3492.       }
  3493.       Dba--;
  3494.       if (type = self.zd(src)) {
  3495.         connect(type, listener);
  3496.         if (0 == type.$) {
  3497.           /** @type {null} */
  3498.           type.src = null;
  3499.           /** @type {null} */
  3500.           src[_i] = null;
  3501.         }
  3502.       } else {
  3503.         addListener(listener);
  3504.       }
  3505.       return true;
  3506.     };
  3507.     /**
  3508.      * @param {Object} source
  3509.      * @param {Object} type
  3510.      * @return {undefined}
  3511.      */
  3512.     self.ph = function(source, type) {
  3513.       if (source) {
  3514.         if (self.vd(source)) {
  3515.           source.removeAllListeners(type);
  3516.         } else {
  3517.           var properties = self.zd(source);
  3518.           if (properties) {
  3519.             /** @type {number} */
  3520.             var d = 0;
  3521.             var submit = type && type.toString();
  3522.             var key;
  3523.             for (key in properties.Ad) {
  3524.               if (!submit || key == submit) {
  3525.                 var codeSegments = properties.Ad[key].concat();
  3526.                 /** @type {number} */
  3527.                 var i = 0;
  3528.                 for (;i < codeSegments.length;++i) {
  3529.                   if (self.Cd(codeSegments[i])) {
  3530.                     ++d;
  3531.                   }
  3532.                 }
  3533.               }
  3534.             }
  3535.           }
  3536.         }
  3537.       }
  3538.     };
  3539.     /**
  3540.      * @param {string} name
  3541.      * @return {?}
  3542.      */
  3543.     attachEvent = function(name) {
  3544.       return name in args ? args[name] : args[name] = "on" + name;
  3545.     };
  3546.     /**
  3547.      * @param {?} attributes
  3548.      * @param {Object} optgroup
  3549.      * @param {?} attr
  3550.      * @return {undefined}
  3551.      */
  3552.     self.Ed = function(attributes, optgroup, attr) {
  3553.       if (self.vd(attributes)) {
  3554.         self.Dd(attributes, optgroup, false, attr);
  3555.       } else {
  3556.         isArray(attributes, optgroup, false, attr);
  3557.       }
  3558.     };
  3559.     /**
  3560.      * @param {?} v
  3561.      * @param {Object} t
  3562.      * @param {boolean} recurring
  3563.      * @param {?} item
  3564.      * @return {?}
  3565.      */
  3566.     isArray = function(v, t, recurring, item) {
  3567.       /** @type {boolean} */
  3568.       var r = true;
  3569.       if (v = self.zd(v)) {
  3570.         if (t = v.Ad[t.toString()]) {
  3571.           t = t.concat();
  3572.           /** @type {number} */
  3573.           v = 0;
  3574.           for (;v < t.length;v++) {
  3575.             var val = t[v];
  3576.             if (val) {
  3577.               if (val.Ns == recurring) {
  3578.                 if (!val.removed) {
  3579.                   val = objectToString(val, item);
  3580.                   /** @type {boolean} */
  3581.                   r = r && false !== val;
  3582.                 }
  3583.               }
  3584.             }
  3585.           }
  3586.         }
  3587.       }
  3588.       return r;
  3589.     };
  3590.     /**
  3591.      * @param {Object} o
  3592.      * @param {?} d
  3593.      * @return {?}
  3594.      */
  3595.     objectToString = function(o, d) {
  3596.       var callback = o.listener;
  3597.       var T = o.ay || o.src;
  3598.       if (o.fw) {
  3599.         self.Cd(o);
  3600.       }
  3601.       return callback.call(T, d);
  3602.     };
  3603.     /**
  3604.      * @param {Object} e
  3605.      * @param {string} obj
  3606.      * @return {?}
  3607.      */
  3608.     visit = function(e, obj) {
  3609.       if (e.removed) {
  3610.         return true;
  3611.       }
  3612.       if (!named) {
  3613.         var options = obj || self.aa("window.event");
  3614.         var result = new self.ud(options, this);
  3615.         /** @type {boolean} */
  3616.         var out = true;
  3617.         if (!(0 > options.keyCode || void 0 != options.returnValue)) {
  3618.           a: {
  3619.             /** @type {boolean} */
  3620.             var target = false;
  3621.             if (0 == options.keyCode) {
  3622.               try {
  3623.                 /** @type {number} */
  3624.                 options.keyCode = -1;
  3625.                 break a;
  3626.               } catch (g) {
  3627.                 /** @type {boolean} */
  3628.                 target = true;
  3629.               }
  3630.             }
  3631.             if (target || void 0 == options.returnValue) {
  3632.               /** @type {boolean} */
  3633.               options.returnValue = true;
  3634.             }
  3635.           }
  3636.           /** @type {Array} */
  3637.           options = [];
  3638.           target = result.currentTarget;
  3639.           for (;target;target = target.parentNode) {
  3640.             options.push(target);
  3641.           }
  3642.           target = e.type;
  3643.           /** @type {number} */
  3644.           var i = options.length - 1;
  3645.           for (;!result.ma && 0 <= i;i--) {
  3646.             result.currentTarget = options[i];
  3647.             var actual = isArray(options[i], target, true, result);
  3648.             out = out && actual;
  3649.           }
  3650.           /** @type {number} */
  3651.           i = 0;
  3652.           for (;!result.ma && i < options.length;i++) {
  3653.             result.currentTarget = options[i];
  3654.             actual = isArray(options[i], target, false, result);
  3655.             out = out && actual;
  3656.           }
  3657.         }
  3658.         return out;
  3659.       }
  3660.       return objectToString(e, new self.ud(obj, this));
  3661.     };
  3662.     /**
  3663.      * @param {?} obj
  3664.      * @return {?}
  3665.      */
  3666.     self.zd = function(obj) {
  3667.       obj = obj[_i];
  3668.       return obj instanceof ctor ? obj : null;
  3669.     };
  3670.     /** @type {string} */
  3671.     LISTENER_SCRIPT_DATA = "__closure_events_fn_" + (1E9 * Math.random() >>> 0);
  3672.     /**
  3673.      * @param {Function} listener
  3674.      * @return {?}
  3675.      */
  3676.     self.yd = function(listener) {
  3677.       if (self.pa(listener)) {
  3678.         return listener;
  3679.       }
  3680.       if (!listener[LISTENER_SCRIPT_DATA]) {
  3681.         /**
  3682.          * @param {?} e
  3683.          * @return {?}
  3684.          */
  3685.         listener[LISTENER_SCRIPT_DATA] = function(e) {
  3686.           return listener.handleEvent(e);
  3687.         };
  3688.       }
  3689.       return listener[LISTENER_SCRIPT_DATA];
  3690.     };
  3691.     /**
  3692.      * @return {undefined}
  3693.      */
  3694.     self.Fd = function() {
  3695.       self.wb.call(this);
  3696.       this.hj = new ctor(this);
  3697.       this.TQ = this;
  3698.       /** @type {null} */
  3699.       this.LP = null;
  3700.     };
  3701.     self.r(self.Fd, self.wb);
  3702.     /** @type {boolean} */
  3703.     self.Fd.prototype[functionName] = true;
  3704.     self.h = self.Fd.prototype;
  3705.     /**
  3706.      * @return {?}
  3707.      */
  3708.     self.h.an = function() {
  3709.       return this.LP;
  3710.     };
  3711.     /**
  3712.      * @param {?} dataAndEvents
  3713.      * @return {undefined}
  3714.      */
  3715.     self.h.Vb = function(dataAndEvents) {
  3716.       this.LP = dataAndEvents;
  3717.     };
  3718.     /**
  3719.      * @param {string} object
  3720.      * @param {Function} listener
  3721.      * @param {boolean} recurring
  3722.      * @param {Array} event
  3723.      * @return {undefined}
  3724.      */
  3725.     self.h.addEventListener = function(object, listener, recurring, event) {
  3726.       self.C(this, object, listener, recurring, event);
  3727.     };
  3728.     /**
  3729.      * @param {string} type
  3730.      * @param {Function} func
  3731.      * @param {boolean} callback
  3732.      * @param {Array} capture
  3733.      * @return {undefined}
  3734.      */
  3735.     self.h.removeEventListener = function(type, func, callback, capture) {
  3736.       self.Bd(this, type, func, callback, capture);
  3737.     };
  3738.     /**
  3739.      * @param {?} attributes
  3740.      * @return {?}
  3741.      */
  3742.     self.h.dispatchEvent = function(attributes) {
  3743.       var codeSegments;
  3744.       var item = this.an();
  3745.       if (item) {
  3746.         /** @type {Array} */
  3747.         codeSegments = [];
  3748.         for (;item;item = item.an()) {
  3749.           codeSegments.push(item);
  3750.         }
  3751.       }
  3752.       item = this.TQ;
  3753.       var optgroup = attributes.type || attributes;
  3754.       if (self.ma(attributes)) {
  3755.         attributes = new self.pd(attributes, item);
  3756.       } else {
  3757.         if (attributes instanceof self.pd) {
  3758.           attributes.target = attributes.target || item;
  3759.         } else {
  3760.           var ret = attributes;
  3761.           attributes = new self.pd(optgroup, item);
  3762.           self.rc(attributes, ret);
  3763.         }
  3764.       }
  3765.       /** @type {boolean} */
  3766.       ret = true;
  3767.       var opt_attributes;
  3768.       if (codeSegments) {
  3769.         /** @type {number} */
  3770.         var i = codeSegments.length - 1;
  3771.         for (;!attributes.ma && 0 <= i;i--) {
  3772.           opt_attributes = attributes.currentTarget = codeSegments[i];
  3773.           ret = self.Dd(opt_attributes, optgroup, true, attributes) && ret;
  3774.         }
  3775.       }
  3776.       if (!attributes.ma) {
  3777.         opt_attributes = attributes.currentTarget = item;
  3778.         ret = self.Dd(opt_attributes, optgroup, true, attributes) && ret;
  3779.         if (!attributes.ma) {
  3780.           ret = self.Dd(opt_attributes, optgroup, false, attributes) && ret;
  3781.         }
  3782.       }
  3783.       if (codeSegments) {
  3784.         /** @type {number} */
  3785.         i = 0;
  3786.         for (;!attributes.ma && i < codeSegments.length;i++) {
  3787.           opt_attributes = attributes.currentTarget = codeSegments[i];
  3788.           ret = self.Dd(opt_attributes, optgroup, false, attributes) && ret;
  3789.         }
  3790.       }
  3791.       return ret;
  3792.     };
  3793.     /**
  3794.      * @return {undefined}
  3795.      */
  3796.     self.h.Ha = function() {
  3797.       self.Fd.Ba.Ha.call(this);
  3798.       this.removeAllListeners();
  3799.       /** @type {null} */
  3800.       this.LP = null;
  3801.     };
  3802.     /**
  3803.      * @param {?} target
  3804.      * @param {Array} type
  3805.      * @param {Function} f
  3806.      * @param {Array} selector
  3807.      * @return {?}
  3808.      */
  3809.     self.h.listen = function(target, type, f, selector) {
  3810.       return this.hj.add(String(target), type, false, f, selector);
  3811.     };
  3812.     /**
  3813.      * @param {?} target
  3814.      * @param {Object} listener
  3815.      * @param {boolean} handler
  3816.      * @param {Array} opt_capt
  3817.      * @return {?}
  3818.      */
  3819.     self.h.unlisten = function(target, listener, handler, opt_capt) {
  3820.       return this.hj.remove(String(target), listener, handler, opt_capt);
  3821.     };
  3822.     /**
  3823.      * @param {Object} type
  3824.      * @return {?}
  3825.      */
  3826.     self.h.removeAllListeners = function(type) {
  3827.       return this.hj ? this.hj.removeAll(type) : 0;
  3828.     };
  3829.     /**
  3830.      * @param {?} opt_attributes
  3831.      * @param {Object} name
  3832.      * @param {(boolean|number|string)} attributes
  3833.      * @param {?} id
  3834.      * @return {?}
  3835.      */
  3836.     self.Dd = function(opt_attributes, name, attributes, id) {
  3837.       name = opt_attributes.hj.Ad[String(name)];
  3838.       if (!name) {
  3839.         return true;
  3840.       }
  3841.       name = name.concat();
  3842.       /** @type {boolean} */
  3843.       var rv = true;
  3844.       /** @type {number} */
  3845.       var i = 0;
  3846.       for (;i < name.length;++i) {
  3847.         var self = name[i];
  3848.         if (self && (!self.removed && self.Ns == attributes)) {
  3849.           var callback = self.listener;
  3850.           var T = self.ay || self.src;
  3851.           if (self.fw) {
  3852.             connect(opt_attributes.hj, self);
  3853.           }
  3854.           /** @type {boolean} */
  3855.           rv = false !== callback.call(T, id) && rv;
  3856.         }
  3857.       }
  3858.       return rv && 0 != id.tN;
  3859.     };
  3860.     /**
  3861.      * @param {string} opt_message
  3862.      * @param {?} deepDataAndEvents
  3863.      * @return {?}
  3864.      */
  3865.     self.Fd.prototype.ox = function(opt_message, deepDataAndEvents) {
  3866.       return this.hj.ox(String(opt_message), deepDataAndEvents);
  3867.     };
  3868.     var debug;
  3869.     var agree;
  3870.     /**
  3871.      * @param {?} state
  3872.      * @return {?}
  3873.      */
  3874.     self.Xb = function(state) {
  3875.       return function() {
  3876.         return state;
  3877.       };
  3878.     };
  3879.     self.Yb = self.Xb(false);
  3880.     self.Zb = self.Xb(true);
  3881.     self.Paa = self.Xb(null);
  3882.     /**
  3883.      * @param {?} fn
  3884.      * @return {?}
  3885.      */
  3886.     self.$b = function(fn) {
  3887.       return fn;
  3888.     };
  3889.     /**
  3890.      * @param {string} message
  3891.      * @return {?}
  3892.      */
  3893.     debug = function(message) {
  3894.       return function() {
  3895.         throw Error(message);
  3896.       };
  3897.     };
  3898.     /**
  3899.      * @param {Function} matcherFunction
  3900.      * @return {?}
  3901.      */
  3902.     self.oka = function(matcherFunction) {
  3903.       var start;
  3904.       /** @type {number} */
  3905.       start = start || 0;
  3906.       return function() {
  3907.         return matcherFunction.apply(this, Array.prototype.slice.call(arguments, 0, start));
  3908.       };
  3909.     };
  3910.     /**
  3911.      * @param {?} dataAndEvents
  3912.      * @return {?}
  3913.      */
  3914.     self.ac = function(dataAndEvents) {
  3915.       /** @type {Arguments} */
  3916.       var functions = arguments;
  3917.       /** @type {number} */
  3918.       var length = functions.length;
  3919.       return function() {
  3920.         var returnValue;
  3921.         /** @type {number} */
  3922.         var i = 0;
  3923.         for (;i < length;i++) {
  3924.           returnValue = functions[i].apply(this, arguments);
  3925.         }
  3926.         return returnValue;
  3927.       };
  3928.     };
  3929.     /**
  3930.      * @return {?}
  3931.      */
  3932.     agree = function() {
  3933.       var matcherFunction = plural;
  3934.       return function() {
  3935.         return!matcherFunction.apply(this, arguments);
  3936.       };
  3937.     };
  3938.     /**
  3939.      * @param {Function} parent
  3940.      * @param {?} dataAndEvents
  3941.      * @return {?}
  3942.      */
  3943.     self.Cxa = function(parent, dataAndEvents) {
  3944.       /**
  3945.        * @return {undefined}
  3946.        */
  3947.       var child = function() {
  3948.       };
  3949.       child.prototype = parent.prototype;
  3950.       child = new child;
  3951.       parent.apply(child, Array.prototype.slice.call(arguments, 1));
  3952.       return child;
  3953.     };
  3954.     /**
  3955.      * @param {?} makeIterator
  3956.      * @return {?}
  3957.      */
  3958.     self.bc = function(makeIterator) {
  3959.       /** @type {boolean} */
  3960.       var b = false;
  3961.       var callback;
  3962.       return function() {
  3963.         if (!b) {
  3964.           callback = makeIterator();
  3965.           /** @type {boolean} */
  3966.           b = true;
  3967.         }
  3968.         return callback;
  3969.       };
  3970.     };
  3971.     var compact;
  3972.     /**
  3973.      * @param {?} attributes
  3974.      * @return {?}
  3975.      */
  3976.     self.Gd = function(attributes) {
  3977.       var serializer = compact;
  3978.       return function() {
  3979.         var cache = this || self.ca;
  3980.         cache = cache.closure_memoize_cache_ || (cache.closure_memoize_cache_ = {});
  3981.         var key = serializer(self.ra(attributes), arguments);
  3982.         return cache.hasOwnProperty(key) ? cache[key] : cache[key] = attributes.apply(this, arguments);
  3983.       };
  3984.     };
  3985.     /**
  3986.      * @param {?} ref
  3987.      * @param {Object} array
  3988.      * @return {?}
  3989.      */
  3990.     compact = function(ref, array) {
  3991.       /** @type {Array} */
  3992.       var ascii = [ref];
  3993.       /** @type {number} */
  3994.       var i = array.length - 1;
  3995.       for (;0 <= i;--i) {
  3996.         ascii.push(typeof array[i], array[i]);
  3997.       }
  3998.       return ascii.join("\x0B");
  3999.     };
  4000.     /**
  4001.      * @param {(RegExp|string)} dx
  4002.      * @return {undefined}
  4003.      */
  4004.     var s = function(dx) {
  4005.       self.Fd.call(this);
  4006.       this.$d = dx || self.wc();
  4007.       if (this.ot = this.Tia()) {
  4008.         this.$ = self.C(this.$d.pb, this.ot, (0, self.p)(this.ia, this));
  4009.       }
  4010.     };
  4011.     self.r(s, self.Fd);
  4012.     self.h = s.prototype;
  4013.     self.h.Tia = self.Gd(function() {
  4014.       var any = this.isSupported();
  4015.       /** @type {boolean} */
  4016.       var whitespace = "hidden" != this.PB();
  4017.       return any ? whitespace ? ((self.nd() || "") + "visibilitychange").toLowerCase() : "visibilitychange" : null;
  4018.     });
  4019.     self.h.PB = self.Gd(function() {
  4020.       return inspect("hidden", this.$d.pb);
  4021.     });
  4022.     self.h.ija = self.Gd(function() {
  4023.       return inspect("visibilityState", this.$d.pb);
  4024.     });
  4025.     /**
  4026.      * @return {?}
  4027.      */
  4028.     self.h.isSupported = function() {
  4029.       return!!this.PB();
  4030.     };
  4031.     /**
  4032.      * @return {?}
  4033.      */
  4034.     self.h.Ou = function() {
  4035.       return!!this.$d.pb[this.PB()];
  4036.     };
  4037.     /**
  4038.      * @param {Object} dataAndEvents
  4039.      * @return {?}
  4040.      */
  4041.     self.Mba = function(dataAndEvents) {
  4042.       return dataAndEvents.isSupported() ? dataAndEvents.$d.pb[dataAndEvents.ija()] : null;
  4043.     };
  4044.     /**
  4045.      * @return {undefined}
  4046.      */
  4047.     s.prototype.ia = function() {
  4048.       self.Mba(this);
  4049.       var type = new initial(this.Ou());
  4050.       this.dispatchEvent(type);
  4051.     };
  4052.     /**
  4053.      * @return {undefined}
  4054.      */
  4055.     s.prototype.Ha = function() {
  4056.       self.Cd(this.$);
  4057.       s.Ba.Ha.call(this);
  4058.     };
  4059.     /**
  4060.      * @param {boolean} array
  4061.      * @return {undefined}
  4062.      */
  4063.     var initial = function(array) {
  4064.       self.pd.call(this, "visibilitychange");
  4065.       /** @type {boolean} */
  4066.       this.hidden = array;
  4067.     };
  4068.     self.r(initial, self.pd);
  4069.     /**
  4070.      * @param {?} opt_attributes
  4071.      * @param {?} right
  4072.      * @param {number} bottom
  4073.      * @param {?} left
  4074.      * @return {undefined}
  4075.      */
  4076.     self.Jd = function(opt_attributes, right, bottom, left) {
  4077.       this.top = opt_attributes;
  4078.       this.right = right;
  4079.       /** @type {number} */
  4080.       this.bottom = bottom;
  4081.       this.left = left;
  4082.     };
  4083.     self.h = self.Jd.prototype;
  4084.     /**
  4085.      * @return {?}
  4086.      */
  4087.     self.h.Ab = function() {
  4088.       return this.right - this.left;
  4089.     };
  4090.     /**
  4091.      * @return {?}
  4092.      */
  4093.     self.h.ub = function() {
  4094.       return this.bottom - this.top;
  4095.     };
  4096.     /**
  4097.      * @return {?}
  4098.      */
  4099.     self.h.clone = function() {
  4100.       return new self.Jd(this.top, this.right, this.bottom, this.left);
  4101.     };
  4102.     /**
  4103.      * @param {Object} region
  4104.      * @return {?}
  4105.      */
  4106.     self.h.contains = function(region) {
  4107.       return this && region ? region instanceof self.Jd ? region.left >= this.left && (region.right <= this.right && (region.top >= this.top && region.bottom <= this.bottom)) : region.x >= this.left && (region.x <= this.right && (region.y >= this.top && region.y <= this.bottom)) : false;
  4108.     };
  4109.     /**
  4110.      * @return {?}
  4111.      */
  4112.     self.h.ceil = function() {
  4113.       /** @type {number} */
  4114.       this.top = Math.ceil(this.top);
  4115.       /** @type {number} */
  4116.       this.right = Math.ceil(this.right);
  4117.       /** @type {number} */
  4118.       this.bottom = Math.ceil(this.bottom);
  4119.       /** @type {number} */
  4120.       this.left = Math.ceil(this.left);
  4121.       return this;
  4122.     };
  4123.     /**
  4124.      * @return {?}
  4125.      */
  4126.     self.h.floor = function() {
  4127.       /** @type {number} */
  4128.       this.top = Math.floor(this.top);
  4129.       /** @type {number} */
  4130.       this.right = Math.floor(this.right);
  4131.       /** @type {number} */
  4132.       this.bottom = Math.floor(this.bottom);
  4133.       /** @type {number} */
  4134.       this.left = Math.floor(this.left);
  4135.       return this;
  4136.     };
  4137.     /**
  4138.      * @return {?}
  4139.      */
  4140.     self.h.round = function() {
  4141.       /** @type {number} */
  4142.       this.top = Math.round(this.top);
  4143.       /** @type {number} */
  4144.       this.right = Math.round(this.right);
  4145.       /** @type {number} */
  4146.       this.bottom = Math.round(this.bottom);
  4147.       /** @type {number} */
  4148.       this.left = Math.round(this.left);
  4149.       return this;
  4150.     };
  4151.     /**
  4152.      * @param {?} tx
  4153.      * @param {?} t
  4154.      * @return {?}
  4155.      */
  4156.     self.h.translate = function(tx, t) {
  4157.       if (tx instanceof self.dc) {
  4158.         this.left += tx.x;
  4159.         this.right += tx.x;
  4160.         this.top += tx.y;
  4161.         this.bottom += tx.y;
  4162.       } else {
  4163.         this.left += tx;
  4164.         this.right += tx;
  4165.         if (self.oa(t)) {
  4166.           this.top += t;
  4167.           this.bottom += t;
  4168.         }
  4169.       }
  4170.       return this;
  4171.     };
  4172.     /**
  4173.      * @param {?} sx
  4174.      * @param {?} opt_sy
  4175.      * @return {?}
  4176.      */
  4177.     self.h.scale = function(sx, opt_sy) {
  4178.       var sy = self.oa(opt_sy) ? opt_sy : sx;
  4179.       this.left *= sx;
  4180.       this.right *= sx;
  4181.       this.top *= sy;
  4182.       this.bottom *= sy;
  4183.       return this;
  4184.     };
  4185.     /**
  4186.      * @param {boolean} recurring
  4187.      * @param {?} top
  4188.      * @param {?} pixelWidth
  4189.      * @param {?} pixelHeight
  4190.      * @return {undefined}
  4191.      */
  4192.     self.Kd = function(recurring, top, pixelWidth, pixelHeight) {
  4193.       /** @type {boolean} */
  4194.       this.left = recurring;
  4195.       this.top = top;
  4196.       this.width = pixelWidth;
  4197.       this.height = pixelHeight;
  4198.     };
  4199.     /**
  4200.      * @return {?}
  4201.      */
  4202.     self.Kd.prototype.clone = function() {
  4203.       return new self.Kd(this.left, this.top, this.width, this.height);
  4204.     };
  4205.     /**
  4206.      * @param {?} itemBounds
  4207.      * @return {?}
  4208.      */
  4209.     self.Ld = function(itemBounds) {
  4210.       return new self.Jd(itemBounds.top, itemBounds.left + itemBounds.width, itemBounds.top + itemBounds.height, itemBounds.left);
  4211.     };
  4212.     /**
  4213.      * @param {Object} target
  4214.      * @return {?}
  4215.      */
  4216.     self.Kd.prototype.contains = function(target) {
  4217.       return target instanceof self.Kd ? this.left <= target.left && (this.left + this.width >= target.left + target.width && (this.top <= target.top && this.top + this.height >= target.top + target.height)) : target.x >= this.left && (target.x <= this.left + this.width && (target.y >= this.top && target.y <= this.top + this.height));
  4218.     };
  4219.     /**
  4220.      * @param {?} box
  4221.      * @param {Object} coord
  4222.      * @return {?}
  4223.      */
  4224.     var getBounds = function(box, coord) {
  4225.       /** @type {number} */
  4226.       var z0 = coord.x < box.left ? box.left - coord.x : Math.max(coord.x - (box.left + box.width), 0);
  4227.       /** @type {number} */
  4228.       var z1 = coord.y < box.top ? box.top - coord.y : Math.max(coord.y - (box.top + box.height), 0);
  4229.       return z0 * z0 + z1 * z1;
  4230.     };
  4231.     /**
  4232.      * @param {Object} y
  4233.      * @return {?}
  4234.      */
  4235.     self.Kd.prototype.distance = function(y) {
  4236.       return Math.sqrt(getBounds(this, y));
  4237.     };
  4238.     /**
  4239.      * @return {?}
  4240.      */
  4241.     self.Kd.prototype.Ie = function() {
  4242.       return new self.ec(this.width, this.height);
  4243.     };
  4244.     /**
  4245.      * @param {?} item
  4246.      * @return {?}
  4247.      */
  4248.     self.yda = function(item) {
  4249.       return new self.dc(item.left, item.top);
  4250.     };
  4251.     self.h = self.Kd.prototype;
  4252.     /**
  4253.      * @return {?}
  4254.      */
  4255.     self.h.getCenter = function() {
  4256.       return new self.dc(this.left + this.width / 2, this.top + this.height / 2);
  4257.     };
  4258.     /**
  4259.      * @return {?}
  4260.      */
  4261.     self.h.ceil = function() {
  4262.       /** @type {number} */
  4263.       this.left = Math.ceil(this.left);
  4264.       /** @type {number} */
  4265.       this.top = Math.ceil(this.top);
  4266.       /** @type {number} */
  4267.       this.width = Math.ceil(this.width);
  4268.       /** @type {number} */
  4269.       this.height = Math.ceil(this.height);
  4270.       return this;
  4271.     };
  4272.     /**
  4273.      * @return {?}
  4274.      */
  4275.     self.h.floor = function() {
  4276.       /** @type {number} */
  4277.       this.left = Math.floor(this.left);
  4278.       /** @type {number} */
  4279.       this.top = Math.floor(this.top);
  4280.       /** @type {number} */
  4281.       this.width = Math.floor(this.width);
  4282.       /** @type {number} */
  4283.       this.height = Math.floor(this.height);
  4284.       return this;
  4285.     };
  4286.     /**
  4287.      * @return {?}
  4288.      */
  4289.     self.h.round = function() {
  4290.       /** @type {number} */
  4291.       this.left = Math.round(this.left);
  4292.       /** @type {number} */
  4293.       this.top = Math.round(this.top);
  4294.       /** @type {number} */
  4295.       this.width = Math.round(this.width);
  4296.       /** @type {number} */
  4297.       this.height = Math.round(this.height);
  4298.       return this;
  4299.     };
  4300.     /**
  4301.      * @param {?} tx
  4302.      * @param {?} t
  4303.      * @return {?}
  4304.      */
  4305.     self.h.translate = function(tx, t) {
  4306.       if (tx instanceof self.dc) {
  4307.         this.left += tx.x;
  4308.         this.top += tx.y;
  4309.       } else {
  4310.         this.left += tx;
  4311.         if (self.oa(t)) {
  4312.           this.top += t;
  4313.         }
  4314.       }
  4315.       return this;
  4316.     };
  4317.     /**
  4318.      * @param {?} sx
  4319.      * @param {?} opt_sy
  4320.      * @return {?}
  4321.      */
  4322.     self.h.scale = function(sx, opt_sy) {
  4323.       var sy = self.oa(opt_sy) ? opt_sy : sx;
  4324.       this.left *= sx;
  4325.       this.width *= sx;
  4326.       this.top *= sy;
  4327.       this.height *= sy;
  4328.       return this;
  4329.     };
  4330.     var results;
  4331.     var getComputedStyle;
  4332.     var getOffset;
  4333.     var px;
  4334.     var rect;
  4335.     var property;
  4336.     var computedStyle;
  4337.     var setShortStyleProperty;
  4338.     var wellKnownWords;
  4339.     var getPixelValue;
  4340.     /**
  4341.      * @param {Element} node
  4342.      * @param {?} attributes
  4343.      * @param {Element} element
  4344.      * @return {undefined}
  4345.      */
  4346.     self.D = function(node, attributes, element) {
  4347.       if (self.ma(attributes)) {
  4348.         if (attributes = getComputedStyle(node, attributes)) {
  4349.           /** @type {Element} */
  4350.           node.style[attributes] = element;
  4351.         }
  4352.       } else {
  4353.         var name;
  4354.         for (name in attributes) {
  4355.           /** @type {Element} */
  4356.           element = node;
  4357.           var value = attributes[name];
  4358.           var s = getComputedStyle(element, name);
  4359.           if (s) {
  4360.             element.style[s] = value;
  4361.           }
  4362.         }
  4363.       }
  4364.     };
  4365.     results = {};
  4366.     /**
  4367.      * @param {Element} element
  4368.      * @param {?} property
  4369.      * @return {?}
  4370.      */
  4371.     getComputedStyle = function(element, property) {
  4372.       var result = results[property];
  4373.       if (!result) {
  4374.         var prop = self.Ra(property);
  4375.         result = prop;
  4376.         if (void 0 === element.style[prop]) {
  4377.           prop = self.nd() + self.Ta(prop);
  4378.           if (void 0 !== element.style[prop]) {
  4379.             result = prop;
  4380.           }
  4381.         }
  4382.         results[property] = result;
  4383.       }
  4384.       return result;
  4385.     };
  4386.     /**
  4387.      * @param {Element} element
  4388.      * @param {?} property
  4389.      * @return {?}
  4390.      */
  4391.     self.Md = function(element, property) {
  4392.       var actual = element.style[self.Ra(property)];
  4393.       return "undefined" !== typeof actual ? actual : element.style[getComputedStyle(element, property)] || "";
  4394.     };
  4395.     /**
  4396.      * @param {?} opt_attributes
  4397.      * @param {Object} name
  4398.      * @return {?}
  4399.      */
  4400.     self.Nd = function(opt_attributes, name) {
  4401.       var s = self.vc(opt_attributes);
  4402.       return s.defaultView && (s.defaultView.getComputedStyle && (s = s.defaultView.getComputedStyle(opt_attributes, null))) ? s[name] || (s.getPropertyValue(name) || "") : "";
  4403.     };
  4404.     /**
  4405.      * @param {?} attributes
  4406.      * @param {Object} optgroup
  4407.      * @return {?}
  4408.      */
  4409.     self.Od = function(attributes, optgroup) {
  4410.       return self.Nd(attributes, optgroup) || ((attributes.currentStyle ? attributes.currentStyle[optgroup] : null) || attributes.style && attributes.style[optgroup]);
  4411.     };
  4412.     /**
  4413.      * @param {?} attr
  4414.      * @return {?}
  4415.      */
  4416.     self.Pd = function(attr) {
  4417.       return self.Od(attr, "position");
  4418.     };
  4419.     /**
  4420.      * @param {string} object
  4421.      * @return {?}
  4422.      */
  4423.     self.Rba = function(object) {
  4424.       var property;
  4425.       a: {
  4426.         property = self.Ra("transform");
  4427.         if (void 0 === object.style[property] && (property = self.nd() + self.Ta(property), void 0 !== object.style[property])) {
  4428.           property = self.od() + "-transform";
  4429.           break a;
  4430.         }
  4431.         /** @type {string} */
  4432.         property = "transform";
  4433.       }
  4434.       return self.Od(object, property) || self.Od(object, "transform");
  4435.     };
  4436.     /**
  4437.      * @param {Element} el
  4438.      * @param {?} y
  4439.      * @param {?} opt_arg2
  4440.      * @return {undefined}
  4441.      */
  4442.     self.Rd = function(el, y, opt_arg2) {
  4443.       var pos;
  4444.       if (y instanceof self.dc) {
  4445.         pos = y.x;
  4446.         y = y.y;
  4447.       } else {
  4448.         pos = y;
  4449.         y = opt_arg2;
  4450.       }
  4451.       el.style.left = px(pos, false);
  4452.       el.style.top = px(y, false);
  4453.     };
  4454.     /**
  4455.      * @param {Element} item
  4456.      * @return {?}
  4457.      */
  4458.     self.Sd = function(item) {
  4459.       return new self.dc(item.offsetLeft, item.offsetTop);
  4460.     };
  4461.     /**
  4462.      * @param {Object} e
  4463.      * @return {?}
  4464.      */
  4465.     self.Td = function(e) {
  4466.       e = e ? self.vc(e) : window.document;
  4467.       return!self.Aa || (9 <= self.Jaa || self.jd(self.wc(e))) ? e.documentElement : e.body;
  4468.     };
  4469.     /**
  4470.      * @param {Object} e
  4471.      * @return {?}
  4472.      */
  4473.     self.ti = function(e) {
  4474.       var b = e.body;
  4475.       e = e.documentElement;
  4476.       return new self.dc(b.scrollLeft || e.scrollLeft, b.scrollTop || e.scrollTop);
  4477.     };
  4478.     /**
  4479.      * @param {Object} d
  4480.      * @return {?}
  4481.      */
  4482.     getOffset = function(d) {
  4483.       var offset;
  4484.       try {
  4485.         offset = d.getBoundingClientRect();
  4486.       } catch (c) {
  4487.         return{
  4488.           left : 0,
  4489.           top : 0,
  4490.           right : 0,
  4491.           bottom : 0
  4492.         };
  4493.       }
  4494.       if (self.Aa) {
  4495.         if (d.ownerDocument.body) {
  4496.           d = d.ownerDocument;
  4497.           offset.left -= d.documentElement.clientLeft + d.body.clientLeft;
  4498.           offset.top -= d.documentElement.clientTop + d.body.clientTop;
  4499.         }
  4500.       }
  4501.       return offset;
  4502.     };
  4503.     /**
  4504.      * @param {Object} parent
  4505.      * @return {?}
  4506.      */
  4507.     self.Tba = function(parent) {
  4508.       if (self.Aa && !(8 <= self.Jaa)) {
  4509.         return parent.offsetParent;
  4510.       }
  4511.       var doc = self.vc(parent);
  4512.       var position = self.Od(parent, "position");
  4513.       /** @type {boolean} */
  4514.       var skipStatic = "fixed" == position || "absolute" == position;
  4515.       parent = parent.parentNode;
  4516.       for (;parent && parent != doc;parent = parent.parentNode) {
  4517.         if (11 == parent.nodeType && (parent.host && (parent = parent.host)), position = self.Od(parent, "position"), skipStatic = skipStatic && ("static" == position && (parent != doc.documentElement && parent != doc.body)), !skipStatic && (parent.scrollWidth > parent.clientWidth || (parent.scrollHeight > parent.clientHeight || ("fixed" == position || ("absolute" == position || "relative" == position))))) {
  4518.           return parent;
  4519.         }
  4520.       }
  4521.       return null;
  4522.     };
  4523.     /**
  4524.      * @param {?} opt_attributes
  4525.      * @return {?}
  4526.      */
  4527.     self.Hk = function(opt_attributes) {
  4528.       var visibleRect = new self.Jd(0, window.Infinity, window.Infinity, 0);
  4529.       var node = self.wc(opt_attributes);
  4530.       var scrollX = node.pb.body;
  4531.       var de = node.pb.documentElement;
  4532.       var scrollY = self.ld(node);
  4533.       for (;opt_attributes = self.Tba(opt_attributes);) {
  4534.         if (!(self.Aa && 0 == opt_attributes.clientWidth || self.Pb && (0 == opt_attributes.clientHeight && opt_attributes == scrollX)) && (opt_attributes != scrollX && (opt_attributes != de && "visible" != self.Od(opt_attributes, "overflow")))) {
  4535.           var pos = self.Ud(opt_attributes);
  4536.           var client = new self.dc(opt_attributes.clientLeft, opt_attributes.clientTop);
  4537.           pos.x += client.x;
  4538.           pos.y += client.y;
  4539.           /** @type {number} */
  4540.           visibleRect.top = Math.max(visibleRect.top, pos.y);
  4541.           /** @type {number} */
  4542.           visibleRect.right = Math.min(visibleRect.right, pos.x + opt_attributes.clientWidth);
  4543.           /** @type {number} */
  4544.           visibleRect.bottom = Math.min(visibleRect.bottom, pos.y + opt_attributes.clientHeight);
  4545.           /** @type {number} */
  4546.           visibleRect.left = Math.max(visibleRect.left, pos.x);
  4547.         }
  4548.       }
  4549.       scrollX = scrollY.scrollLeft;
  4550.       scrollY = scrollY.scrollTop;
  4551.       /** @type {number} */
  4552.       visibleRect.left = Math.max(visibleRect.left, scrollX);
  4553.       /** @type {number} */
  4554.       visibleRect.top = Math.max(visibleRect.top, scrollY);
  4555.       node = self.Cc(self.Lb(node));
  4556.       /** @type {number} */
  4557.       visibleRect.right = Math.min(visibleRect.right, scrollX + node.width);
  4558.       /** @type {number} */
  4559.       visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + node.height);
  4560.       return 0 <= visibleRect.top && (0 <= visibleRect.left && (visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left)) ? visibleRect : null;
  4561.     };
  4562.     /**
  4563.      * @param {?} v
  4564.      * @return {?}
  4565.      */
  4566.     self.Ud = function(v) {
  4567.       var position = self.vc(v);
  4568.       var offsetCoordinate = new self.dc(0, 0);
  4569.       var val = self.Td(position);
  4570.       if (v == val) {
  4571.         return offsetCoordinate;
  4572.       }
  4573.       v = getOffset(v);
  4574.       position = self.md(self.wc(position));
  4575.       offsetCoordinate.x = v.left + position.x;
  4576.       offsetCoordinate.y = v.top + position.y;
  4577.       return offsetCoordinate;
  4578.     };
  4579.     /**
  4580.      * @param {?} part
  4581.      * @return {?}
  4582.      */
  4583.     self.Vd = function(part) {
  4584.       return self.Ud(part).x;
  4585.     };
  4586.     /**
  4587.      * @param {?} arg
  4588.      * @return {?}
  4589.      */
  4590.     self.Wd = function(arg) {
  4591.       return self.Ud(arg).y;
  4592.     };
  4593.     /**
  4594.      * @param {Object} a
  4595.      * @param {Object} b
  4596.      * @return {?}
  4597.      */
  4598.     self.Yd = function(a, b) {
  4599.       var ap = self.Xd(a);
  4600.       var bp = self.Xd(b);
  4601.       return new self.dc(ap.x - bp.x, ap.y - bp.y);
  4602.     };
  4603.     /**
  4604.      * @param {Object} elm
  4605.      * @return {?}
  4606.      */
  4607.     self.Uba = function(elm) {
  4608.       elm = getOffset(elm);
  4609.       return new self.dc(elm.left, elm.top);
  4610.     };
  4611.     /**
  4612.      * @param {Object} e
  4613.      * @return {?}
  4614.      */
  4615.     self.Xd = function(e) {
  4616.       if (1 == e.nodeType) {
  4617.         return self.Uba(e);
  4618.       }
  4619.       e = e.changedTouches ? e.changedTouches[0] : e;
  4620.       return new self.dc(e.clientX, e.clientY);
  4621.     };
  4622.     /**
  4623.      * @param {Array} bytes
  4624.      * @param {Object} w
  4625.      * @param {(Object|string)} h
  4626.      * @return {undefined}
  4627.      */
  4628.     self.be = function(bytes, w, h) {
  4629.       if (w instanceof self.ec) {
  4630.         h = w.height;
  4631.         w = w.width;
  4632.       } else {
  4633.         if (void 0 == h) {
  4634.           throw Error("e");
  4635.         }
  4636.       }
  4637.       self.$d(bytes, w);
  4638.       self.ae(bytes, h);
  4639.     };
  4640.     /**
  4641.      * @param {(number|string)} value
  4642.      * @param {boolean} recurring
  4643.      * @return {?}
  4644.      */
  4645.     px = function(value, recurring) {
  4646.       if ("number" == typeof value) {
  4647.         /** @type {string} */
  4648.         value = (recurring ? Math.round(value) : value) + "px";
  4649.       }
  4650.       return value;
  4651.     };
  4652.     /**
  4653.      * @param {Array} n
  4654.      * @param {string} height
  4655.      * @return {undefined}
  4656.      */
  4657.     self.ae = function(n, height) {
  4658.       n.style.height = px(height, true);
  4659.     };
  4660.     /**
  4661.      * @param {Array} buffer
  4662.      * @param {string} width
  4663.      * @return {undefined}
  4664.      */
  4665.     self.$d = function(buffer, width) {
  4666.       buffer.style.width = px(width, true);
  4667.     };
  4668.     /**
  4669.      * @param {string} obj
  4670.      * @return {?}
  4671.      */
  4672.     self.ce = function(obj) {
  4673.       var getActual = rect;
  4674.       if ("none" != self.Od(obj, "display")) {
  4675.         return getActual(obj);
  4676.       }
  4677.       var style = obj.style;
  4678.       var originalDisplay = style.display;
  4679.       var originalVisibility = style.visibility;
  4680.       var originalPosition = style.position;
  4681.       /** @type {string} */
  4682.       style.visibility = "hidden";
  4683.       /** @type {string} */
  4684.       style.position = "absolute";
  4685.       /** @type {string} */
  4686.       style.display = "inline";
  4687.       obj = getActual(obj);
  4688.       style.display = originalDisplay;
  4689.       style.position = originalPosition;
  4690.       style.visibility = originalVisibility;
  4691.       return obj;
  4692.     };
  4693.     /**
  4694.      * @param {Object} box
  4695.      * @return {?}
  4696.      */
  4697.     rect = function(box) {
  4698.       var width = box.offsetWidth;
  4699.       var height = box.offsetHeight;
  4700.       var d = self.Pb && (!width && !height);
  4701.       return self.Uf(width) && !d || !box.getBoundingClientRect ? new self.ec(width, height) : (box = getOffset(box), new self.ec(box.right - box.left, box.bottom - box.top));
  4702.     };
  4703.     /**
  4704.      * @param {Object} css
  4705.      * @return {?}
  4706.      */
  4707.     self.ee = function(css) {
  4708.       var m = self.Ud(css);
  4709.       css = self.ce(css);
  4710.       return new self.Kd(m.x, m.y, css.width, css.height);
  4711.     };
  4712.     /**
  4713.      * @param {Element} el
  4714.      * @param {number} value
  4715.      * @return {undefined}
  4716.      */
  4717.     self.fe = function(el, value) {
  4718.       var style = el.style;
  4719.       if ("opacity" in style) {
  4720.         /** @type {number} */
  4721.         style.opacity = value;
  4722.       } else {
  4723.         if ("MozOpacity" in style) {
  4724.           /** @type {number} */
  4725.           style.MozOpacity = value;
  4726.         } else {
  4727.           if ("filter" in style) {
  4728.             /** @type {string} */
  4729.             style.filter = "" === value ? "" : "alpha(opacity=" + 100 * value + ")";
  4730.           }
  4731.         }
  4732.       }
  4733.     };
  4734.     /**
  4735.      * @param {Element} d
  4736.      * @param {boolean} b
  4737.      * @return {undefined}
  4738.      */
  4739.     self.E = function(d, b) {
  4740.       /** @type {string} */
  4741.       d.style.display = b ? "" : "none";
  4742.     };
  4743.     /**
  4744.      * @param {?} obj
  4745.      * @return {?}
  4746.      */
  4747.     self.ge = function(obj) {
  4748.       return "none" != obj.style.display;
  4749.     };
  4750.     /**
  4751.      * @param {?} funcToCall
  4752.      * @param {?} i
  4753.      * @return {undefined}
  4754.      */
  4755.     self.he = function(funcToCall, i) {
  4756.       var target = self.wc(i);
  4757.       /** @type {null} */
  4758.       var m = null;
  4759.       var item = target.pb;
  4760.       if (self.Aa && item.createStyleSheet) {
  4761.         m = item.createStyleSheet();
  4762.         self.Wba(m, funcToCall);
  4763.       } else {
  4764.         item = self.zc(target.pb, "HEAD", void 0, void 0)[0];
  4765.         if (!item) {
  4766.           m = self.zc(target.pb, "BODY", void 0, void 0)[0];
  4767.           item = target.$("HEAD");
  4768.           m.parentNode.insertBefore(item, m);
  4769.         }
  4770.         m = target.$("STYLE");
  4771.         self.Wba(m, funcToCall);
  4772.         target.appendChild(item, m);
  4773.       }
  4774.     };
  4775.     /**
  4776.      * @param {Object} e
  4777.      * @param {?} code
  4778.      * @return {undefined}
  4779.      */
  4780.     self.Wba = function(e, code) {
  4781.       if (self.Aa && self.Uf(e.cssText)) {
  4782.         e.cssText = code;
  4783.       } else {
  4784.         e.innerHTML = code;
  4785.       }
  4786.     };
  4787.     /**
  4788.      * @param {?} attributes
  4789.      * @return {?}
  4790.      */
  4791.     self.ie = function(attributes) {
  4792.       return "rtl" == self.Od(attributes, "direction");
  4793.     };
  4794.     /** @type {(null|string)} */
  4795.     property = self.Ob ? "MozUserSelect" : self.Pb ? "WebkitUserSelect" : null;
  4796.     /**
  4797.      * @param {Node} el
  4798.      * @param {boolean} value
  4799.      * @param {boolean} elements
  4800.      * @return {undefined}
  4801.      */
  4802.     self.ke = function(el, value, elements) {
  4803.       elements = elements ? null : el.getElementsByTagName("*");
  4804.       if (property) {
  4805.         if (value = value ? "none" : "", el.style && (el.style[property] = value), elements) {
  4806.           /** @type {number} */
  4807.           el = 0;
  4808.           var element;
  4809.           for (;element = elements[el];el++) {
  4810.             if (element.style) {
  4811.               /** @type {boolean} */
  4812.               element.style[property] = value;
  4813.             }
  4814.           }
  4815.         }
  4816.       } else {
  4817.         if (self.Aa || self.Mb) {
  4818.           if (value = value ? "on" : "", el.setAttribute("unselectable", value), elements) {
  4819.             /** @type {number} */
  4820.             el = 0;
  4821.             for (;element = elements[el];el++) {
  4822.               element.setAttribute("unselectable", value);
  4823.             }
  4824.           }
  4825.         }
  4826.       }
  4827.     };
  4828.     /**
  4829.      * @param {Object} item
  4830.      * @return {?}
  4831.      */
  4832.     self.Yba = function(item) {
  4833.       return new self.ec(item.offsetWidth, item.offsetHeight);
  4834.     };
  4835.     /**
  4836.      * @param {Object} a
  4837.      * @return {?}
  4838.      */
  4839.     self.oe = function(a) {
  4840.       var value = self.vc(a);
  4841.       var b = self.Aa && a.currentStyle;
  4842.       if (b && (self.jd(self.wc(value)) && ("auto" != b.width && ("auto" != b.height && !b.boxSizing)))) {
  4843.         return value = self.le(a, b.width, "width", "pixelWidth"), a = self.le(a, b.height, "height", "pixelHeight"), new self.ec(value, a);
  4844.       }
  4845.       b = self.Yba(a);
  4846.       value = self.me(a);
  4847.       a = self.ne(a);
  4848.       return new self.ec(b.width - a.left - value.left - value.right - a.right, b.height - a.top - value.top - value.bottom - a.bottom);
  4849.     };
  4850.     /**
  4851.      * @param {Element} element
  4852.      * @param {(number|string)} value
  4853.      * @param {string} name
  4854.      * @param {string} pixelName
  4855.      * @return {?}
  4856.      */
  4857.     self.le = function(element, value, name, pixelName) {
  4858.       if (/^\d+px?$/.test(value)) {
  4859.         return(0, window.parseInt)(value, 10);
  4860.       }
  4861.       var old = element.style[name];
  4862.       var ref = element.runtimeStyle[name];
  4863.       element.runtimeStyle[name] = element.currentStyle[name];
  4864.       /** @type {(number|string)} */
  4865.       element.style[name] = value;
  4866.       value = element.style[pixelName];
  4867.       element.style[name] = old;
  4868.       element.runtimeStyle[name] = ref;
  4869.       return value;
  4870.     };
  4871.     /**
  4872.      * @param {Element} element
  4873.      * @param {string} style
  4874.      * @return {?}
  4875.      */
  4876.     computedStyle = function(element, style) {
  4877.       var value = element.currentStyle ? element.currentStyle[style] : null;
  4878.       return value ? self.le(element, value, "left", "pixelLeft") : 0;
  4879.     };
  4880.     /**
  4881.      * @param {?} attributes
  4882.      * @param {string} property
  4883.      * @return {?}
  4884.      */
  4885.     setShortStyleProperty = function(attributes, property) {
  4886.       if (self.Aa) {
  4887.         var primaryKey = computedStyle(attributes, property + "Left");
  4888.         var events = computedStyle(attributes, property + "Right");
  4889.         var values = computedStyle(attributes, property + "Top");
  4890.         var entity = computedStyle(attributes, property + "Bottom");
  4891.         return new self.Jd(values, events, entity, primaryKey);
  4892.       }
  4893.       primaryKey = self.Nd(attributes, property + "Left");
  4894.       events = self.Nd(attributes, property + "Right");
  4895.       values = self.Nd(attributes, property + "Top");
  4896.       entity = self.Nd(attributes, property + "Bottom");
  4897.       return new self.Jd((0, window.parseFloat)(values), (0, window.parseFloat)(events), (0, window.parseFloat)(entity), (0, window.parseFloat)(primaryKey));
  4898.     };
  4899.     /**
  4900.      * @param {string} v02
  4901.      * @return {?}
  4902.      */
  4903.     self.me = function(v02) {
  4904.       return setShortStyleProperty(v02, "padding");
  4905.     };
  4906.     /**
  4907.      * @param {string} opt_attributes
  4908.      * @return {?}
  4909.      */
  4910.     self.qe = function(opt_attributes) {
  4911.       return setShortStyleProperty(opt_attributes, "margin");
  4912.     };
  4913.     wellKnownWords = {
  4914.       thin : 2,
  4915.       medium : 4,
  4916.       thick : 6
  4917.     };
  4918.     /**
  4919.      * @param {Element} span
  4920.      * @param {string} prop
  4921.      * @return {?}
  4922.      */
  4923.     getPixelValue = function(span, prop) {
  4924.       if ("none" == (span.currentStyle ? span.currentStyle[prop + "Style"] : null)) {
  4925.         return 0;
  4926.       }
  4927.       var w = span.currentStyle ? span.currentStyle[prop + "Width"] : null;
  4928.       return w in wellKnownWords ? wellKnownWords[w] : self.le(span, w, "left", "pixelLeft");
  4929.     };
  4930.     /**
  4931.      * @param {?} attributes
  4932.      * @return {?}
  4933.      */
  4934.     self.ne = function(attributes) {
  4935.       if (self.Aa && !(9 <= self.Jaa)) {
  4936.         var primaryKey = getPixelValue(attributes, "borderLeft");
  4937.         var events = getPixelValue(attributes, "borderRight");
  4938.         var top = getPixelValue(attributes, "borderTop");
  4939.         attributes = getPixelValue(attributes, "borderBottom");
  4940.         return new self.Jd(top, events, attributes, primaryKey);
  4941.       }
  4942.       primaryKey = self.Nd(attributes, "borderLeftWidth");
  4943.       events = self.Nd(attributes, "borderRightWidth");
  4944.       top = self.Nd(attributes, "borderTopWidth");
  4945.       attributes = self.Nd(attributes, "borderBottomWidth");
  4946.       return new self.Jd((0, window.parseFloat)(top), (0, window.parseFloat)(events), (0, window.parseFloat)(attributes), (0, window.parseFloat)(primaryKey));
  4947.     };
  4948.     var directiveRe;
  4949.     /** @type {RegExp} */
  4950.     directiveRe = /^(\w+)?(?:\.(.+))?$/;
  4951.     self.se = self.Xb(new s);
  4952.     /**
  4953.      * @param {?} s
  4954.      * @return {?}
  4955.      */
  4956.     self.te = function(s) {
  4957.       return(self.x("xjsc") || window.document.body).appendChild(s);
  4958.     };
  4959.     /**
  4960.      * @param {string} str
  4961.      * @param {number} text
  4962.      * @return {?}
  4963.      */
  4964.     self.ue = function(str, text) {
  4965.       var matches = str.match(directiveRe);
  4966.       var li = window.document.createElement(matches[1]);
  4967.       if (matches[2]) {
  4968.         li.className = matches[2];
  4969.       }
  4970.       if (text) {
  4971.         /** @type {number} */
  4972.         li.innerHTML = text;
  4973.       }
  4974.       return li;
  4975.     };
  4976.     /**
  4977.      * @param {Object} obj
  4978.      * @param {string} sx
  4979.      * @return {undefined}
  4980.      */
  4981.     self.ve = function(obj, sx) {
  4982.       /** @type {number} */
  4983.       var i = 1;
  4984.       for (;i < arguments.length;i += 2) {
  4985.         var name = arguments[i];
  4986.         var value = arguments[i + 1];
  4987.         var style = obj.style;
  4988.         if (style && name in style) {
  4989.           style[name] = value;
  4990.         } else {
  4991.           if (name in obj) {
  4992.             obj[name] = value;
  4993.           } else {
  4994.             if (self.Cb()) {
  4995.               if (style) {
  4996.                 if ("opacity" == name) {
  4997.                   /** @type {number} */
  4998.                   obj.zoom = 1;
  4999.                   name = (style.filter || "").replace(/alpha\([^)]*\)/, "");
  5000.                   if (!(0, window.isNaN)((0, window.parseFloat)(value))) {
  5001.                     name += "alpha(opacity=" + 100 * value + ")";
  5002.                   }
  5003.                   style.filter = name;
  5004.                 }
  5005.               }
  5006.             }
  5007.           }
  5008.         }
  5009.       }
  5010.     };
  5011.     /**
  5012.      * @param {?} key
  5013.      * @param {number} dataAndEvents
  5014.      * @return {undefined}
  5015.      */
  5016.     self.we = function(key, dataAndEvents) {
  5017.       var st = self.Wd(key);
  5018.       if (0 <= st) {
  5019.         window.scrollTo(0, st + (dataAndEvents || 0));
  5020.       }
  5021.     };
  5022.     /**
  5023.      * @param {number} n
  5024.      * @param {number} funcToCall
  5025.      * @param {number} millis
  5026.      * @param {Function} deepDataAndEvents
  5027.      * @param {number} v02
  5028.      * @param {Object} e
  5029.      * @return {undefined}
  5030.      */
  5031.     self.xe = function(n, funcToCall, millis, deepDataAndEvents, v02, e) {
  5032.       var j = e ? e.scrollTop : window.pageYOffset;
  5033.       if (!(0 > n)) {
  5034.         n += funcToCall || 0;
  5035.         var imgWidth = millis || 200;
  5036.         var quietMillis = v02 || 25;
  5037.         var attachEvent = deepDataAndEvents || function(value) {
  5038.           return value;
  5039.         };
  5040.         /** @type {number} */
  5041.         var ratioSrc = imgWidth / quietMillis;
  5042.         var boxMargin = (0, self.q)();
  5043.         /**
  5044.          * @param {number} dataAndEvents
  5045.          * @return {?}
  5046.          */
  5047.         var bind = function(dataAndEvents) {
  5048.           return function() {
  5049.             if (!(dataAndEvents > ratioSrc)) {
  5050.               var udataCur = (0, self.q)();
  5051.               /** @type {number} */
  5052.               udataCur = Math.min((udataCur - boxMargin) / imgWidth, 1);
  5053.               var val = j + (n - j) * attachEvent(udataCur);
  5054.               if (e) {
  5055.                 e.scrollTop = val;
  5056.               } else {
  5057.                 window.scrollTo(0, val);
  5058.               }
  5059.               if (1 > udataCur) {
  5060.                 window.setTimeout(bind(dataAndEvents + 1), quietMillis);
  5061.               }
  5062.             }
  5063.           };
  5064.         };
  5065.         window.setTimeout(bind(1), quietMillis);
  5066.       }
  5067.     };
  5068.     var auto;
  5069.     var cca;
  5070.     var out;
  5071.     var seal;
  5072.     var abort;
  5073.     var func;
  5074.     var parseInt;
  5075.     var markup;
  5076.     var eval;
  5077.     /** @type {number} */
  5078.     auto = 0;
  5079.     /** @type {number} */
  5080.     cca = 0;
  5081.     /** @type {Array} */
  5082.     out = [];
  5083.     /**
  5084.      * @param {?} object
  5085.      * @return {?}
  5086.      */
  5087.     seal = function(object) {
  5088.       return object;
  5089.     };
  5090.     /**
  5091.      * @param {number} opt_attributes
  5092.      * @param {Object} res
  5093.      * @param {Function} dataAndEvents
  5094.      * @return {?}
  5095.      */
  5096.     self.Ae = function(opt_attributes, res, dataAndEvents) {
  5097.       /** @type {number} */
  5098.       var resLength = 0;
  5099.       var r;
  5100.       for (;r = res[resLength++];) {
  5101.         /** @type {boolean} */
  5102.         var n = "string" == typeof r[2];
  5103.         if (n) {
  5104.           r[2] = markup(r[2]);
  5105.           r[3] = markup(r[3]);
  5106.           /** @type {string} */
  5107.           r[5] = "";
  5108.         } else {
  5109.           r[5] = null == r[5] ? "px" : r[5];
  5110.         }
  5111.         r[4] = r[4] || seal;
  5112.         /** @type {boolean} */
  5113.         r[6] = n;
  5114.         self.ve(r[0], r[1], n ? (0,eval)(r[2]) : r[2] + r[5]);
  5115.       }
  5116.       var copies = {
  5117.         Lw : opt_attributes,
  5118.         /** @type {Function} */
  5119.         Zd : dataAndEvents,
  5120.         W7 : (0, self.q)(),
  5121.         Vp : res
  5122.       };
  5123.       out.push(copies);
  5124.       auto = auto || window.setInterval(func, 15);
  5125.       return{
  5126.         /**
  5127.          * @return {undefined}
  5128.          */
  5129.         finish : function() {
  5130.           if (!copies.CB) {
  5131.             /** @type {boolean} */
  5132.             copies.CB = true;
  5133.             func();
  5134.           }
  5135.         }
  5136.       };
  5137.     };
  5138.     /**
  5139.      * @return {undefined}
  5140.      */
  5141.     abort = function() {
  5142.       if (!out.length) {
  5143.         window.clearInterval(auto);
  5144.         /** @type {number} */
  5145.         auto = 0;
  5146.       }
  5147.     };
  5148.     /**
  5149.      * @return {undefined}
  5150.      */
  5151.     func = function() {
  5152.       ++cca;
  5153.       /** @type {number} */
  5154.       var index = 0;
  5155.       var sprite;
  5156.       for (;sprite = out[index++];) {
  5157.         /** @type {number} */
  5158.         var frame = (0, self.q)() - sprite.W7;
  5159.         if (frame >= sprite.Lw || sprite.CB) {
  5160.           /** @type {number} */
  5161.           var i = 0;
  5162.           var r = void 0;
  5163.           for (;r = sprite.Vp[i++];) {
  5164.             self.ve(r[0], r[1], r[6] ? (0,eval)(r[3]) : r[3] + r[5]);
  5165.           }
  5166.           /** @type {boolean} */
  5167.           sprite.CB = true;
  5168.           if (sprite.Zd) {
  5169.             sprite.Zd();
  5170.           }
  5171.           /** @type {number} */
  5172.           sprite = 0;
  5173.         } else {
  5174.           /** @type {number} */
  5175.           i = 0;
  5176.           for (;r = sprite.Vp[i++];) {
  5177.             var dir = r[4](frame / sprite.Lw);
  5178.             var date;
  5179.             if (r[6]) {
  5180.               date = parseInt(r[2][0], r[3][0], dir, true);
  5181.               var t = parseInt(r[2][1], r[3][1], dir, true);
  5182.               dir = parseInt(r[2][2], r[3][2], dir, true);
  5183.               date = (0,eval)([date, t, dir]);
  5184.             } else {
  5185.               date = parseInt(r[2], r[3], dir, "px" == r[5]);
  5186.             }
  5187.             self.ve(r[0], r[1], date + r[5]);
  5188.           }
  5189.           /** @type {number} */
  5190.           sprite = 1;
  5191.         }
  5192.         if (!sprite) {
  5193.           out.splice(--index, 1);
  5194.         }
  5195.       }
  5196.       abort();
  5197.     };
  5198.     /**
  5199.      * @param {number} value
  5200.      * @param {number} radix
  5201.      * @param {number} base
  5202.      * @param {boolean} dataAndEvents
  5203.      * @return {?}
  5204.      */
  5205.     parseInt = function(value, radix, base, dataAndEvents) {
  5206.       value += (radix - value) * base;
  5207.       return dataAndEvents ? Math.round(value) : value;
  5208.     };
  5209.     /**
  5210.      * @param {(Array|string)} spec
  5211.      * @return {?}
  5212.      */
  5213.     markup = function(spec) {
  5214.       spec = spec.match(/#(..)(..)(..)/).slice(1);
  5215.       /** @type {number} */
  5216.       var i = 0;
  5217.       for (;3 > i;++i) {
  5218.         spec[i] = (0, window.parseInt)(spec[i], 16);
  5219.       }
  5220.       return spec;
  5221.     };
  5222.     /**
  5223.      * @param {Array} vals
  5224.      * @return {?}
  5225.      */
  5226.     eval = function(vals) {
  5227.       return "rgb(" + vals.join(",") + ")";
  5228.     };
  5229.     var attrFn;
  5230.     var min;
  5231.     var plural;
  5232.     /**
  5233.      * @param {Object} ev
  5234.      * @return {undefined}
  5235.      */
  5236.     self.ij = function(ev) {
  5237.       if (ev) {
  5238.         this.$ = self.pc(ev.$);
  5239.         this.ia = self.nb(ev.ia);
  5240.       } else {
  5241.         this.$ = {};
  5242.         /** @type {Array} */
  5243.         this.ia = [];
  5244.       }
  5245.     };
  5246.     attrFn = {
  5247.       ad : true,
  5248.       adsafe : true,
  5249.       adtest : true,
  5250.       "adtest-useragent" : true,
  5251.       as_author : true,
  5252.       as_drrb : true,
  5253.       as_dt : true,
  5254.       as_epq : true,
  5255.       as_eq : true,
  5256.       as_filetype : true,
  5257.       as_ft : true,
  5258.       as_maxd : true,
  5259.       as_maxm : true,
  5260.       as_mind : true,
  5261.       as_minm : true,
  5262.       as_nhi : true,
  5263.       as_nlo : true,
  5264.       as_nloc : true,
  5265.       as_nsrc : true,
  5266.       as_occt : true,
  5267.       as_oq : true,
  5268.       as_q : true,
  5269.       as_qdr : true,
  5270.       as_rights : true,
  5271.       as_scoring : true,
  5272.       as_sitesearch : true,
  5273.       as_st : true,
  5274.       authuser : true,
  5275.       c2coff : true,
  5276.       channel : true,
  5277.       chips : true,
  5278.       complete : true,
  5279.       cr : true,
  5280.       deb : true,
  5281.       domains : true,
  5282.       e : true,
  5283.       es_th : true,
  5284.       esrch : true,
  5285.       expflags : true,
  5286.       expid : true,
  5287.       expnd : true,
  5288.       fakeads : true,
  5289.       filter : true,
  5290.       fir : true,
  5291.       fiu : true,
  5292.       flav : true,
  5293.       fll : true,
  5294.       frcnw : true,
  5295.       fspn : true,
  5296.       fz : true,
  5297.       gfns : true,
  5298.       gl : true,
  5299.       gpc : true,
  5300.       hl : true,
  5301.       host : true,
  5302.       hotel_dates : true,
  5303.       hq : true,
  5304.       igu : true,
  5305.       imgcolor : true,
  5306.       imgil : true,
  5307.       imgrefurl : true,
  5308.       imgsz : true,
  5309.       imgtype : true,
  5310.       imgurl : true,
  5311.       inlang : true,
  5312.       interests : true,
  5313.       ix : true,
  5314.       kptab : true,
  5315.       lite : true,
  5316.       lnu : true,
  5317.       lr : true,
  5318.       lrfsid : true,
  5319.       lsf : true,
  5320.       ludocid : true,
  5321.       luref : true,
  5322.       lxcar : true,
  5323.       mergelabel : true,
  5324.       meta : true,
  5325.       mid : true,
  5326.       mrestrict : true,
  5327.       near : true,
  5328.       newwindow : true,
  5329.       nfpr : true,
  5330.       nirf : true,
  5331.       noj : true,
  5332.       nomo : true,
  5333.       nord : true,
  5334.       nota : true,
  5335.       num : true,
  5336.       og : true,
  5337.       ogdeb : true,
  5338.       oll : true,
  5339.       optd : true,
  5340.       opti : true,
  5341.       optq : true,
  5342.       opts : true,
  5343.       optt : true,
  5344.       ospn : true,
  5345.       oz : true,
  5346.       plugin : true,
  5347.       prds : true,
  5348.       prmd : true,
  5349.       psgn : true,
  5350.       pstick : true,
  5351.       pws : true,
  5352.       pwst : true,
  5353.       q : true,
  5354.       qf : true,
  5355.       qr : true,
  5356.       quantum : true,
  5357.       query : true,
  5358.       rct : true,
  5359.       restrict : true,
  5360.       rflfq : true,
  5361.       rlha : true,
  5362.       rlst : true,
  5363.       sab : true,
  5364.       safe : true,
  5365.       safeui : true,
  5366.       scoring : true,
  5367.       search : true,
  5368.       site_flavored : true,
  5369.       sitesearch : true,
  5370.       skip : true,
  5371.       source_ip : true,
  5372.       sout : true,
  5373.       sp : true,
  5374.       ssui : true,
  5375.       start : true,
  5376.       stick : true,
  5377.       surl : true,
  5378.       tbas : true,
  5379.       tbm : true,
  5380.       tbs : true,
  5381.       ttsm : true,
  5382.       uid : true,
  5383.       uideb : true,
  5384.       um : true,
  5385.       useragent : true,
  5386.       userid : true,
  5387.       uuld : true,
  5388.       uule : true
  5389.     };
  5390.     self.Dda = {
  5391.       ac : true,
  5392.       action : true,
  5393.       addh : true,
  5394.       affdom : true,
  5395.       agsad : true,
  5396.       aqs : true,
  5397.       bav : true,
  5398.       bih : true,
  5399.       biw : true,
  5400.       brd : true,
  5401.       bs : true,
  5402.       bvm : true,
  5403.       cad : true,
  5404.       cd : true,
  5405.       client : true,
  5406.       changed_loc : true,
  5407.       cp : true,
  5408.       ct : true,
  5409.       ctf : true,
  5410.       ctzn : true,
  5411.       dbl : true,
  5412.       ctxs : true,
  5413.       dc : true,
  5414.       devloc : true,
  5415.       dpr : true,
  5416.       dq : true,
  5417.       ds : true,
  5418.       ech : true,
  5419.       ei : true,
  5420.       entrypoint : true,
  5421.       es_nrs : true,
  5422.       es_sm : true,
  5423.       espv : true,
  5424.       fheit : true,
  5425.       fp : true,
  5426.       gbv : true,
  5427.       gc : true,
  5428.       gcc : true,
  5429.       gcs : true,
  5430.       gko_vi : true,
  5431.       gll : true,
  5432.       gm : true,
  5433.       gr : true,
  5434.       gs_id : true,
  5435.       gs_ivs : true,
  5436.       gs_l : true,
  5437.       gs_lp : true,
  5438.       gs_mss : true,
  5439.       gs_ri : true,
  5440.       gs_rn : true,
  5441.       gs_ssp : true,
  5442.       hs : true,
  5443.       hw : true,
  5444.       ie : true,
  5445.       ig : true,
  5446.       inm : true,
  5447.       ion : true,
  5448.       kapk : true,
  5449.       lei : true,
  5450.       lsft : true,
  5451.       luul : true,
  5452.       mapsl : true,
  5453.       muul : true,
  5454.       mvs : true,
  5455.       ndsp : true,
  5456.       norc : true,
  5457.       npsic : true,
  5458.       ntyp : true,
  5459.       oe : true,
  5460.       output : true,
  5461.       oq : true,
  5462.       padb : true,
  5463.       padt : true,
  5464.       pbx : true,
  5465.       pdl : true,
  5466.       pei : true,
  5467.       pf : true,
  5468.       pjf : true,
  5469.       pnp : true,
  5470.       pq : true,
  5471.       prmdo : true,
  5472.       prog : true,
  5473.       psi : true,
  5474.       psj : true,
  5475.       qsubts : true,
  5476.       rcid : true,
  5477.       redir : true,
  5478.       redir_esc : true,
  5479.       ref : true,
  5480.       resnum : true,
  5481.       revid : true,
  5482.       rf : true,
  5483.       rlakp : true,
  5484.       rllg : true,
  5485.       rls : true,
  5486.       rlz : true,
  5487.       sa : true,
  5488.       sboxchip : true,
  5489.       sclient : true,
  5490.       se : true,
  5491.       sert : true,
  5492.       sesinv : true,
  5493.       site : true,
  5494.       sla : true,
  5495.       sns : true,
  5496.       source : true,
  5497.       sourceid : true,
  5498.       spell : true,
  5499.       spknlang : true,
  5500.       sqi : true,
  5501.       sugexp : true,
  5502.       suggest : true,
  5503.       tab : true,
  5504.       tbo : true,
  5505.       tch : true,
  5506.       tel : true,
  5507.       tok : true,
  5508.       v : true,
  5509.       ved : true,
  5510.       wf : true,
  5511.       wrapid : true,
  5512.       xhr : true,
  5513.       zx : true
  5514.     };
  5515.     /**
  5516.      * @param {?} key
  5517.      * @return {?}
  5518.      */
  5519.     min = function(key) {
  5520.       return key in attrFn ? 0 : key in self.Dda ? 1 : 2;
  5521.     };
  5522.     /**
  5523.      * @param {?} n
  5524.      * @return {?}
  5525.      */
  5526.     plural = function(n) {
  5527.       switch(min(n)) {
  5528.         case 0:
  5529.         ;
  5530.         case 1:
  5531.           return true;
  5532.         default:
  5533.           return false;
  5534.       }
  5535.     };
  5536.     /**
  5537.      * @param {Function} value
  5538.      * @return {?}
  5539.      */
  5540.     self.Wb = function(value) {
  5541.       return self.Dia(value, self.Dda);
  5542.     };
  5543.     /**
  5544.      * @param {string} value
  5545.      * @return {?}
  5546.      */
  5547.     self.vh = function(value) {
  5548.       var pos = value.indexOf("#");
  5549.       var result;
  5550.       if (-1 != pos) {
  5551.         result = self.Cia(value.substr(pos + 1));
  5552.         value = value.substr(0, pos);
  5553.       } else {
  5554.         result = new self.ij;
  5555.       }
  5556.       pos = value.indexOf("?");
  5557.       pos = -1 == pos ? new self.ij : self.Cia(value.substr(pos + 1));
  5558.       return{
  5559.         state : self.Qf(result) ? result : self.$g(pos, self.Vf(result)),
  5560.         Rd : value
  5561.       };
  5562.     };
  5563.     /**
  5564.      * @param {Object} value
  5565.      * @param {string} search
  5566.      * @param {boolean} recurring
  5567.      * @return {?}
  5568.      */
  5569.     self.Xf = function(value, search, recurring) {
  5570.       return recurring ? search.replace(/#.*$/, "") + "#" + self.Eia(value) : search.replace(/\?.*$/, "") + "?" + self.Eia(value);
  5571.     };
  5572.     /**
  5573.      * @return {?}
  5574.      */
  5575.     self.ij.prototype.toString = function() {
  5576.       return self.Eia(this);
  5577.     };
  5578.     /**
  5579.      * @param {string} tests
  5580.      * @return {?}
  5581.      */
  5582.     self.Cia = function(tests) {
  5583.       var webshims = new self.ij;
  5584.       tests = tests.split("&");
  5585.       /** @type {number} */
  5586.       var x = 0;
  5587.       for (;x < tests.length;++x) {
  5588.         var parent = tests[x].split("=");
  5589.         var i = parent[0];
  5590.         parent = parent[1];
  5591.         if (i) {
  5592.           if (plural(i)) {
  5593.             if (!(i in webshims.$)) {
  5594.               webshims.ia.push(i);
  5595.             }
  5596.           }
  5597.           webshims.$[i] = self.Uf(parent) ? parent : null;
  5598.         }
  5599.       }
  5600.       return webshims;
  5601.     };
  5602.     /**
  5603.      * @param {string} name
  5604.      * @return {?}
  5605.      */
  5606.     self.ij.prototype.getParam = function(name) {
  5607.       return this.$[name] || "";
  5608.     };
  5609.     /**
  5610.      * @param {Object} value
  5611.      * @return {?}
  5612.      */
  5613.     self.Eia = function(value) {
  5614.       /** @type {Array} */
  5615.       var results = [];
  5616.       if (0 < value.ia.length) {
  5617.         results.push(self.Uh(value));
  5618.       }
  5619.       if (value = self.xga(value)) {
  5620.         results.push(value);
  5621.       }
  5622.       return results.join("&");
  5623.     };
  5624.     /**
  5625.      * @param {Function} actual
  5626.      * @return {?}
  5627.      */
  5628.     self.Uh = function(actual) {
  5629.       return(0, self.$a)(actual.ia, function(index) {
  5630.         var value = this.$[index];
  5631.         return null === value ? index : index + "=" + value;
  5632.       }, actual).join("&");
  5633.     };
  5634.     /**
  5635.      * @param {Object} v
  5636.      * @return {?}
  5637.      */
  5638.     self.xga = function(v) {
  5639.       var names = (0, self.Za)(self.lc(v.$), agree());
  5640.       names.sort();
  5641.       return(0, self.$a)(names, function(index) {
  5642.         var value = this.$[index];
  5643.         return null === value ? index : index + "=" + value;
  5644.       }, v).join("&");
  5645.     };
  5646.     /**
  5647.      * @param {Function} value
  5648.      * @param {?} opt_attributes
  5649.      * @param {boolean} remove
  5650.      * @return {?}
  5651.      */
  5652.     self.$g = function(value, opt_attributes, remove) {
  5653.       value = new self.ij(value);
  5654.       remove = remove ? self.Yb : function(opt_attributes) {
  5655.         return!opt_attributes;
  5656.       };
  5657.       var i;
  5658.       for (i in opt_attributes) {
  5659.         if (plural(i)) {
  5660.           if (remove(opt_attributes[i]) || i in value.$) {
  5661.             if (remove(opt_attributes[i])) {
  5662.               self.kb(value.ia, i);
  5663.             }
  5664.           } else {
  5665.             value.ia.push(i);
  5666.           }
  5667.         }
  5668.         if (remove(opt_attributes[i])) {
  5669.           delete value.$[i];
  5670.         } else {
  5671.           value.$[i] = opt_attributes[i];
  5672.         }
  5673.       }
  5674.       return value;
  5675.     };
  5676.     /**
  5677.      * @param {Function} arg
  5678.      * @param {?} attributes
  5679.      * @return {?}
  5680.      */
  5681.     self.Dia = function(arg, attributes) {
  5682.       var html = self.ka(attributes) ? self.tc(attributes) : attributes;
  5683.       return self.$g(arg, self.Ih(html, self.Xb("")));
  5684.     };
  5685.     /**
  5686.      * @param {Object} v
  5687.      * @return {?}
  5688.      */
  5689.     self.Xi = function(v) {
  5690.       return self.ic(v.$, function(dataAndEvents, i) {
  5691.         return plural(i);
  5692.       });
  5693.     };
  5694.     /**
  5695.      * @param {Object} v
  5696.      * @return {?}
  5697.      */
  5698.     self.Vf = function(v) {
  5699.       return self.ic(v.$, function(dataAndEvents, subKey) {
  5700.         return 2 == min(subKey);
  5701.       });
  5702.     };
  5703.     /**
  5704.      * @param {Object} value
  5705.      * @return {?}
  5706.      */
  5707.     self.Qf = function(value) {
  5708.       return 0 != value.ia.length;
  5709.     };
  5710.     /**
  5711.      * @param {Object} b
  5712.      * @return {?}
  5713.      */
  5714.     self.ij.prototype.equals = function(b) {
  5715.       return self.wga(this.$, b.$);
  5716.     };
  5717.     /**
  5718.      * @param {Function} value
  5719.      * @param {Function} event
  5720.      * @return {?}
  5721.      */
  5722.     self.ig = function(value, event) {
  5723.       var v = self.Wb(value);
  5724.       event = self.Wb(event);
  5725.       v = self.$g(v, {
  5726.         q : (0, window.decodeURIComponent)(v.getParam("q").replace(/\+/g, " ")).toLowerCase().trim()
  5727.       });
  5728.       var hello = event = self.$g(event, {
  5729.         q : (0, window.decodeURIComponent)(event.getParam("q").replace(/\+/g, " ")).toLowerCase().trim()
  5730.       });
  5731.       return self.wga(self.Xi(v), self.Xi(hello));
  5732.     };
  5733.     /**
  5734.      * @param {Object} expected
  5735.      * @return {?}
  5736.      */
  5737.     self.ij.prototype.compare = function(expected) {
  5738.       return Number(!this.equals(expected));
  5739.     };
  5740.     var MULTI_FLAG;
  5741.     var _t;
  5742.     var setAttributes;
  5743.     var freeze;
  5744.     var trimEndRegexp;
  5745.     /** @type {RegExp} */
  5746.     MULTI_FLAG = /^(?:([^:/?#.]+):)?(?:\/\/(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\?([^#]*))?(?:#(.*))?$/;
  5747.     /**
  5748.      * @param {?} opt_attributes
  5749.      * @return {?}
  5750.      */
  5751.     self.Kf = function(opt_attributes) {
  5752.       if (_t) {
  5753.         /** @type {boolean} */
  5754.         _t = false;
  5755.         var a = self.ca.location;
  5756.         if (a) {
  5757.           var value = a.href;
  5758.           if (value && ((value = self.If(self.Jf(3, value))) && value != a.hostname)) {
  5759.             throw _t = true, Error();
  5760.           }
  5761.         }
  5762.       }
  5763.       return opt_attributes.match(MULTI_FLAG);
  5764.     };
  5765.     _t = self.Pb;
  5766.     /**
  5767.      * @param {?} body
  5768.      * @return {?}
  5769.      */
  5770.     self.If = function(body) {
  5771.       return body ? (0, window.decodeURI)(body) : body;
  5772.     };
  5773.     /**
  5774.      * @param {number} desiredNonCommentArgIndex
  5775.      * @param {?} attributes
  5776.      * @return {?}
  5777.      */
  5778.     self.Jf = function(desiredNonCommentArgIndex, attributes) {
  5779.       return self.Kf(attributes)[desiredNonCommentArgIndex] || null;
  5780.     };
  5781.     /**
  5782.      * @param {?} opt_attributes
  5783.      * @return {?}
  5784.      */
  5785.     self.Lf = function(opt_attributes) {
  5786.       return self.If(self.Jf(5, opt_attributes));
  5787.     };
  5788.     /**
  5789.      * @param {string} href
  5790.      * @return {?}
  5791.      */
  5792.     self.Wh = function(href) {
  5793.       var hashIndex = href.indexOf("#");
  5794.       return 0 > hashIndex ? null : href.substr(hashIndex + 1);
  5795.     };
  5796.     /**
  5797.      * @param {string} uri
  5798.      * @param {boolean} fragment
  5799.      * @return {?}
  5800.      */
  5801.     self.bra = function(uri, fragment) {
  5802.       return self.Wf(uri) + (fragment ? "#" + fragment : "");
  5803.     };
  5804.     /**
  5805.      * @param {string} s
  5806.      * @return {?}
  5807.      */
  5808.     self.Wf = function(s) {
  5809.       var tmp = s.indexOf("#");
  5810.       return 0 > tmp ? s : s.substr(0, tmp);
  5811.     };
  5812.     /**
  5813.      * @param {Array} buffer
  5814.      * @return {?}
  5815.      */
  5816.     self.Mf = function(buffer) {
  5817.       if (buffer[1]) {
  5818.         var baseUri = buffer[0];
  5819.         var hashIndex = baseUri.indexOf("#");
  5820.         if (0 <= hashIndex) {
  5821.           buffer.push(baseUri.substr(hashIndex));
  5822.           buffer[0] = baseUri = baseUri.substr(0, hashIndex);
  5823.         }
  5824.         hashIndex = baseUri.indexOf("?");
  5825.         if (0 > hashIndex) {
  5826.           /** @type {string} */
  5827.           buffer[1] = "?";
  5828.         } else {
  5829.           if (hashIndex == baseUri.length - 1) {
  5830.             buffer[1] = void 0;
  5831.           }
  5832.         }
  5833.       }
  5834.       return buffer.join("");
  5835.     };
  5836.     /**
  5837.      * @param {string} elem
  5838.      * @param {?} attributes
  5839.      * @param {Array} isXML
  5840.      * @return {undefined}
  5841.      */
  5842.     setAttributes = function(elem, attributes, isXML) {
  5843.       if (self.ka(attributes)) {
  5844.         /** @type {number} */
  5845.         var i = 0;
  5846.         for (;i < attributes.length;i++) {
  5847.           setAttributes(elem, String(attributes[i]), isXML);
  5848.         }
  5849.       } else {
  5850.         if (null != attributes) {
  5851.           isXML.push("&", elem, "" === attributes ? "" : "=", self.Ea(attributes));
  5852.         }
  5853.       }
  5854.     };
  5855.     /**
  5856.      * @param {Array} object
  5857.      * @param {Object} buf
  5858.      * @param {number} off
  5859.      * @return {?}
  5860.      */
  5861.     freeze = function(object, buf, off) {
  5862.       off = off || 0;
  5863.       for (;off < buf.length;off += 2) {
  5864.         setAttributes(buf[off], buf[off + 1], object);
  5865.       }
  5866.       return object;
  5867.     };
  5868.     /**
  5869.      * @param {Array} isXML
  5870.      * @param {Object} context
  5871.      * @return {?}
  5872.      */
  5873.     self.ada = function(isXML, context) {
  5874.       var match;
  5875.       for (match in context) {
  5876.         setAttributes(match, context[match], isXML);
  5877.       }
  5878.       return isXML;
  5879.     };
  5880.     /**
  5881.      * @param {?} opt_attributes
  5882.      * @return {?}
  5883.      */
  5884.     self.Nf = function(opt_attributes) {
  5885.       opt_attributes = self.ada([], opt_attributes);
  5886.       /** @type {string} */
  5887.       opt_attributes[0] = "";
  5888.       return opt_attributes.join("");
  5889.     };
  5890.     /**
  5891.      * @param {string} dataAndEvents
  5892.      * @param {string} tag
  5893.      * @return {?}
  5894.      */
  5895.     self.bda = function(dataAndEvents, tag) {
  5896.       return self.Mf(2 == arguments.length ? freeze([dataAndEvents], arguments[1], 0) : freeze([dataAndEvents], arguments, 1));
  5897.     };
  5898.     /**
  5899.      * @param {?} opt_attributes
  5900.      * @param {Object} name
  5901.      * @param {?} attributes
  5902.      * @return {?}
  5903.      */
  5904.     self.ei = function(opt_attributes, name, attributes) {
  5905.       /** @type {Array} */
  5906.       opt_attributes = [opt_attributes, "&", name];
  5907.       if (null != attributes) {
  5908.         opt_attributes.push("=", self.Ea(attributes));
  5909.       }
  5910.       return self.Mf(opt_attributes);
  5911.     };
  5912.     /**
  5913.      * @param {string} string
  5914.      * @param {number} index
  5915.      * @param {string} s
  5916.      * @param {number} sz
  5917.      * @return {?}
  5918.      */
  5919.     self.cda = function(string, index, s, sz) {
  5920.       var j = s.length;
  5921.       for (;0 <= (index = string.indexOf(s, index)) && index < sz;) {
  5922.         var zeroQuoted = string.charCodeAt(index - 1);
  5923.         if (38 == zeroQuoted || 63 == zeroQuoted) {
  5924.           if (zeroQuoted = string.charCodeAt(index + j), !zeroQuoted || (61 == zeroQuoted || (38 == zeroQuoted || 35 == zeroQuoted))) {
  5925.             return index;
  5926.           }
  5927.         }
  5928.         index += j + 1;
  5929.       }
  5930.       return-1;
  5931.     };
  5932.     /** @type {RegExp} */
  5933.     self.dda = /#|$/;
  5934.     /**
  5935.      * @param {string} value
  5936.      * @param {string} s
  5937.      * @return {?}
  5938.      */
  5939.     self.Of = function(value, s) {
  5940.       var y = value.search(self.dda);
  5941.       var index = self.cda(value, 0, s, y);
  5942.       if (0 > index) {
  5943.         return null;
  5944.       }
  5945.       var length = value.indexOf("&", index);
  5946.       if (0 > length || length > y) {
  5947.         length = y;
  5948.       }
  5949.       index += s.length + 1;
  5950.       return self.Fa(value.substr(index, length - index));
  5951.     };
  5952.     /** @type {RegExp} */
  5953.     trimEndRegexp = /[?&]($|#)/;
  5954.     /**
  5955.      * @param {string} key
  5956.      * @param {string} name
  5957.      * @return {?}
  5958.      */
  5959.     self.Wga = function(key, name) {
  5960.       var size = key.search(self.dda);
  5961.       /** @type {number} */
  5962.       var p = 0;
  5963.       var ret;
  5964.       /** @type {Array} */
  5965.       var newOut = [];
  5966.       for (;0 <= (ret = self.cda(key, p, name, size));) {
  5967.         newOut.push(key.substring(p, ret));
  5968.         /** @type {number} */
  5969.         p = Math.min(key.indexOf("&", ret) + 1 || size, size);
  5970.       }
  5971.       newOut.push(key.substr(p));
  5972.       return newOut.join("").replace(trimEndRegexp, "$1");
  5973.     };
  5974.     /**
  5975.      * @param {string} newIndex
  5976.      * @param {Object} optgroup
  5977.      * @param {string} opt_attributes
  5978.      * @return {?}
  5979.      */
  5980.     self.fi = function(newIndex, optgroup, opt_attributes) {
  5981.       return self.ei(self.Wga(newIndex, optgroup), optgroup, opt_attributes);
  5982.     };
  5983.     /**
  5984.      * @return {?}
  5985.      */
  5986.     self.kd = function() {
  5987.       return self.ca.location || {};
  5988.     };
  5989.     /**
  5990.      * @return {?}
  5991.      */
  5992.     self.ug = function() {
  5993.       return self.ca.location || {};
  5994.     };
  5995.     /**
  5996.      * @param {string} deepDataAndEvents
  5997.      * @return {undefined}
  5998.      */
  5999.     self.lca = function(deepDataAndEvents) {
  6000.       self.Pba(deepDataAndEvents);
  6001.     };
  6002.     /**
  6003.      * @param {string} deepDataAndEvents
  6004.      * @return {undefined}
  6005.      */
  6006.     self.Pba = function(deepDataAndEvents) {
  6007.       if (self.Id().replace(/^#*/, "") != deepDataAndEvents) {
  6008.         /** @type {string} */
  6009.         self.kd().hash = deepDataAndEvents;
  6010.       }
  6011.     };
  6012.     /**
  6013.      * @param {string} slide
  6014.      * @return {undefined}
  6015.      */
  6016.     self.eda = function(slide) {
  6017.       self.Kca(slide);
  6018.     };
  6019.     /**
  6020.      * @param {(Object|boolean|number|string)} res
  6021.      * @return {undefined}
  6022.      */
  6023.     self.Kca = function(res) {
  6024.       var url = self.kd().href;
  6025.       if ((self.Wh(url) || "") != res) {
  6026.         var u = self.Wf(url);
  6027.         if (res || 0 < url.indexOf("#")) {
  6028.           u += "#" + res;
  6029.         }
  6030.         self.kd().replace(u);
  6031.       }
  6032.     };
  6033.     /**
  6034.      * @return {?}
  6035.      */
  6036.     self.Id = function() {
  6037.       var list = self.kd();
  6038.       return list.hash ? list.href.substr(list.href.indexOf("#")) : "";
  6039.     };
  6040.     /**
  6041.      * @return {?}
  6042.      */
  6043.     self.Rda = function() {
  6044.       return self.kd().protocol + "//" + self.kd().host;
  6045.     };
  6046.     var Zda;
  6047.     var throttledUpdate;
  6048.     var isUndefined;
  6049.     var urlParse;
  6050.     var scope;
  6051.     self.lj = {};
  6052.     /** @type {boolean} */
  6053.     self.Sda = false;
  6054.     /** @type {boolean} */
  6055.     Zda = false;
  6056.     self.Mga = void 0;
  6057.     /**
  6058.      * @param {string} name
  6059.      * @param {Function} view
  6060.      * @return {undefined}
  6061.      */
  6062.     self.nj = function(name, view) {
  6063.       if (!self.lj[name]) {
  6064.         /** @type {Function} */
  6065.         self.lj[name] = view;
  6066.         window.google.dclc(self.sa(view, self.gi.getParam(name), true));
  6067.       }
  6068.     };
  6069.     /**
  6070.      * @param {?} key
  6071.      * @param {?} value
  6072.      * @param {boolean} funcToCall
  6073.      * @return {undefined}
  6074.      */
  6075.     self.pj = function(key, value, funcToCall) {
  6076.       var flags = {};
  6077.       flags[key] = value;
  6078.       self.cQb(flags, funcToCall);
  6079.     };
  6080.     /**
  6081.      * @param {?} attributes
  6082.      * @param {boolean} funcToCall
  6083.      * @return {undefined}
  6084.      */
  6085.     self.cQb = function(attributes, funcToCall) {
  6086.       var suiteView = self.$g(self.gi, attributes);
  6087.       self.Aea(suiteView, funcToCall);
  6088.     };
  6089.     /**
  6090.      * @return {undefined}
  6091.      */
  6092.     self.zi = function() {
  6093.       window.history.back();
  6094.     };
  6095.     /**
  6096.      * @param {string} x
  6097.      * @return {?}
  6098.      */
  6099.     self.Di = function(x) {
  6100.       return 1 == min(x) ? self.lf.getParam(x) : self.gi.getParam(x);
  6101.     };
  6102.     /**
  6103.      * @return {undefined}
  6104.      */
  6105.     throttledUpdate = function() {
  6106.       var test = self.vh(self.kd().href);
  6107.       self.gi = self.Wb(test.state);
  6108.     };
  6109.     /**
  6110.      * @param {Object} arg
  6111.      * @return {?}
  6112.      */
  6113.     isUndefined = function(arg) {
  6114.       if (self.ig(arg, self.Nb)) {
  6115.         var type = self.Xi(arg);
  6116.         arg = self.Dia(arg, type);
  6117.       }
  6118.       return self.Eia(arg);
  6119.     };
  6120.     /**
  6121.      * @param {boolean} value
  6122.      * @return {?}
  6123.      */
  6124.     urlParse = function(value) {
  6125.       var l = self.kd();
  6126.       return self.Sda ? self.Xf(value, l.pathname, false) : self.Xf(value, l.pathname + l.search, true);
  6127.     };
  6128.     /**
  6129.      * @param {boolean} obj
  6130.      * @param {boolean} deepDataAndEvents
  6131.      * @return {undefined}
  6132.      */
  6133.     self.Aea = function(obj, deepDataAndEvents) {
  6134.       if (!obj.equals(self.gi)) {
  6135.         /** @type {boolean} */
  6136.         self.gi = obj;
  6137.         if (deepDataAndEvents) {
  6138.           if (Zda) {
  6139.             window.history.replaceState({}, "", urlParse(obj));
  6140.           } else {
  6141.             self.eda(isUndefined(obj));
  6142.           }
  6143.         } else {
  6144.           if (Zda) {
  6145.             window.history.pushState({}, "", urlParse(obj));
  6146.           } else {
  6147.             self.lca(isUndefined(obj));
  6148.           }
  6149.         }
  6150.       }
  6151.     };
  6152.     /**
  6153.      * @return {undefined}
  6154.      */
  6155.     self.jfa = function() {
  6156.       throttledUpdate();
  6157.       if (self.Mga) {
  6158.         window.google.dclc(self.sa(self.Mga, self.gi, false));
  6159.       }
  6160.       var name;
  6161.       for (name in self.lj) {
  6162.         window.google.dclc(self.sa(self.lj[name], self.gi.getParam(name), false));
  6163.       }
  6164.     };
  6165.     scope = self.aa("google.pmc.hsm");
  6166.     if (scope) {
  6167.       /** @type {boolean} */
  6168.       Zda = !!scope.h;
  6169.       /** @type {boolean} */
  6170.       self.Sda = !!scope.q;
  6171.     }
  6172.     var strBase64 = self.Id();
  6173.     if (strBase64) {
  6174.       if (-1 < strBase64.substr(1).indexOf("#")) {
  6175.         window.google.log("jbh", "h=" + (0, window.encodeURIComponent)(strBase64).substr(0, 40));
  6176.         /** @type {string} */
  6177.         self.kd().hash = "";
  6178.       }
  6179.     }
  6180.     self.lf = self.Cia(self.kd().search.substring(1));
  6181.     self.Nb = self.Wb(self.lf);
  6182.     throttledUpdate();
  6183.     if (self.Sda) {
  6184.       self.C(window, "popstate", self.jfa);
  6185.     } else {
  6186.       self.C(window, "hashchange", self.jfa);
  6187.     }
  6188.     self.ida = self.Xb(null);
  6189.     /**
  6190.      * @return {undefined}
  6191.      */
  6192.     self.vg = function() {
  6193.     };
  6194.     self.vg.prototype.getType = self.Xb("");
  6195.     /**
  6196.      * @param {?} opt_attributes
  6197.      * @param {Object} name
  6198.      * @param {(boolean|number|string)} attributes
  6199.      * @return {undefined}
  6200.      */
  6201.     self.Ee = function(opt_attributes, name, attributes) {
  6202.       if (null === self.ica) {
  6203.         window.google.ml(opt_attributes, !!attributes, name);
  6204.       } else {
  6205.         (0, self.ica)(opt_attributes, name, attributes);
  6206.       }
  6207.     };
  6208.     self.ua("jsl.el", self.Ee);
  6209.     /** @type {null} */
  6210.     self.ica = null;
  6211.     var fetch;
  6212.     var children;
  6213.     self.Fe = "StopIteration" in self.ca ? self.ca.StopIteration : {
  6214.       message : "StopIteration",
  6215.       stack : ""
  6216.     };
  6217.     /**
  6218.      * @return {undefined}
  6219.      */
  6220.     self.Ge = function() {
  6221.     };
  6222.     /**
  6223.      * @return {?}
  6224.      */
  6225.     self.Ge.prototype.next = function() {
  6226.       throw self.Fe;
  6227.     };
  6228.     /**
  6229.      * @return {?}
  6230.      */
  6231.     self.Ge.prototype.ii = function() {
  6232.       return this;
  6233.     };
  6234.     /**
  6235.      * @param {string} data
  6236.      * @return {?}
  6237.      */
  6238.     fetch = function(data) {
  6239.       if (data instanceof self.Ge) {
  6240.         return data;
  6241.       }
  6242.       if ("function" == typeof data.ii) {
  6243.         return data.ii(false);
  6244.       }
  6245.       if (self.la(data)) {
  6246.         /** @type {number} */
  6247.         var pos = 0;
  6248.         var source = new self.Ge;
  6249.         /**
  6250.          * @return {?}
  6251.          */
  6252.         source.next = function() {
  6253.           for (;;) {
  6254.             if (pos >= data.length) {
  6255.               throw self.Fe;
  6256.             }
  6257.             if (pos in data) {
  6258.               return data[pos++];
  6259.             }
  6260.             pos++;
  6261.           }
  6262.         };
  6263.         return source;
  6264.       }
  6265.       throw Error("g");
  6266.     };
  6267.     /**
  6268.      * @param {Object} attributes
  6269.      * @param {Function} next_callback
  6270.      * @return {undefined}
  6271.      */
  6272.     self.Ie = function(attributes, next_callback) {
  6273.       if (self.la(attributes)) {
  6274.         try {
  6275.           (0, self.u)(attributes, next_callback, void 0);
  6276.         } catch (nextSlide) {
  6277.           if (nextSlide !== self.Fe) {
  6278.             throw nextSlide;
  6279.           }
  6280.         }
  6281.       } else {
  6282.         attributes = fetch(attributes);
  6283.         try {
  6284.           for (;;) {
  6285.             next_callback.call(void 0, attributes.next(), void 0, attributes);
  6286.           }
  6287.         } catch (el) {
  6288.           if (el !== self.Fe) {
  6289.             throw el;
  6290.           }
  6291.         }
  6292.       }
  6293.     };
  6294.     /**
  6295.      * @param {string} attributes
  6296.      * @return {?}
  6297.      */
  6298.     children = function(attributes) {
  6299.       if (self.la(attributes)) {
  6300.         return self.nb(attributes);
  6301.       }
  6302.       attributes = fetch(attributes);
  6303.       /** @type {Array} */
  6304.       var children = [];
  6305.       self.Ie(attributes, function(child) {
  6306.         children.push(child);
  6307.       });
  6308.       return children;
  6309.     };
  6310.     /**
  6311.      * @param {?} r
  6312.      * @param {?} dataAndEvents
  6313.      * @return {undefined}
  6314.      */
  6315.     self.Je = function(r, dataAndEvents) {
  6316.       this.ia = {};
  6317.       /** @type {Array} */
  6318.       this.$ = [];
  6319.       /** @type {number} */
  6320.       this.ma = this.ga = 0;
  6321.       /** @type {number} */
  6322.       var n = arguments.length;
  6323.       if (1 < n) {
  6324.         if (n % 2) {
  6325.           throw Error("c");
  6326.         }
  6327.         /** @type {number} */
  6328.         var i = 0;
  6329.         for (;i < n;i += 2) {
  6330.           this.set(arguments[i], arguments[i + 1]);
  6331.         }
  6332.       } else {
  6333.         if (r) {
  6334.           if (r instanceof self.Je) {
  6335.             n = r.Pf();
  6336.             i = r.Xc();
  6337.           } else {
  6338.             n = self.lc(r);
  6339.             i = self.kc(r);
  6340.           }
  6341.           /** @type {number} */
  6342.           var s = 0;
  6343.           for (;s < n.length;s++) {
  6344.             this.set(n[s], i[s]);
  6345.           }
  6346.         }
  6347.       }
  6348.     };
  6349.     /**
  6350.      * @return {?}
  6351.      */
  6352.     self.Je.prototype.ze = function() {
  6353.       return this.ga;
  6354.     };
  6355.     /**
  6356.      * @return {?}
  6357.      */
  6358.     self.Je.prototype.Xc = function() {
  6359.       self.Ke(this);
  6360.       /** @type {Array} */
  6361.       var eventPath = [];
  6362.       /** @type {number} */
  6363.       var n = 0;
  6364.       for (;n < this.$.length;n++) {
  6365.         eventPath.push(this.ia[this.$[n]]);
  6366.       }
  6367.       return eventPath;
  6368.     };
  6369.     /**
  6370.      * @return {?}
  6371.      */
  6372.     self.Je.prototype.Pf = function() {
  6373.       self.Ke(this);
  6374.       return this.$.concat();
  6375.     };
  6376.     /**
  6377.      * @param {?} opt_attributes
  6378.      * @param {Object} name
  6379.      * @return {?}
  6380.      */
  6381.     self.Me = function(opt_attributes, name) {
  6382.       return hasOwnProperty(opt_attributes.ia, name);
  6383.     };
  6384.     /**
  6385.      * @param {boolean} val
  6386.      * @return {?}
  6387.      */
  6388.     self.Je.prototype.Us = function(val) {
  6389.       /** @type {number} */
  6390.       var i = 0;
  6391.       for (;i < this.$.length;i++) {
  6392.         var key = this.$[i];
  6393.         if (hasOwnProperty(this.ia, key) && this.ia[key] == val) {
  6394.           return true;
  6395.         }
  6396.       }
  6397.       return false;
  6398.     };
  6399.     /**
  6400.      * @param {Object} obj
  6401.      * @param {string} opt_equalityFn
  6402.      * @return {?}
  6403.      */
  6404.     self.Je.prototype.equals = function(obj, opt_equalityFn) {
  6405.       if (this === obj) {
  6406.         return true;
  6407.       }
  6408.       if (this.ga != obj.ze()) {
  6409.         return false;
  6410.       }
  6411.       var equalityFn = opt_equalityFn || ext;
  6412.       self.Ke(this);
  6413.       var attributes;
  6414.       /** @type {number} */
  6415.       var i = 0;
  6416.       for (;attributes = this.$[i];i++) {
  6417.         if (!equalityFn(this.get(attributes), obj.get(attributes))) {
  6418.           return false;
  6419.         }
  6420.       }
  6421.       return true;
  6422.     };
  6423.     /**
  6424.      * @param {?} a
  6425.      * @param {?} b
  6426.      * @return {?}
  6427.      */
  6428.     var ext = function(a, b) {
  6429.       return a === b;
  6430.     };
  6431.     /**
  6432.      * @return {?}
  6433.      */
  6434.     self.Je.prototype.isEmpty = function() {
  6435.       return 0 == this.ga;
  6436.     };
  6437.     /**
  6438.      * @return {undefined}
  6439.      */
  6440.     self.Je.prototype.clear = function() {
  6441.       this.ia = {};
  6442.       /** @type {number} */
  6443.       this.ma = this.ga = this.$.length = 0;
  6444.     };
  6445.     /**
  6446.      * @param {string} opt_attributes
  6447.      * @return {?}
  6448.      */
  6449.     self.Je.prototype.remove = function(opt_attributes) {
  6450.       return hasOwnProperty(this.ia, opt_attributes) ? (delete this.ia[opt_attributes], this.ga--, this.ma++, this.$.length > 2 * this.ga && self.Ke(this), true) : false;
  6451.     };
  6452.     /**
  6453.      * @param {Object} root
  6454.      * @return {undefined}
  6455.      */
  6456.     self.Ke = function(root) {
  6457.       if (root.ga != root.$.length) {
  6458.         /** @type {number} */
  6459.         var i = 0;
  6460.         /** @type {number} */
  6461.         var len = 0;
  6462.         for (;i < root.$.length;) {
  6463.           var feature = root.$[i];
  6464.           if (hasOwnProperty(root.ia, feature)) {
  6465.             root.$[len++] = feature;
  6466.           }
  6467.           i++;
  6468.         }
  6469.         /** @type {number} */
  6470.         root.$.length = len;
  6471.       }
  6472.       if (root.ga != root.$.length) {
  6473.         var tests = {};
  6474.         /** @type {number} */
  6475.         len = i = 0;
  6476.         for (;i < root.$.length;) {
  6477.           feature = root.$[i];
  6478.           if (!hasOwnProperty(tests, feature)) {
  6479.             root.$[len++] = feature;
  6480.             /** @type {number} */
  6481.             tests[feature] = 1;
  6482.           }
  6483.           i++;
  6484.         }
  6485.         /** @type {number} */
  6486.         root.$.length = len;
  6487.       }
  6488.     };
  6489.     self.h = self.Je.prototype;
  6490.     /**
  6491.      * @param {?} opt_attributes
  6492.      * @param {Object} name
  6493.      * @return {?}
  6494.      */
  6495.     self.h.get = function(opt_attributes, name) {
  6496.       return hasOwnProperty(this.ia, opt_attributes) ? this.ia[opt_attributes] : name;
  6497.     };
  6498.     /**
  6499.      * @param {number} opt_attributes
  6500.      * @param {?} id
  6501.      * @return {undefined}
  6502.      */
  6503.     self.h.set = function(opt_attributes, id) {
  6504.       if (!hasOwnProperty(this.ia, opt_attributes)) {
  6505.         this.ga++;
  6506.         this.$.push(opt_attributes);
  6507.         this.ma++;
  6508.       }
  6509.       this.ia[opt_attributes] = id;
  6510.     };
  6511.     /**
  6512.      * @param {Function} callback
  6513.      * @param {?} scope
  6514.      * @return {undefined}
  6515.      */
  6516.     self.h.forEach = function(callback, scope) {
  6517.       var codeSegments = this.Pf();
  6518.       /** @type {number} */
  6519.       var i = 0;
  6520.       for (;i < codeSegments.length;i++) {
  6521.         var attributes = codeSegments[i];
  6522.         var fields = this.get(attributes);
  6523.         callback.call(scope, fields, attributes, this);
  6524.       }
  6525.     };
  6526.     /**
  6527.      * @return {?}
  6528.      */
  6529.     self.h.clone = function() {
  6530.       return new self.Je(this);
  6531.     };
  6532.     /**
  6533.      * @param {boolean} opt_keys
  6534.      * @return {?}
  6535.      */
  6536.     self.h.ii = function(opt_keys) {
  6537.       self.Ke(this);
  6538.       /** @type {number} */
  6539.       var offset = 0;
  6540.       var hidden = this.ma;
  6541.       var element = this;
  6542.       var stream = new self.Ge;
  6543.       /**
  6544.        * @return {?}
  6545.        */
  6546.       stream.next = function() {
  6547.         if (hidden != element.ma) {
  6548.           throw Error("h");
  6549.         }
  6550.         if (offset >= element.$.length) {
  6551.           throw self.Fe;
  6552.         }
  6553.         var key = element.$[offset++];
  6554.         return opt_keys ? key : element.ia[key];
  6555.       };
  6556.       return stream;
  6557.     };
  6558.     /**
  6559.      * @param {?} object
  6560.      * @param {?} attributes
  6561.      * @return {?}
  6562.      */
  6563.     var hasOwnProperty = function(object, attributes) {
  6564.       return Object.prototype.hasOwnProperty.call(object, attributes);
  6565.     };
  6566.     var every;
  6567.     /**
  6568.      * @param {?} attributes
  6569.      * @return {?}
  6570.      */
  6571.     self.nca = function(attributes) {
  6572.       return "function" == typeof attributes.ze ? attributes.ze() : self.la(attributes) || self.ma(attributes) ? attributes.length : self.jc(attributes);
  6573.     };
  6574.     /**
  6575.      * @param {?} attributes
  6576.      * @return {?}
  6577.      */
  6578.     self.Ne = function(attributes) {
  6579.       if ("function" == typeof attributes.Xc) {
  6580.         return attributes.Xc();
  6581.       }
  6582.       if (self.ma(attributes)) {
  6583.         return attributes.split("");
  6584.       }
  6585.       if (self.la(attributes)) {
  6586.         /** @type {Array} */
  6587.         var byteout = [];
  6588.         var len = attributes.length;
  6589.         /** @type {number} */
  6590.         var value = 0;
  6591.         for (;value < len;value++) {
  6592.           byteout.push(attributes[value]);
  6593.         }
  6594.         return byteout;
  6595.       }
  6596.       return self.kc(attributes);
  6597.     };
  6598.     /**
  6599.      * @param {?} attributes
  6600.      * @return {?}
  6601.      */
  6602.     self.oca = function(attributes) {
  6603.       if ("function" == typeof attributes.Pf) {
  6604.         return attributes.Pf();
  6605.       }
  6606.       if ("function" != typeof attributes.Xc) {
  6607.         if (self.la(attributes) || self.ma(attributes)) {
  6608.           /** @type {Array} */
  6609.           var assigns = [];
  6610.           attributes = attributes.length;
  6611.           /** @type {number} */
  6612.           var vvar = 0;
  6613.           for (;vvar < attributes;vvar++) {
  6614.             assigns.push(vvar);
  6615.           }
  6616.           return assigns;
  6617.         }
  6618.         return self.lc(attributes);
  6619.       }
  6620.     };
  6621.     /**
  6622.      * @param {?} attributes
  6623.      * @param {Function} fn
  6624.      * @param {?} scope
  6625.      * @return {undefined}
  6626.      */
  6627.     self.pca = function(attributes, fn, scope) {
  6628.       if ("function" == typeof attributes.forEach) {
  6629.         attributes.forEach(fn, scope);
  6630.       } else {
  6631.         if (self.la(attributes) || self.ma(attributes)) {
  6632.           (0, self.u)(attributes, fn, scope);
  6633.         } else {
  6634.           var values = self.oca(attributes);
  6635.           var names = self.Ne(attributes);
  6636.           var len = names.length;
  6637.           /** @type {number} */
  6638.           var i = 0;
  6639.           for (;i < len;i++) {
  6640.             fn.call(scope, names[i], values && values[i], attributes);
  6641.           }
  6642.         }
  6643.       }
  6644.     };
  6645.     /**
  6646.      * @param {?} attributes
  6647.      * @param {Function} callback
  6648.      * @return {?}
  6649.      */
  6650.     every = function(attributes, callback) {
  6651.       if ("function" == typeof attributes.every) {
  6652.         return attributes.every(callback, void 0);
  6653.       }
  6654.       if (self.la(attributes) || self.ma(attributes)) {
  6655.         return(0, self.cb)(attributes, callback, void 0);
  6656.       }
  6657.       var fns = self.oca(attributes);
  6658.       var values = self.Ne(attributes);
  6659.       var valuesLen = values.length;
  6660.       /** @type {number} */
  6661.       var i = 0;
  6662.       for (;i < valuesLen;i++) {
  6663.         if (!callback.call(void 0, values[i], fns && fns[i], attributes)) {
  6664.           return false;
  6665.         }
  6666.       }
  6667.       return true;
  6668.     };
  6669.     var set;
  6670.     /**
  6671.      * @param {?} opt_attributes
  6672.      * @return {undefined}
  6673.      */
  6674.     self.Oe = function(opt_attributes) {
  6675.       this.$ = new self.Je;
  6676.       if (opt_attributes) {
  6677.         self.rca(this, opt_attributes);
  6678.       }
  6679.     };
  6680.     /**
  6681.      * @param {?} attributes
  6682.      * @return {?}
  6683.      */
  6684.     set = function(attributes) {
  6685.       /** @type {string} */
  6686.       var $s = typeof attributes;
  6687.       return "object" == $s && attributes || "function" == $s ? "o" + self.ra(attributes) : $s.substr(0, 1) + attributes;
  6688.     };
  6689.     /**
  6690.      * @return {?}
  6691.      */
  6692.     self.Oe.prototype.ze = function() {
  6693.       return this.$.ze();
  6694.     };
  6695.     /**
  6696.      * @param {string} attr
  6697.      * @return {undefined}
  6698.      */
  6699.     self.Oe.prototype.add = function(attr) {
  6700.       this.$.set(set(attr), attr);
  6701.     };
  6702.     /**
  6703.      * @param {Object} store
  6704.      * @param {string} attributes
  6705.      * @return {undefined}
  6706.      */
  6707.     self.rca = function(store, attributes) {
  6708.       var values = self.Ne(attributes);
  6709.       var valuesLen = values.length;
  6710.       /** @type {number} */
  6711.       var i = 0;
  6712.       for (;i < valuesLen;i++) {
  6713.         store.add(values[i]);
  6714.       }
  6715.     };
  6716.     self.h = self.Oe.prototype;
  6717.     /**
  6718.      * @param {string} items
  6719.      * @return {undefined}
  6720.      */
  6721.     self.h.removeAll = function(items) {
  6722.       items = self.Ne(items);
  6723.       var valuesLen = items.length;
  6724.       /** @type {number} */
  6725.       var i = 0;
  6726.       for (;i < valuesLen;i++) {
  6727.         this.remove(items[i]);
  6728.       }
  6729.     };
  6730.     /**
  6731.      * @param {string} opt_attributes
  6732.      * @return {?}
  6733.      */
  6734.     self.h.remove = function(opt_attributes) {
  6735.       return this.$.remove(set(opt_attributes));
  6736.     };
  6737.     /**
  6738.      * @return {undefined}
  6739.      */
  6740.     self.h.clear = function() {
  6741.       this.$.clear();
  6742.     };
  6743.     /**
  6744.      * @return {?}
  6745.      */
  6746.     self.h.isEmpty = function() {
  6747.       return this.$.isEmpty();
  6748.     };
  6749.     /**
  6750.      * @param {string} name
  6751.      * @return {?}
  6752.      */
  6753.     self.h.contains = function(name) {
  6754.       return self.Me(this.$, set(name));
  6755.     };
  6756.     /**
  6757.      * @param {?} vector1
  6758.      * @param {string} type
  6759.      * @return {?}
  6760.      */
  6761.     self.Ama = function(vector1, type) {
  6762.       var api = vector1.clone();
  6763.       api.removeAll(type);
  6764.       return api;
  6765.     };
  6766.     /**
  6767.      * @return {?}
  6768.      */
  6769.     self.Oe.prototype.Xc = function() {
  6770.       return this.$.Xc();
  6771.     };
  6772.     /**
  6773.      * @return {?}
  6774.      */
  6775.     self.Oe.prototype.clone = function() {
  6776.       return new self.Oe(this);
  6777.     };
  6778.     /**
  6779.      * @param {string} y
  6780.      * @return {?}
  6781.      */
  6782.     self.Oe.prototype.equals = function(y) {
  6783.       return this.ze() == self.nca(y) && self.tca(this, y);
  6784.     };
  6785.     /**
  6786.      * @param {string} a
  6787.      * @param {string} value
  6788.      * @return {?}
  6789.      */
  6790.     self.tca = function(a, value) {
  6791.       var isFunction = self.nca(value);
  6792.       if (a.ze() > isFunction) {
  6793.         return false;
  6794.       }
  6795.       if (!(value instanceof self.Oe)) {
  6796.         if (5 < isFunction) {
  6797.           value = new self.Oe(value);
  6798.         }
  6799.       }
  6800.       return every(a, function(name) {
  6801.         var attributes = value;
  6802.         if ("function" == typeof attributes.contains) {
  6803.           name = attributes.contains(name);
  6804.         } else {
  6805.           if ("function" == typeof attributes.Us) {
  6806.             name = attributes.Us(name);
  6807.           } else {
  6808.             if (self.la(attributes) || self.ma(attributes)) {
  6809.               name = self.fb(attributes, name);
  6810.             } else {
  6811.               a: {
  6812.                 var k;
  6813.                 for (k in attributes) {
  6814.                   if (attributes[k] == name) {
  6815.                     /** @type {boolean} */
  6816.                     name = true;
  6817.                     break a;
  6818.                   }
  6819.                 }
  6820.                 /** @type {boolean} */
  6821.                 name = false;
  6822.               }
  6823.             }
  6824.           }
  6825.         }
  6826.         return name;
  6827.       });
  6828.     };
  6829.     /**
  6830.      * @return {?}
  6831.      */
  6832.     self.Oe.prototype.ii = function() {
  6833.       return this.$.ii(false);
  6834.     };
  6835.     var Type;
  6836.     /**
  6837.      * @param {string} js
  6838.      * @return {?}
  6839.      */
  6840.     self.jda = function(js) {
  6841.       return/^\s*$/.test(js) ? false : /^[\],:{}\s\u2028\u2029]*$/.test(js.replace(/\\["\\\/bfnrtu]/g, "@").replace(/"[^"\\\n\r\u2028\u2029\x00-\x08\x0a-\x1f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g, ""));
  6842.     };
  6843.     /**
  6844.      * @param {?} str
  6845.      * @return {?}
  6846.      */
  6847.     self.Pe = function(str) {
  6848.       /** @type {string} */
  6849.       str = String(str);
  6850.       if (self.jda(str)) {
  6851.         try {
  6852.           return eval("(" + str + ")");
  6853.         } catch (b) {
  6854.         }
  6855.       }
  6856.       throw Error("i`" + str);
  6857.     };
  6858.     /**
  6859.      * @param {string} dataAndEvents
  6860.      * @return {?}
  6861.      */
  6862.     self.Qe = function(dataAndEvents) {
  6863.       return eval("(" + dataAndEvents + ")");
  6864.     };
  6865.     /**
  6866.      * @param {?} opt_attributes
  6867.      * @return {?}
  6868.      */
  6869.     self.Re = function(opt_attributes) {
  6870.       return(new Type(void 0)).yb(opt_attributes);
  6871.     };
  6872.     /**
  6873.      * @param {?} path
  6874.      * @return {undefined}
  6875.      */
  6876.     Type = function(path) {
  6877.       this.$ = path;
  6878.     };
  6879.     /**
  6880.      * @param {string} opt_attributes
  6881.      * @return {?}
  6882.      */
  6883.     Type.prototype.yb = function(opt_attributes) {
  6884.       /** @type {Array} */
  6885.       var sb = [];
  6886.       l(this, opt_attributes, sb);
  6887.       return sb.join("");
  6888.     };
  6889.     /**
  6890.      * @param {Object} d
  6891.      * @param {?} attributes
  6892.      * @param {Array} sb
  6893.      * @return {undefined}
  6894.      */
  6895.     var l = function(d, attributes, sb) {
  6896.       if (null == attributes) {
  6897.         sb.push("null");
  6898.       } else {
  6899.         if ("object" == typeof attributes) {
  6900.           if (self.ka(attributes)) {
  6901.             var attr = attributes;
  6902.             attributes = attr.length;
  6903.             sb.push("[");
  6904.             /** @type {string} */
  6905.             var value = "";
  6906.             /** @type {number} */
  6907.             var a = 0;
  6908.             for (;a < attributes;a++) {
  6909.               sb.push(value);
  6910.               value = attr[a];
  6911.               l(d, d.$ ? d.$.call(attr, String(a), value) : value, sb);
  6912.               /** @type {string} */
  6913.               value = ",";
  6914.             }
  6915.             sb.push("]");
  6916.             return;
  6917.           }
  6918.           if (attributes instanceof String || (attributes instanceof Number || attributes instanceof Boolean)) {
  6919.             /** @type {*} */
  6920.             attributes = attributes.valueOf();
  6921.           } else {
  6922.             sb.push("{");
  6923.             /** @type {string} */
  6924.             a = "";
  6925.             for (attr in attributes) {
  6926.               if (Object.prototype.hasOwnProperty.call(attributes, attr)) {
  6927.                 value = attributes[attr];
  6928.                 if ("function" != typeof value) {
  6929.                   sb.push(a);
  6930.                   stringify(attr, sb);
  6931.                   sb.push(":");
  6932.                   l(d, d.$ ? d.$.call(attributes, attr, value) : value, sb);
  6933.                   /** @type {string} */
  6934.                   a = ",";
  6935.                 }
  6936.               }
  6937.             }
  6938.             sb.push("}");
  6939.             return;
  6940.           }
  6941.         }
  6942.         switch(typeof attributes) {
  6943.           case "string":
  6944.             stringify(attributes, sb);
  6945.             break;
  6946.           case "number":
  6947.             sb.push((0, window.isFinite)(attributes) && !(0, window.isNaN)(attributes) ? attributes : "null");
  6948.             break;
  6949.           case "boolean":
  6950.             sb.push(attributes);
  6951.             break;
  6952.           case "function":
  6953.             sb.push("null");
  6954.             break;
  6955.           default:
  6956.             throw Error("j`" + typeof attributes);;
  6957.         }
  6958.       }
  6959.     };
  6960.     var flags = {
  6961.       '"' : '\\"',
  6962.       "\\" : "\\\\",
  6963.       "/" : "\\/",
  6964.       "\b" : "\\b",
  6965.       "\f" : "\\f",
  6966.       "\n" : "\\n",
  6967.       "\r" : "\\r",
  6968.       "\t" : "\\t",
  6969.       "\x0B" : "\\u000b"
  6970.     };
  6971.     /** @type {RegExp} */
  6972.     var prop = /\uffff/.test("\uffff") ? /[\\\"\x00-\x1f\x7f-\uffff]/g : /[\\\"\x00-\x1f\x7f-\xff]/g;
  6973.     /**
  6974.      * @param {?} obj
  6975.      * @param {Array} buffer
  6976.      * @return {undefined}
  6977.      */
  6978.     var stringify = function(obj, buffer) {
  6979.       buffer.push('"', obj.replace(prop, function(key) {
  6980.         var value = flags[key];
  6981.         if (!value) {
  6982.           /** @type {string} */
  6983.           value = "\\u" + (key.charCodeAt(0) | 65536).toString(16).substr(1);
  6984.           /** @type {string} */
  6985.           flags[key] = value;
  6986.         }
  6987.         return value;
  6988.       }), '"');
  6989.     };
  6990.     /**
  6991.      * @param {?} attributes
  6992.      * @return {?}
  6993.      */
  6994.     self.Se = function(attributes) {
  6995.       if (self.ca.JSON) {
  6996.         try {
  6997.           return self.ca.JSON.stringify(attributes);
  6998.         } catch (b) {
  6999.         }
  7000.       }
  7001.       return self.Re(attributes);
  7002.     };
  7003.     /**
  7004.      * @param {?} attributes
  7005.      * @return {?}
  7006.      */
  7007.     self.Te = function(attributes) {
  7008.       if (self.ca.JSON) {
  7009.         try {
  7010.           var primaryKey = self.ca.JSON.parse(attributes);
  7011.           return primaryKey;
  7012.         } catch (c) {
  7013.         }
  7014.       }
  7015.       return primaryKey = self.Pe(attributes);
  7016.     };
  7017.     /**
  7018.      * @return {undefined}
  7019.      */
  7020.     self.zca = function() {
  7021.     };
  7022.     /**
  7023.      * @return {undefined}
  7024.      */
  7025.     self.Ue = function() {
  7026.     };
  7027.     self.r(self.Ue, self.zca);
  7028.     /**
  7029.      * @return {?}
  7030.      */
  7031.     self.Ue.prototype.ze = function() {
  7032.       /** @type {number} */
  7033.       var ze = 0;
  7034.       self.Ie(this.ii(true), function() {
  7035.         ze++;
  7036.       });
  7037.       return ze;
  7038.     };
  7039.     /**
  7040.      * @return {undefined}
  7041.      */
  7042.     self.Ue.prototype.clear = function() {
  7043.       var r20 = children(this.ii(true));
  7044.       var file = this;
  7045.       (0, self.u)(r20, function(attributes) {
  7046.         file.remove(attributes);
  7047.       });
  7048.     };
  7049.     /**
  7050.      * @param {?} yytext
  7051.      * @return {undefined}
  7052.      */
  7053.     self.Ve = function(yytext) {
  7054.       this.$ = yytext;
  7055.     };
  7056.     self.r(self.Ve, self.Ue);
  7057.     self.h = self.Ve.prototype;
  7058.     /**
  7059.      * @return {?}
  7060.      */
  7061.     self.h.isAvailable = function() {
  7062.       if (!this.$) {
  7063.         return false;
  7064.       }
  7065.       try {
  7066.         return this.$.setItem("__sak", "1"), this.$.removeItem("__sak"), true;
  7067.       } catch (a) {
  7068.         return false;
  7069.       }
  7070.     };
  7071.     /**
  7072.      * @param {number} opt_attributes
  7073.      * @param {?} id
  7074.      * @return {undefined}
  7075.      */
  7076.     self.h.set = function(opt_attributes, id) {
  7077.       try {
  7078.         this.$.setItem(opt_attributes, id);
  7079.       } catch (c) {
  7080.         if (0 == this.$.length) {
  7081.           throw "Storage mechanism: Storage disabled";
  7082.         }
  7083.         throw "Storage mechanism: Quota exceeded";
  7084.       }
  7085.     };
  7086.     /**
  7087.      * @param {?} opt_attributes
  7088.      * @return {?}
  7089.      */
  7090.     self.h.get = function(opt_attributes) {
  7091.       opt_attributes = this.$.getItem(opt_attributes);
  7092.       if (!self.ma(opt_attributes) && null !== opt_attributes) {
  7093.         throw "Storage mechanism: Invalid value was encountered";
  7094.       }
  7095.       return opt_attributes;
  7096.     };
  7097.     /**
  7098.      * @param {string} opt_attributes
  7099.      * @return {undefined}
  7100.      */
  7101.     self.h.remove = function(opt_attributes) {
  7102.       this.$.removeItem(opt_attributes);
  7103.     };
  7104.     /**
  7105.      * @return {?}
  7106.      */
  7107.     self.h.ze = function() {
  7108.       return this.$.length;
  7109.     };
  7110.     /**
  7111.      * @param {boolean} recurring
  7112.      * @return {?}
  7113.      */
  7114.     self.h.ii = function(recurring) {
  7115.       /** @type {number} */
  7116.       var i = 0;
  7117.       var items = this.$;
  7118.       var stream = new self.Ge;
  7119.       /**
  7120.        * @return {?}
  7121.        */
  7122.       stream.next = function() {
  7123.         if (i >= items.length) {
  7124.           throw self.Fe;
  7125.         }
  7126.         var attributes = items.key(i++);
  7127.         if (recurring) {
  7128.           return attributes;
  7129.         }
  7130.         attributes = items.getItem(attributes);
  7131.         if (!self.ma(attributes)) {
  7132.           throw "Storage mechanism: Invalid value was encountered";
  7133.         }
  7134.         return attributes;
  7135.       };
  7136.       return stream;
  7137.     };
  7138.     /**
  7139.      * @return {undefined}
  7140.      */
  7141.     self.h.clear = function() {
  7142.       this.$.clear();
  7143.     };
  7144.     /**
  7145.      * @param {number} index
  7146.      * @return {?}
  7147.      */
  7148.     self.h.key = function(index) {
  7149.       return this.$.key(index);
  7150.     };
  7151.     /**
  7152.      * @return {undefined}
  7153.      */
  7154.     self.Aca = function() {
  7155.       /** @type {null} */
  7156.       var $ = null;
  7157.       try {
  7158.         $ = window.sessionStorage || null;
  7159.       } catch (b) {
  7160.       }
  7161.       this.$ = $;
  7162.     };
  7163.     self.r(self.Aca, self.Ve);
  7164.     var node;
  7165.     var num;
  7166.     var special;
  7167.     var dict;
  7168.     var tag;
  7169.     var m;
  7170.     var requestFileSystem;
  7171.     special = {};
  7172.     self.Ye = {};
  7173.     dict = {
  7174.       init : [],
  7175.       history : [],
  7176.       dispose : [],
  7177.       _e : []
  7178.     };
  7179.     /** @type {boolean} */
  7180.     self.Ze = false;
  7181.     /** @type {Array} */
  7182.     self.$e = [];
  7183.     /**
  7184.      * @param {string} type
  7185.      * @param {?} opt_attributes
  7186.      * @return {undefined}
  7187.      */
  7188.     self.af = function(type, opt_attributes) {
  7189.       var g;
  7190.       for (g in opt_attributes) {
  7191.         dict[g].push(type);
  7192.       }
  7193.       special[type] = opt_attributes;
  7194.       if (self.Ze) {
  7195.         g = self.sa(m, "init", type);
  7196.         self.$e.push(g);
  7197.       }
  7198.     };
  7199.     /**
  7200.      * @return {undefined}
  7201.      */
  7202.     self.Eca = function() {
  7203.       (0, self.u)(self.$e, function($sanitize) {
  7204.         $sanitize();
  7205.       });
  7206.       /** @type {Array} */
  7207.       self.$e = [];
  7208.     };
  7209.     /**
  7210.      * @param {string} name
  7211.      * @param {?} opt_attributes
  7212.      * @return {undefined}
  7213.      */
  7214.     self.bf = function(name, opt_attributes) {
  7215.       opt_attributes = opt_attributes || {};
  7216.       opt_attributes._e = self.R;
  7217.       self.af(name, opt_attributes);
  7218.     };
  7219.     /**
  7220.      * @param {string} T
  7221.      * @return {undefined}
  7222.      */
  7223.     self.Gca = function(T) {
  7224.       if (window.google.pmc) {
  7225.         if ("dispose" != T || self.Ze) {
  7226.           tag(T);
  7227.           if ("init" == T) {
  7228.             /** @type {boolean} */
  7229.             self.Ze = true;
  7230.           } else {
  7231.             if ("dispose" == T) {
  7232.               /** @type {boolean} */
  7233.               self.Ze = false;
  7234.               /** @type {null} */
  7235.               window.google.pmc = null;
  7236.             }
  7237.           }
  7238.         }
  7239.       }
  7240.     };
  7241.     /**
  7242.      * @param {string} idx
  7243.      * @return {undefined}
  7244.      */
  7245.     tag = function(idx) {
  7246.       ("dispose" == idx ? self.Ya : self.u)(dict[idx], function(a) {
  7247.         m(idx, a);
  7248.       });
  7249.     };
  7250.     /**
  7251.      * @param {string} i
  7252.      * @param {?} type
  7253.      * @return {undefined}
  7254.      */
  7255.     m = function(i, type) {
  7256.       try {
  7257.         var ca = special[type];
  7258.         if (ca) {
  7259.           var c = ca[i];
  7260.           var gen = window.google.pmc[type];
  7261.           if (c && (gen || requestFileSystem(type))) {
  7262.             new self.vg;
  7263.             var f = (0, self.q)();
  7264.             c(gen);
  7265.             if ("init" == i || "dispose" == i) {
  7266.               if (!self.Ye[i]) {
  7267.                 self.Ye[i] = {};
  7268.               }
  7269.               /** @type {number} */
  7270.               self.Ye[i][type] = (0, self.q)() - f;
  7271.             }
  7272.           }
  7273.         }
  7274.       } catch (attributes) {
  7275.         self.Ee(attributes, {
  7276.           cause : "m" + i,
  7277.           mid : type
  7278.         });
  7279.       }
  7280.     };
  7281.     /**
  7282.      * @param {Object} type
  7283.      * @return {?}
  7284.      */
  7285.     requestFileSystem = function(type) {
  7286.       type = special[type];
  7287.       return Boolean(type && type._e);
  7288.     };
  7289.     self.ua("google.initHistory", function() {
  7290.       num = window.google.kEI;
  7291.       node = new self.Aca;
  7292.       var destElements;
  7293.       a: {
  7294.         var n = num;
  7295.         try {
  7296.           var clone = node.get("web-mh" + n);
  7297.           if (clone) {
  7298.             destElements = self.Te(clone);
  7299.             break a;
  7300.           }
  7301.         } catch (d) {
  7302.         }
  7303.         /** @type {null} */
  7304.         destElements = null;
  7305.       }
  7306.       if (destElements) {
  7307.         window.google.pmc = destElements;
  7308.       }
  7309.     });
  7310.     self.ua("google.med", self.Gca);
  7311.     self.ua("google.raas", self.bf);
  7312.     var Jca;
  7313.     var event;
  7314.     var _forEach;
  7315.     var Mca;
  7316.     var onWindowHashChange;
  7317.     /** @type {Array} */
  7318.     self.df = [];
  7319.     event = {
  7320.       persisted : false
  7321.     };
  7322.     /**
  7323.      * @return {undefined}
  7324.      */
  7325.     _forEach = function() {
  7326.       /** @type {Array} */
  7327.       var ret = [];
  7328.       /** @type {Array} */
  7329.       var elems = [];
  7330.       /** @type {number} */
  7331.       var i = 0;
  7332.       var valuesLen = self.df.length;
  7333.       for (;i < valuesLen;i++) {
  7334.         var nodes = self.df[i]();
  7335.         if (nodes) {
  7336.           if (0 == nodes.indexOf("&")) {
  7337.             elems.push(nodes);
  7338.           } else {
  7339.             if (0 < ret.length) {
  7340.               ret.push(",");
  7341.             }
  7342.             ret.push(nodes);
  7343.           }
  7344.         }
  7345.       }
  7346.       /** @type {Array} */
  7347.       ret = ret.concat(elems);
  7348.       /** @type {boolean} */
  7349.       window.google._bfr = true;
  7350.       ret.push("&ei=", window.google.kEI);
  7351.       window.google.log("backbutton", ret.join(""));
  7352.     };
  7353.     Mca = window.google.j && window.google.j.en;
  7354.     /**
  7355.      * @param {?} event
  7356.      * @return {undefined}
  7357.      */
  7358.     onWindowHashChange = function(event) {
  7359.       if (!(!event.persisted && !Jca)) {
  7360.         if (!Mca) {
  7361.           _forEach();
  7362.         }
  7363.       }
  7364.       /** @type {boolean} */
  7365.       Jca = true;
  7366.     };
  7367.     self.bf("bbd", {
  7368.       /**
  7369.        * @return {undefined}
  7370.        */
  7371.       init : function() {
  7372.         event = {
  7373.           persisted : false
  7374.         };
  7375.         /** @type {boolean} */
  7376.         window.google._bfr = false;
  7377.       },
  7378.       /**
  7379.        * @param {(Function|string)} id
  7380.        * @return {undefined}
  7381.        */
  7382.       history : function(id) {
  7383.         if (id) {
  7384.           event.persisted = id.persisted;
  7385.         }
  7386.         if (event.persisted) {
  7387.           _forEach();
  7388.         } else {
  7389.           if (!event.persisted) {
  7390.             /** @type {boolean} */
  7391.             event.persisted = true;
  7392.             id = event;
  7393.             if (node && ("" !== num && (window.google.pmc.bbd || requestFileSystem("bbd")))) {
  7394.               /** @type {(Function|string)} */
  7395.               window.google.pmc.bbd = id;
  7396.               id = num;
  7397.               var attributes = window.google.pmc;
  7398.               try {
  7399.                 var attr = self.Se(attributes);
  7400.                 if (attr) {
  7401.                   node.set("web-mh" + id, attr);
  7402.                 }
  7403.               } catch (d) {
  7404.               }
  7405.             }
  7406.             if (window.addEventListener) {
  7407.               window.addEventListener("pageshow", onWindowHashChange, false);
  7408.               /** @type {boolean} */
  7409.               Jca = false;
  7410.             }
  7411.           }
  7412.         }
  7413.       },
  7414.       /**
  7415.        * @return {undefined}
  7416.        */
  7417.       dispose : function() {
  7418.         /** @type {number} */
  7419.         self.df.length = 0;
  7420.       }
  7421.     });
  7422.     /**
  7423.      * @param {?} obj
  7424.      * @param {string} type
  7425.      * @param {Function} fn
  7426.      * @return {undefined}
  7427.      */
  7428.     self.Ce = function(obj, type, fn) {
  7429.       if (obj.addEventListener) {
  7430.         obj.addEventListener(type, fn, false);
  7431.       } else {
  7432.         obj.attachEvent("on" + type, fn);
  7433.       }
  7434.     };
  7435.     /**
  7436.      * @param {?} obj
  7437.      * @param {string} type
  7438.      * @param {?} f
  7439.      * @return {undefined}
  7440.      */
  7441.     self.De = function(obj, type, f) {
  7442.       if (obj.removeEventListener) {
  7443.         obj.removeEventListener(type, f, false);
  7444.       } else {
  7445.         obj.detachEvent("on" + type, f);
  7446.       }
  7447.     };
  7448.     self.dha = self.wh();
  7449.     self.hi = self.kf() || self.Ab("iPod");
  7450.     self.ii = self.dh();
  7451.     self.fha = self.Ik();
  7452.     self.gha = self.Eb();
  7453.     self.ji = self.Db() && !self.mf();
  7454.     /** @type {boolean} */
  7455.     self.ui = !self.Aa;
  7456.     /**
  7457.      * @param {Object} obj
  7458.      * @param {string} name
  7459.      * @param {string} str
  7460.      * @return {undefined}
  7461.      */
  7462.     self.of = function(obj, name, str) {
  7463.       if (self.ui && obj.dataset) {
  7464.         /** @type {string} */
  7465.         obj.dataset[name] = str;
  7466.       } else {
  7467.         obj.setAttribute("data-" + self.Sa(name), str);
  7468.       }
  7469.     };
  7470.     /**
  7471.      * @param {Element} element
  7472.      * @param {string} key
  7473.      * @return {?}
  7474.      */
  7475.     self.F = function(element, key) {
  7476.       return self.ui && element.dataset ? key in element.dataset ? element.dataset[key] : null : element.getAttribute("data-" + self.Sa(key));
  7477.     };
  7478.     /**
  7479.      * @param {?} opt_attributes
  7480.      * @param {Object} name
  7481.      * @return {undefined}
  7482.      */
  7483.     self.pf = function(opt_attributes, name) {
  7484.       if (self.ui && opt_attributes.dataset) {
  7485.         delete opt_attributes.dataset[name];
  7486.       } else {
  7487.         opt_attributes.removeAttribute("data-" + self.Sa(name));
  7488.       }
  7489.     };
  7490.     /**
  7491.      * @param {Element} element
  7492.      * @param {string} key
  7493.      * @return {?}
  7494.      */
  7495.     self.qf = function(element, key) {
  7496.       return self.ui && element.dataset ? key in element.dataset : element.hasAttribute ? element.hasAttribute("data-" + self.Sa(key)) : !!element.getAttribute("data-" + self.Sa(key));
  7497.     };
  7498.     /**
  7499.      * @param {string} parent
  7500.      * @return {?}
  7501.      */
  7502.     self.rf = function(parent) {
  7503.       return parent && self.Yc(parent) ? self.F(parent, "ved") || "" : "";
  7504.     };
  7505.     var string;
  7506.     /**
  7507.      * @return {undefined}
  7508.      */
  7509.     self.sf = function() {
  7510.       /** @type {Array} */
  7511.       this.Ef = [];
  7512.       /** @type {string} */
  7513.       this.$ = "";
  7514.     };
  7515.     /**
  7516.      * @return {undefined}
  7517.      */
  7518.     self.sf.prototype.initialize = function() {
  7519.       /** @type {Array} */
  7520.       this.Ef = [];
  7521.       /** @type {string} */
  7522.       this.$ = "";
  7523.     };
  7524.     /**
  7525.      * @param {?} event
  7526.      * @param {?} dataAndEvents
  7527.      * @param {string} classNames
  7528.      * @return {undefined}
  7529.      */
  7530.     self.Oca = function(event, dataAndEvents, classNames) {
  7531.       event.Ef.push({
  7532.         bq : dataAndEvents,
  7533.         targetElement : classNames || "",
  7534.         oC : 0
  7535.       });
  7536.     };
  7537.     /**
  7538.      * @param {?} event
  7539.      * @param {string} classNames
  7540.      * @param {string} format
  7541.      * @return {undefined}
  7542.      */
  7543.     self.Pca = function(event, classNames, format) {
  7544.       event.Ef.push({
  7545.         bq : classNames || "",
  7546.         targetElement : format || "",
  7547.         oC : 1
  7548.       });
  7549.     };
  7550.     /**
  7551.      * @param {Object} doc
  7552.      * @param {Object} e
  7553.      * @return {?}
  7554.      */
  7555.     string = function(doc, e) {
  7556.       /** @type {string} */
  7557.       var parent = "";
  7558.       if (e) {
  7559.         parent = "string" == typeof e ? e : window.google.getEI(e);
  7560.       }
  7561.       return parent && parent != doc.$ ? parent : "";
  7562.     };
  7563.     /**
  7564.      * @param {string} a
  7565.      * @return {?}
  7566.      */
  7567.     self.tf = function(a) {
  7568.       var valuesLen = a.Ef.length;
  7569.       if (0 == valuesLen) {
  7570.         return "";
  7571.       }
  7572.       /** @type {Array} */
  7573.       var headers = [];
  7574.       var message;
  7575.       var value;
  7576.       /** @type {number} */
  7577.       var i = 0;
  7578.       for (;i < valuesLen;++i) {
  7579.         switch(message = string(a, a.Ef[i].targetElement) || "", a.Ef[i].oC) {
  7580.           case 0:
  7581.             headers.push(a.Ef[i].bq + "." + message + ".s");
  7582.             break;
  7583.           case 2:
  7584.             /** @type {string} */
  7585.             value = (value = string(a, a.Ef[i].pda)) ? ".0." + a.Ef[i].mW + "." + value : "";
  7586.             headers.push(a.Ef[i].bq + "." + message + ".i" + value);
  7587.             break;
  7588.           case 1:
  7589.             headers.push(a.Ef[i].bq + "." + message + ".h");
  7590.             break;
  7591.           case 3:
  7592.             /** @type {string} */
  7593.             value = (value = string(a, a.Ef[i].pda)) ? "." + value : "";
  7594.             if (a.Ef[i].mW) {
  7595.               if (a.Ef[i].bq) {
  7596.                 headers.push(a.Ef[i].bq + "." + message + ".c." + a.Ef[i].mW + value);
  7597.               }
  7598.             }
  7599.           ;
  7600.         }
  7601.       }
  7602.       /** @type {string} */
  7603.       a = "&vet=1" + headers.join(";");
  7604.       return a = 0 < headers.length ? a : "";
  7605.     };
  7606.     var parts;
  7607.     var y;
  7608.     var getEnumerableProperties;
  7609.     parts = {};
  7610.     /**
  7611.      * @param {number} n
  7612.      * @param {number} args
  7613.      * @return {?}
  7614.      */
  7615.     y = function(n, args) {
  7616.       return self.tb(n[1], args[1]);
  7617.     };
  7618.     /**
  7619.      * @param {number} opt_attributes
  7620.      * @return {undefined}
  7621.      */
  7622.     self.vf = function(opt_attributes) {
  7623.       /** @type {number} */
  7624.       var deepDataAndEvents = 0;
  7625.       /** @type {Arguments} */
  7626.       var frames = arguments;
  7627.       /** @type {number} */
  7628.       var length = frames.length;
  7629.       if (1 == length % 2) {
  7630.         deepDataAndEvents = frames[length - 1];
  7631.       }
  7632.       /** @type {number} */
  7633.       var index = 0;
  7634.       for (;index < length - 1;index += 2) {
  7635.         getEnumerableProperties(frames[index], frames[index + 1], deepDataAndEvents);
  7636.       }
  7637.     };
  7638.     /**
  7639.      * @param {(Array|string)} value
  7640.      * @param {?} variables
  7641.      * @param {number} deepDataAndEvents
  7642.      * @return {undefined}
  7643.      */
  7644.     self.wg = function(value, variables, deepDataAndEvents) {
  7645.       getEnumerableProperties(value, variables, deepDataAndEvents, true);
  7646.     };
  7647.     /**
  7648.      * @param {Array} part
  7649.      * @param {?} object
  7650.      * @param {number} deepDataAndEvents
  7651.      * @param {boolean} dataAndEvents
  7652.      * @return {undefined}
  7653.      */
  7654.     getEnumerableProperties = function(part, object, deepDataAndEvents, dataAndEvents) {
  7655.       parts[part] = parts[part] || [];
  7656.       part = parts[part];
  7657.       part.push([object, deepDataAndEvents || 0, !!dataAndEvents]);
  7658.       self.waa(part, y);
  7659.     };
  7660.     /**
  7661.      * @param {number} opt_attributes
  7662.      * @return {undefined}
  7663.      */
  7664.     self.wf = function(opt_attributes) {
  7665.       /** @type {number} */
  7666.       var i = 0;
  7667.       for (;i < arguments.length - 1;i += 2) {
  7668.         var part = parts[arguments[i]];
  7669.         if (part) {
  7670.           var iterable = arguments[i + 1];
  7671.           /** @type {number} */
  7672.           var m = 0;
  7673.           for (;m < part.length;++m) {
  7674.             if (part[m][0] == iterable) {
  7675.               self.jb(part, m);
  7676.               break;
  7677.             }
  7678.           }
  7679.         }
  7680.       }
  7681.     };
  7682.     /**
  7683.      * @param {number} opt_attributes
  7684.      * @param {Array} expectedHashCode
  7685.      * @param {Object} x
  7686.      * @param {Object} name
  7687.      * @return {?}
  7688.      */
  7689.     self.H = function(opt_attributes, expectedHashCode, x, name) {
  7690.       var type = void 0 === x ? true : x;
  7691.       /** @type {boolean} */
  7692.       var isHorizontal = false === x;
  7693.       var g = expectedHashCode && expectedHashCode[0] === x;
  7694.       if (opt_attributes in parts) {
  7695.         if (void 0 === name) {
  7696.           /** @type {boolean} */
  7697.           name = false;
  7698.         }
  7699.         var template;
  7700.         if ("function" == typeof name) {
  7701.           /** @type {Object} */
  7702.           template = name;
  7703.         } else {
  7704.           /**
  7705.            * @param {?} str
  7706.            * @return {?}
  7707.            */
  7708.           template = function(str) {
  7709.             return str === name;
  7710.           };
  7711.         }
  7712.         var res = parts[opt_attributes].slice(0);
  7713.         /** @type {number} */
  7714.         var resLength = 0;
  7715.         var fx;
  7716.         for (;fx = res[resLength++];) {
  7717.           var wrapper = fx[0];
  7718.           if (fx[2]) {
  7719.             self.wf(opt_attributes, wrapper);
  7720.           }
  7721.           fx = wrapper.apply(null, expectedHashCode || []);
  7722.           if (isHorizontal) {
  7723.             type = type || fx;
  7724.           } else {
  7725.             if (g && (expectedHashCode[0] = fx), type = fx, template(type)) {
  7726.               return type;
  7727.             }
  7728.           }
  7729.         }
  7730.       }
  7731.       return "function" == typeof name ? x : type;
  7732.     };
  7733.     /**
  7734.      * @param {?} attributes
  7735.      * @return {?}
  7736.      */
  7737.     self.xf = function(attributes) {
  7738.       if (attributes.classList) {
  7739.         return attributes.classList;
  7740.       }
  7741.       attributes = attributes.className;
  7742.       return self.ma(attributes) && attributes.match(/\S+/g) || [];
  7743.     };
  7744.     /**
  7745.      * @param {?} item
  7746.      * @param {string} name
  7747.      * @return {?}
  7748.      */
  7749.     self.J = function(item, name) {
  7750.       return item.classList ? item.classList.contains(name) : self.fb(self.xf(item), name);
  7751.     };
  7752.     /**
  7753.      * @param {?} el
  7754.      * @param {string} v
  7755.      * @return {undefined}
  7756.      */
  7757.     self.K = function(el, v) {
  7758.       if (el.classList) {
  7759.         el.classList.add(v);
  7760.       } else {
  7761.         if (!self.J(el, v)) {
  7762.           el.className += 0 < el.className.length ? " " + v : v;
  7763.         }
  7764.       }
  7765.     };
  7766.     /**
  7767.      * @param {Element} element
  7768.      * @param {Array} description
  7769.      * @return {undefined}
  7770.      */
  7771.     self.yf = function(element, description) {
  7772.       if (element.classList) {
  7773.         (0, self.u)(description, function(cx) {
  7774.           self.K(element, cx);
  7775.         });
  7776.       } else {
  7777.         var classMap = {};
  7778.         (0, self.u)(self.xf(element), function(className) {
  7779.           /** @type {boolean} */
  7780.           classMap[className] = true;
  7781.         });
  7782.         (0, self.u)(description, function(className) {
  7783.           /** @type {boolean} */
  7784.           classMap[className] = true;
  7785.         });
  7786.         /** @type {string} */
  7787.         element.className = "";
  7788.         var className;
  7789.         for (className in classMap) {
  7790.           element.className += 0 < element.className.length ? " " + className : className;
  7791.         }
  7792.       }
  7793.     };
  7794.     /**
  7795.      * @param {?} a
  7796.      * @param {string} attributes
  7797.      * @return {undefined}
  7798.      */
  7799.     self.L = function(a, attributes) {
  7800.       if (a.classList) {
  7801.         a.classList.remove(attributes);
  7802.       } else {
  7803.         if (self.J(a, attributes)) {
  7804.           a.className = (0, self.Za)(self.xf(a), function(dataAndEvents) {
  7805.             return dataAndEvents != attributes;
  7806.           }).join(" ");
  7807.         }
  7808.       }
  7809.     };
  7810.     /**
  7811.      * @param {Element} props
  7812.      * @param {Array} opt_attributes
  7813.      * @return {undefined}
  7814.      */
  7815.     self.zf = function(props, opt_attributes) {
  7816.       if (props.classList) {
  7817.         (0, self.u)(opt_attributes, function(funcToCall) {
  7818.           self.L(props, funcToCall);
  7819.         });
  7820.       } else {
  7821.         props.className = (0, self.Za)(self.xf(props), function(funcToCall) {
  7822.           return!self.fb(opt_attributes, funcToCall);
  7823.         }).join(" ");
  7824.       }
  7825.     };
  7826.     /**
  7827.      * @param {?} a
  7828.      * @param {string} value
  7829.      * @param {boolean} millis
  7830.      * @return {undefined}
  7831.      */
  7832.     self.M = function(a, value, millis) {
  7833.       if (millis) {
  7834.         self.K(a, value);
  7835.       } else {
  7836.         self.L(a, value);
  7837.       }
  7838.     };
  7839.     /**
  7840.      * @param {?} def
  7841.      * @param {string} attr
  7842.      * @param {string} cx
  7843.      * @return {?}
  7844.      */
  7845.     self.Af = function(def, attr, cx) {
  7846.       return self.J(def, attr) ? (self.L(def, attr), self.K(def, cx), true) : false;
  7847.     };
  7848.     /**
  7849.      * @param {?} def
  7850.      * @param {string} header
  7851.      * @return {?}
  7852.      */
  7853.     self.Bf = function(def, header) {
  7854.       /** @type {boolean} */
  7855.       var millis = !self.J(def, header);
  7856.       self.M(def, header, millis);
  7857.       return millis;
  7858.     };
  7859.     /**
  7860.      * @param {?} target
  7861.      * @param {string} type
  7862.      * @param {string} fn
  7863.      * @return {undefined}
  7864.      */
  7865.     self.un = function(target, type, fn) {
  7866.       self.L(target, type);
  7867.       self.K(target, fn);
  7868.     };
  7869.     var frame;
  7870.     var poll;
  7871.     /**
  7872.      * @param {?} loc
  7873.      * @param {boolean} dataAndEvents
  7874.      * @return {undefined}
  7875.      */
  7876.     self.hg = function(loc, dataAndEvents) {
  7877.       if (dataAndEvents) {
  7878.         self.ug().replace(loc);
  7879.       } else {
  7880.         self.ug().href = loc;
  7881.       }
  7882.     };
  7883.     /**
  7884.      * @param {?} url
  7885.      * @param {?} deepDataAndEvents
  7886.      * @param {boolean} dataAndEvents
  7887.      * @return {undefined}
  7888.      */
  7889.     self.Rf = function(url, deepDataAndEvents, dataAndEvents) {
  7890.       if (!self.H(32, [url, deepDataAndEvents, dataAndEvents], 0, true)) {
  7891.         try {
  7892.           if ((new RegExp("^(" + self.Rda() + ")?/(url|aclk)\\?.*&rct=j(&|$)")).test(url)) {
  7893.             if (!frame) {
  7894.               frame = window.document.createElement("iframe");
  7895.               /** @type {string} */
  7896.               frame.style.display = "none";
  7897.               self.te(frame);
  7898.             }
  7899.             /** @type {number} */
  7900.             window.google.r = 1;
  7901.             frame.src = url;
  7902.           } else {
  7903.             if (/#.*\/blank\.html$/.test(url) || /#.*about:blank$/.test(url)) {
  7904.               self.Ee(Error("n"));
  7905.             }
  7906.             self.hg(url, dataAndEvents);
  7907.           }
  7908.         } catch (d) {
  7909.           self.hg(url, dataAndEvents);
  7910.         }
  7911.       }
  7912.     };
  7913.     /**
  7914.      * @param {Object} arg
  7915.      * @param {?} deepDataAndEvents
  7916.      * @param {boolean} dataAndEvents
  7917.      * @param {?} funcToCall
  7918.      * @return {undefined}
  7919.      */
  7920.     self.Tf = function(arg, deepDataAndEvents, dataAndEvents, funcToCall) {
  7921.       self.Rf(self.mda(arg, funcToCall), deepDataAndEvents, dataAndEvents);
  7922.     };
  7923.     /**
  7924.      * @param {?} opt_attributes
  7925.      * @return {?}
  7926.      */
  7927.     self.Sf = function(opt_attributes) {
  7928.       var a = self.kd();
  7929.       var m;
  7930.       if (opt_attributes = opt_attributes || (a.hash ? a.href : "")) {
  7931.         m = opt_attributes.indexOf("#");
  7932.         opt_attributes = opt_attributes.substr(m + 1);
  7933.       }
  7934.       var n = a.search ? a.href.substr(a.href.indexOf("?") + 1).replace(/#.*/, "") : "";
  7935.       m = opt_attributes && opt_attributes.match(/(^|&)q=/);
  7936.       opt_attributes = (m ? opt_attributes : n).replace(/(^|&)(fp|tch)=[^&]*/g, "").replace(/^&/, "");
  7937.       return(m ? "/search" : a.pathname) + (opt_attributes ? "?" + opt_attributes : "");
  7938.     };
  7939.     /**
  7940.      * @param {string} dataAndEvents
  7941.      * @param {string} path
  7942.      * @param {string} callback
  7943.      * @param {string} expr
  7944.      * @return {?}
  7945.      */
  7946.     self.sh = function(dataAndEvents, path, callback, expr) {
  7947.       callback = expr ? callback : (0, window.encodeURIComponent)(callback);
  7948.       /** @type {RegExp} */
  7949.       expr = new RegExp("([#?&]" + dataAndEvents + "=)[^&#]*");
  7950.       return path = expr.test(path) ? path.replace(expr, "$1" + callback) : path + ("&" + dataAndEvents + "=" + callback);
  7951.     };
  7952.     /**
  7953.      * @param {Object} target
  7954.      * @param {?} funcToCall
  7955.      * @return {?}
  7956.      */
  7957.     self.mda = function(target, funcToCall) {
  7958.       var results = {};
  7959.       if (!funcToCall) {
  7960.         var nodes = self.Sf().match(/[?&][\w\.\-~]+=([^&]*)/g);
  7961.         if (nodes) {
  7962.           /** @type {number} */
  7963.           var i = 0;
  7964.           var x;
  7965.           for (;x = nodes[i++];) {
  7966.             x = x.match(/([\w\.\-~]+?)=(.*)/);
  7967.             var data = x[2];
  7968.             results[x[1]] = data;
  7969.           }
  7970.         }
  7971.       }
  7972.       for (x in target) {
  7973.         if (target.hasOwnProperty(x)) {
  7974.           data = target[x];
  7975.           if (null == data) {
  7976.             delete results[x];
  7977.           } else {
  7978.             results[x] = data.toString().replace(/[&#]/g, window.encodeURIComponent);
  7979.           }
  7980.         }
  7981.       }
  7982.       /** @type {string} */
  7983.       nodes = "/search?";
  7984.       /** @type {boolean} */
  7985.       i = true;
  7986.       for (x in results) {
  7987.         if (results.hasOwnProperty(x)) {
  7988.           /** @type {string} */
  7989.           nodes = nodes.concat((i ? "" : "&") + x + "=" + results[x]);
  7990.           /** @type {boolean} */
  7991.           i = false;
  7992.         }
  7993.       }
  7994.       return nodes;
  7995.     };
  7996.     /**
  7997.      * @return {undefined}
  7998.      */
  7999.     poll = function() {
  8000.       var sTimeout = window._gjuc;
  8001.       if (sTimeout) {
  8002.         if (!(self.kd().hash && sTimeout())) {
  8003.           window.setTimeout(poll, 500);
  8004.         }
  8005.       }
  8006.     };
  8007.     /**
  8008.      * @return {undefined}
  8009.      */
  8010.     self.hda = function() {
  8011.       var cancelAnimationFrame = window._gjuc;
  8012.       if (cancelAnimationFrame) {
  8013.         if (!cancelAnimationFrame()) {
  8014.           if ("onhashchange" in window) {
  8015.             /**
  8016.              * @return {undefined}
  8017.              */
  8018.             window.onhashchange = function() {
  8019.               cancelAnimationFrame();
  8020.             };
  8021.           } else {
  8022.             poll();
  8023.           }
  8024.         }
  8025.       }
  8026.     };
  8027.     /**
  8028.      * @return {?}
  8029.      */
  8030.     self.Zf = function() {
  8031.       return self.ie(window.document.body || window.document.documentElement);
  8032.     };
  8033.     /**
  8034.      * @param {?} attributes
  8035.      * @param {Object} optgroup
  8036.      * @param {boolean} recurring
  8037.      * @return {?}
  8038.      */
  8039.     self.$f = function(attributes, optgroup, recurring) {
  8040.       if (initEvent()) {
  8041.         optgroup = optgroup.replace(/\-([a-z])/g, function(dataAndEvents, letter) {
  8042.           return letter.toUpperCase();
  8043.         });
  8044.         optgroup = attributes.currentStyle && attributes.currentStyle[optgroup] || "";
  8045.         if (!recurring) {
  8046.           if (!/^-?\d/.test(optgroup)) {
  8047.             return 0;
  8048.           }
  8049.           recurring = attributes.style.left;
  8050.           /** @type {Object} */
  8051.           attributes.style.left = optgroup;
  8052.           optgroup = attributes.style.pixelLeft;
  8053.           /** @type {boolean} */
  8054.           attributes.style.left = recurring;
  8055.         }
  8056.         return optgroup;
  8057.       }
  8058.       attributes = self.Nd(attributes, optgroup);
  8059.       return recurring ? attributes : Number(self.saa(attributes, "px")) || 0;
  8060.     };
  8061.     /**
  8062.      * @param {string} clone
  8063.      * @return {?}
  8064.      */
  8065.     self.ag = function(clone) {
  8066.       var destElements;
  8067.       if (initEvent()) {
  8068.         if (!destElements) {
  8069.           /** @type {number} */
  8070.           destElements = clone.offsetHeight - self.$f(clone, "paddingTop") - self.$f(clone, "paddingBottom") - self.$f(clone, "borderTop") - self.$f(clone, "borderBottom");
  8071.         }
  8072.       } else {
  8073.         destElements = self.$f(clone, "height");
  8074.         if ((0, window.isNaN)(destElements) || 0 == destElements) {
  8075.           if (clone.offsetHeight) {
  8076.             /** @type {number} */
  8077.             destElements = clone.offsetHeight - self.$f(clone, "padding-top") - self.$f(clone, "padding-bottom") - self.$f(clone, "border-top-width") - self.$f(clone, "border-bottom-width");
  8078.           }
  8079.         }
  8080.       }
  8081.       return(0, window.isNaN)(destElements) || 0 > destElements ? 0 : destElements;
  8082.     };
  8083.     /**
  8084.      * @param {Element} el
  8085.      * @return {?}
  8086.      */
  8087.     self.bg = function(el) {
  8088.       var box;
  8089.       if (initEvent()) {
  8090.         if (!(box = el.style.pixelWidth || 0)) {
  8091.           /** @type {number} */
  8092.           box = el.offsetWidth - self.$f(el, "paddingLeft") - self.$f(el, "paddingRight") - self.$f(el, "borderLeft") - self.$f(el, "borderRight");
  8093.         }
  8094.       } else {
  8095.         box = self.$f(el, "width");
  8096.         if ((0, window.isNaN)(box) || 0 == box) {
  8097.           if (el.offsetWidth) {
  8098.             /** @type {number} */
  8099.             box = el.offsetWidth - self.$f(el, "padding-left") - self.$f(el, "padding-right") - self.$f(el, "border-left-width") - self.$f(el, "border-right-width");
  8100.           }
  8101.         }
  8102.       }
  8103.       return(0, window.isNaN)(box) || 0 > box ? 0 : box;
  8104.     };
  8105.     /**
  8106.      * @param {Object} e
  8107.      * @return {undefined}
  8108.      */
  8109.     self.Bma = function(e) {
  8110.       if (null != e) {
  8111.         if (self.ge(e)) {
  8112.           if (self.Pb) {
  8113.             /** @type {string} */
  8114.             e.style.display = "none";
  8115.             self.td(e.offsetHeight);
  8116.             /** @type {string} */
  8117.             e.style.display = "";
  8118.           }
  8119.         }
  8120.       }
  8121.     };
  8122.     /** @type {number} */
  8123.     self.Li = 0;
  8124.     /** @type {number} */
  8125.     self.vfa = 0;
  8126.     /** @type {string} */
  8127.     self.Wha = "";
  8128.     /** @type {boolean} */
  8129.     self.Zha = false;
  8130.     /** @type {boolean} */
  8131.     self.$ha = false;
  8132.     self.ua("google.vm.e", function() {
  8133.       return "";
  8134.     });
  8135.     /**
  8136.      * @param {Object} e
  8137.      * @return {?}
  8138.      */
  8139.     self.dg = function(e) {
  8140.       if (!e) {
  8141.         e = window.event;
  8142.       }
  8143.       return e.target || e.srcElement;
  8144.     };
  8145.     /**
  8146.      * @param {Node} event
  8147.      * @return {undefined}
  8148.      */
  8149.     self.eg = function(event) {
  8150.       event = event || window.event;
  8151.       if (event.stopPropagation) {
  8152.         event.stopPropagation();
  8153.       } else {
  8154.         /** @type {boolean} */
  8155.         event.cancelBubble = true;
  8156.       }
  8157.     };
  8158.     /**
  8159.      * @param {Function} matcherFunction
  8160.      * @param {?} dataAndEvents
  8161.      * @return {?}
  8162.      */
  8163.     self.Hh = function(matcherFunction, dataAndEvents) {
  8164.       /** @type {number} */
  8165.       var tOffset = 0;
  8166.       /** @type {boolean} */
  8167.       var d = false;
  8168.       /** @type {null} */
  8169.       var args = null;
  8170.       return function() {
  8171.         var t = (0, self.q)();
  8172.         if (d) {
  8173.           /** @type {Array.<?>} */
  8174.           args = Array.prototype.slice.call(arguments, 0);
  8175.         } else {
  8176.           if (100 <= t - tOffset) {
  8177.             tOffset = t;
  8178.             matcherFunction.apply(null, arguments);
  8179.           } else {
  8180.             if (dataAndEvents) {
  8181.               /** @type {number} */
  8182.               t = 100 - (t - tOffset);
  8183.               /** @type {boolean} */
  8184.               d = true;
  8185.               /** @type {Array.<?>} */
  8186.               args = Array.prototype.slice.call(arguments, 0);
  8187.               window.setTimeout(function() {
  8188.                 /** @type {boolean} */
  8189.                 d = false;
  8190.                 tOffset = (0, self.q)();
  8191.                 matcherFunction.apply(null, args);
  8192.               }, t);
  8193.             }
  8194.           }
  8195.         }
  8196.       };
  8197.     };
  8198.     /**
  8199.      * @param {boolean} charset
  8200.      * @param {boolean} elements
  8201.      * @param {Array} scope
  8202.      * @param {Object} parts
  8203.      * @param {Object} pres
  8204.      * @param {string} message
  8205.      * @param {string} file
  8206.      * @param {string} ps
  8207.      * @return {undefined}
  8208.      */
  8209.     self.nda = function(charset, elements, scope, parts, pres, message, file, ps) {
  8210.       /** @type {string} */
  8211.       var name = charset ? "&ved=" + charset : "";
  8212.       var y = elements ? window.google.getEI(elements) : window.google.kEI;
  8213.       var s = scope || [];
  8214.       parts = parts || [];
  8215.       pres = pres || [];
  8216.       message = message || "";
  8217.       file = file || "";
  8218.       var v = new self.sf;
  8219.       var len = s.length;
  8220.       var _total = pres.length;
  8221.       v.$ = y;
  8222.       /** @type {number} */
  8223.       y = 0;
  8224.       for (;y < len;y++) {
  8225.         if (y >= _total || pres[y]) {
  8226.           self.Oca(v, s[y], parts[y]);
  8227.         } else {
  8228.           self.Pca(v, s[y], parts[y]);
  8229.         }
  8230.       }
  8231.       if (0 == len) {
  8232.         if (0 < pres.length) {
  8233.           if (!pres[0]) {
  8234.             self.Pca(v);
  8235.           }
  8236.         }
  8237.       }
  8238.       s = self.tf(v);
  8239.       if (y = elements || parts && parts[0]) {
  8240.         window.google.log(message, file + name + s + "", "", y, ps);
  8241.       } else {
  8242.         self.Ee(Error("o"), {
  8243.           ved : charset,
  8244.           trE : elements,
  8245.           vet : scope && scope[0],
  8246.           taE : parts && parts[0],
  8247.           ct : message,
  8248.           data : file,
  8249.           path : ps
  8250.         });
  8251.       }
  8252.     };
  8253.     /**
  8254.      * @param {boolean} item
  8255.      * @param {Object} parts
  8256.      * @param {Object} pres
  8257.      * @param {string} output
  8258.      * @param {Object} target
  8259.      * @param {string} ps
  8260.      * @return {undefined}
  8261.      */
  8262.     self.fg = function(item, parts, pres, output, target, ps) {
  8263.       var data = item ? self.rf(item) : "";
  8264.       if (!item || data) {
  8265.         /** @type {Array} */
  8266.         var ret = [];
  8267.         if (parts) {
  8268.           /** @type {number} */
  8269.           var i = 0;
  8270.           var part;
  8271.           for (;part = parts[i];i++) {
  8272.             if (part = self.rf(part)) {
  8273.               ret.push(part);
  8274.             } else {
  8275.               self.Ee(Error("Ac"), {
  8276.                 trE : item ? 1 : 0,
  8277.                 i : i,
  8278.                 ct : output,
  8279.                 data : target,
  8280.                 path : ps
  8281.               });
  8282.             }
  8283.           }
  8284.         }
  8285.         self.nda(data, item, ret, parts, pres, output, target, ps);
  8286.       }
  8287.     };
  8288.     /**
  8289.      * @param {string} type
  8290.      * @param {string} c
  8291.      * @param {string} s
  8292.      * @param {?} obj
  8293.      * @return {undefined}
  8294.      */
  8295.     self.gg = function(type, c, s, obj) {
  8296.       var charset = self.rf(type);
  8297.       window.google.log(c || "", (s || "") + (charset ? "&ved=" + charset : "") + "", "", type, obj);
  8298.     };
  8299.     /**
  8300.      * @param {?} dataAndEvents
  8301.      * @param {Object} node
  8302.      * @param {?} deepDataAndEvents
  8303.      * @return {undefined}
  8304.      */
  8305.     var $Node = function(dataAndEvents, node, deepDataAndEvents) {
  8306.       this.ha = deepDataAndEvents;
  8307.       this.ga = dataAndEvents;
  8308.       /** @type {Object} */
  8309.       this.ma = node;
  8310.       /** @type {number} */
  8311.       this.ia = 0;
  8312.       /** @type {null} */
  8313.       this.$ = null;
  8314.     };
  8315.     /**
  8316.      * @return {?}
  8317.      */
  8318.     $Node.prototype.get = function() {
  8319.       var source;
  8320.       if (0 < this.ia) {
  8321.         this.ia--;
  8322.         source = this.$;
  8323.         this.$ = source.next;
  8324.         /** @type {null} */
  8325.         source.next = null;
  8326.       } else {
  8327.         source = this.ga();
  8328.       }
  8329.       return source;
  8330.     };
  8331.     /**
  8332.      * @param {Object} node
  8333.      * @param {?} attributes
  8334.      * @return {undefined}
  8335.      */
  8336.     var append = function(node, attributes) {
  8337.       node.ma(attributes);
  8338.       if (node.ia < node.ha) {
  8339.         node.ia++;
  8340.         attributes.next = node.$;
  8341.         node.$ = attributes;
  8342.       }
  8343.     };
  8344.     var extend;
  8345.     var addleadingZero;
  8346.     var create;
  8347.     var jQuery;
  8348.     /**
  8349.      * @param {?} b
  8350.      * @return {undefined}
  8351.      */
  8352.     extend = function(b) {
  8353.       self.ca.setTimeout(function() {
  8354.         throw b;
  8355.       }, 0);
  8356.     };
  8357.     /**
  8358.      * @param {Function} style
  8359.      * @param {?} item
  8360.      * @return {undefined}
  8361.      */
  8362.     self.xg = function(style, item) {
  8363.       /** @type {Function} */
  8364.       var tmp = style;
  8365.       if (item) {
  8366.         tmp = (0, self.p)(style, item);
  8367.       }
  8368.       tmp = jQuery(tmp);
  8369.       if (!self.pa(self.ca.setImmediate) || self.ca.Window && (self.ca.Window.prototype && self.ca.Window.prototype.setImmediate == self.ca.setImmediate)) {
  8370.         if (!addleadingZero) {
  8371.           addleadingZero = create();
  8372.         }
  8373.         addleadingZero(tmp);
  8374.       } else {
  8375.         self.ca.setImmediate(tmp);
  8376.       }
  8377.     };
  8378.     /**
  8379.      * @return {?}
  8380.      */
  8381.     create = function() {
  8382.       var Channel = self.ca.MessageChannel;
  8383.       if ("undefined" === typeof Channel) {
  8384.         if ("undefined" !== typeof window) {
  8385.           if (window.postMessage) {
  8386.             if (window.addEventListener) {
  8387.               if (!self.ch()) {
  8388.                 /**
  8389.                  * @return {undefined}
  8390.                  */
  8391.                 Channel = function() {
  8392.                   var f = window.document.createElement("IFRAME");
  8393.                   /** @type {string} */
  8394.                   f.style.display = "none";
  8395.                   /** @type {string} */
  8396.                   f.src = "";
  8397.                   window.document.documentElement.appendChild(f);
  8398.                   var win = f.contentWindow;
  8399.                   f = win.document;
  8400.                   f.open();
  8401.                   f.write("");
  8402.                   f.close();
  8403.                   /** @type {string} */
  8404.                   var messageName = "callImmediate" + Math.random();
  8405.                   /** @type {string} */
  8406.                   var url = "file:" == win.location.protocol ? "*" : win.location.protocol + "//" + win.location.host;
  8407.                   f = (0, self.p)(function(event) {
  8408.                     if (("*" == url || event.origin == url) && event.data == messageName) {
  8409.                       this.port1.onmessage();
  8410.                     }
  8411.                   }, this);
  8412.                   win.addEventListener("message", f, false);
  8413.                   this.port1 = {};
  8414.                   this.port2 = {
  8415.                     /**
  8416.                      * @return {undefined}
  8417.                      */
  8418.                     postMessage : function() {
  8419.                       win.postMessage(messageName, url);
  8420.                     }
  8421.                   };
  8422.                 };
  8423.               }
  8424.             }
  8425.           }
  8426.         }
  8427.       }
  8428.       if ("undefined" !== typeof Channel && !self.Cb()) {
  8429.         var channel = new Channel;
  8430.         var head = {};
  8431.         var tail = head;
  8432.         /**
  8433.          * @return {undefined}
  8434.          */
  8435.         channel.port1.onmessage = function() {
  8436.           if (self.Uf(head.next)) {
  8437.             head = head.next;
  8438.             var cb = head.cb;
  8439.             /** @type {null} */
  8440.             head.cb = null;
  8441.             cb();
  8442.           }
  8443.         };
  8444.         return function(cb) {
  8445.           tail.next = {
  8446.             /** @type {Function} */
  8447.             cb : cb
  8448.           };
  8449.           tail = tail.next;
  8450.           channel.port2.postMessage(0);
  8451.         };
  8452.       }
  8453.       return "undefined" !== typeof window.document && "onreadystatechange" in window.document.createElement("SCRIPT") ? function(fetchOnlyFunction) {
  8454.         var script = window.document.createElement("SCRIPT");
  8455.         /**
  8456.          * @return {undefined}
  8457.          */
  8458.         script.onreadystatechange = function() {
  8459.           /** @type {null} */
  8460.           script.onreadystatechange = null;
  8461.           script.parentNode.removeChild(script);
  8462.           /** @type {null} */
  8463.           script = null;
  8464.           fetchOnlyFunction();
  8465.           /** @type {null} */
  8466.           fetchOnlyFunction = null;
  8467.         };
  8468.         window.document.documentElement.appendChild(script);
  8469.       } : function(funcToCall) {
  8470.         self.ca.setTimeout(funcToCall, 0);
  8471.       };
  8472.     };
  8473.     /** @type {function (?): ?} */
  8474.     jQuery = self.$b;
  8475.     /**
  8476.      * @return {undefined}
  8477.      */
  8478.     var dialog = function() {
  8479.       /** @type {null} */
  8480.       this.ia = this.$ = null;
  8481.     };
  8482.     var header = new $Node(function() {
  8483.       return new grid;
  8484.     }, function(record) {
  8485.       record.reset();
  8486.     }, 100);
  8487.     /**
  8488.      * @param {(number|string)} attributes
  8489.      * @param {Array} attr
  8490.      * @return {undefined}
  8491.      */
  8492.     dialog.prototype.add = function(attributes, attr) {
  8493.       var $ = header.get();
  8494.       $.set(attributes, attr);
  8495.       if (this.ia) {
  8496.         this.ia.next = $;
  8497.       } else {
  8498.         this.$ = $;
  8499.       }
  8500.       this.ia = $;
  8501.     };
  8502.     /**
  8503.      * @return {?}
  8504.      */
  8505.     dialog.prototype.remove = function() {
  8506.       /** @type {null} */
  8507.       var removed = null;
  8508.       if (this.$) {
  8509.         removed = this.$;
  8510.         this.$ = this.$.next;
  8511.         if (!this.$) {
  8512.           /** @type {null} */
  8513.           this.ia = null;
  8514.         }
  8515.         /** @type {null} */
  8516.         removed.next = null;
  8517.       }
  8518.       return removed;
  8519.     };
  8520.     /**
  8521.      * @return {undefined}
  8522.      */
  8523.     var grid = function() {
  8524.       /** @type {null} */
  8525.       this.next = this.scope = this.Kk = null;
  8526.     };
  8527.     /**
  8528.      * @param {number} opt_attributes
  8529.      * @param {?} id
  8530.      * @return {undefined}
  8531.      */
  8532.     grid.prototype.set = function(opt_attributes, id) {
  8533.       /** @type {number} */
  8534.       this.Kk = opt_attributes;
  8535.       this.scope = id;
  8536.       /** @type {null} */
  8537.       this.next = null;
  8538.     };
  8539.     /**
  8540.      * @return {undefined}
  8541.      */
  8542.     grid.prototype.reset = function() {
  8543.       /** @type {null} */
  8544.       this.next = this.scope = this.Kk = null;
  8545.     };
  8546.     var resolveOne;
  8547.     var resolvePromise;
  8548.     var Yda;
  8549.     var _;
  8550.     var transition;
  8551.     /**
  8552.      * @param {string} config
  8553.      * @param {Array} protoProps
  8554.      * @return {undefined}
  8555.      */
  8556.     self.$da = function(config, protoProps) {
  8557.       if (!resolveOne) {
  8558.         resolvePromise();
  8559.       }
  8560.       if (!Yda) {
  8561.         resolveOne();
  8562.         /** @type {boolean} */
  8563.         Yda = true;
  8564.       }
  8565.       _.add(config, protoProps);
  8566.     };
  8567.     /**
  8568.      * @return {undefined}
  8569.      */
  8570.     resolvePromise = function() {
  8571.       if (self.ca.Promise && self.ca.Promise.resolve) {
  8572.         var n = self.ca.Promise.resolve(void 0);
  8573.         /**
  8574.          * @return {undefined}
  8575.          */
  8576.         resolveOne = function() {
  8577.           n.then(transition);
  8578.         };
  8579.       } else {
  8580.         /**
  8581.          * @return {undefined}
  8582.          */
  8583.         resolveOne = function() {
  8584.           self.xg(transition);
  8585.         };
  8586.       }
  8587.     };
  8588.     /** @type {boolean} */
  8589.     Yda = false;
  8590.     _ = new dialog;
  8591.     /**
  8592.      * @return {undefined}
  8593.      */
  8594.     transition = function() {
  8595.       /** @type {null} */
  8596.       var value = null;
  8597.       for (;value = _.remove();) {
  8598.         try {
  8599.           value.Kk.call(value.scope);
  8600.         } catch (config) {
  8601.           extend(config);
  8602.         }
  8603.         append(header, value);
  8604.       }
  8605.       /** @type {boolean} */
  8606.       Yda = false;
  8607.     };
  8608.     var execute;
  8609.     /**
  8610.      * @param {Function} a
  8611.      * @return {undefined}
  8612.      */
  8613.     execute = function(a) {
  8614.       a.prototype.then = a.prototype.then;
  8615.       /** @type {boolean} */
  8616.       a.prototype.$goog_Thenable = true;
  8617.     };
  8618.     /**
  8619.      * @param {?} object
  8620.      * @return {?}
  8621.      */
  8622.     self.cea = function(object) {
  8623.       if (!object) {
  8624.         return false;
  8625.       }
  8626.       try {
  8627.         return!!object.$goog_Thenable;
  8628.       } catch (b) {
  8629.         return false;
  8630.       }
  8631.     };
  8632.     var sprite;
  8633.     var seg;
  8634.     var sort;
  8635.     var elementFromPoint;
  8636.     var _keys;
  8637.     var print;
  8638.     var defaults;
  8639.     var prepare;
  8640.     var constructor;
  8641.     /**
  8642.      * @param {?} next_callback
  8643.      * @param {?} next_scope
  8644.      * @return {undefined}
  8645.      */
  8646.     self.Bg = function(next_callback, next_scope) {
  8647.       /** @type {number} */
  8648.       this.$ = 0;
  8649.       this.na = void 0;
  8650.       /** @type {null} */
  8651.       this.ha = this.ia = this.ga = null;
  8652.       /** @type {boolean} */
  8653.       this.ma = this.ka = false;
  8654.       if (next_callback != self.R) {
  8655.         try {
  8656.           var n = this;
  8657.           next_callback.call(next_scope, function(opt_attributes) {
  8658.             concat(n, 2, opt_attributes);
  8659.           }, function(opt_attributes) {
  8660.             concat(n, 3, opt_attributes);
  8661.           });
  8662.         } catch (attributes) {
  8663.           concat(this, 3, attributes);
  8664.         }
  8665.       }
  8666.     };
  8667.     /**
  8668.      * @return {undefined}
  8669.      */
  8670.     sprite = function() {
  8671.       /** @type {null} */
  8672.       this.next = this.context = this.ia = this.ha = this.$ = null;
  8673.       /** @type {boolean} */
  8674.       this.ga = false;
  8675.     };
  8676.     /**
  8677.      * @return {undefined}
  8678.      */
  8679.     sprite.prototype.reset = function() {
  8680.       /** @type {null} */
  8681.       this.context = this.ia = this.ha = this.$ = null;
  8682.       /** @type {boolean} */
  8683.       this.ga = false;
  8684.     };
  8685.     seg = new $Node(function() {
  8686.       return new sprite;
  8687.     }, function(record) {
  8688.       record.reset();
  8689.     }, 100);
  8690.     /**
  8691.      * @param {string} x
  8692.      * @param {string} key
  8693.      * @param {Object} a
  8694.      * @return {?}
  8695.      */
  8696.     sort = function(x, key, a) {
  8697.       var data = seg.get();
  8698.       /** @type {string} */
  8699.       data.ha = x;
  8700.       /** @type {string} */
  8701.       data.ia = key;
  8702.       /** @type {Object} */
  8703.       data.context = a;
  8704.       return data;
  8705.     };
  8706.     /**
  8707.      * @param {?} opt_attributes
  8708.      * @return {?}
  8709.      */
  8710.     self.Cg = function(opt_attributes) {
  8711.       if (opt_attributes instanceof self.Bg) {
  8712.         return opt_attributes;
  8713.       }
  8714.       var n = new self.Bg(self.R);
  8715.       concat(n, 2, opt_attributes);
  8716.       return n;
  8717.     };
  8718.     /**
  8719.      * @param {?} outErr
  8720.      * @return {?}
  8721.      */
  8722.     self.dea = function(outErr) {
  8723.       return new self.Bg(function(dataAndEvents, cb) {
  8724.         cb(outErr);
  8725.       });
  8726.     };
  8727.     /**
  8728.      * @param {string} name
  8729.      * @param {?} i
  8730.      * @param {Function} opts
  8731.      * @return {undefined}
  8732.      */
  8733.     self.$ga = function(name, i, opts) {
  8734.       if (!objEquiv(name, i, opts, null)) {
  8735.         self.$da(self.sa(i, name));
  8736.       }
  8737.     };
  8738.     /**
  8739.      * @param {Array} heads
  8740.      * @return {?}
  8741.      */
  8742.     self.eea = function(heads) {
  8743.       return new self.Bg(function(on, getProperty) {
  8744.         var numHeads = heads.length;
  8745.         /** @type {Array} */
  8746.         var failuresLink = [];
  8747.         if (numHeads) {
  8748.           /**
  8749.            * @param {number} id
  8750.            * @param {?} obj
  8751.            * @return {undefined}
  8752.            */
  8753.           var i = function(id, obj) {
  8754.             numHeads--;
  8755.             failuresLink[id] = obj;
  8756.             if (0 == numHeads) {
  8757.               on(failuresLink);
  8758.             }
  8759.           };
  8760.           /**
  8761.            * @param {?} name
  8762.            * @return {undefined}
  8763.            */
  8764.           var opts = function(name) {
  8765.             getProperty(name);
  8766.           };
  8767.           /** @type {number} */
  8768.           var h = 0;
  8769.           var handle;
  8770.           for (;h < heads.length;h++) {
  8771.             handle = heads[h];
  8772.             self.$ga(handle, self.sa(i, h), opts);
  8773.           }
  8774.         } else {
  8775.           on(failuresLink);
  8776.         }
  8777.       });
  8778.     };
  8779.     /**
  8780.      * @return {?}
  8781.      */
  8782.     self.Eg = function() {
  8783.       var text;
  8784.       var result;
  8785.       var fn = new self.Bg(function(textAlt, subKey) {
  8786.         text = textAlt;
  8787.         result = subKey;
  8788.       });
  8789.       return new Promise(fn, text, result);
  8790.     };
  8791.     /**
  8792.      * @param {string} property
  8793.      * @param {?} options
  8794.      * @param {Object} next
  8795.      * @return {?}
  8796.      */
  8797.     self.Bg.prototype.then = function(property, options, next) {
  8798.       return self.gea(this, self.pa(property) ? property : null, self.pa(options) ? options : null, next);
  8799.     };
  8800.     execute(self.Bg);
  8801.     /**
  8802.      * @param {?} tasks
  8803.      * @param {Text} x
  8804.      * @param {Object} t
  8805.      * @return {?}
  8806.      */
  8807.     self.Fg = function(tasks, x, t) {
  8808.       x = sort(x, x, t);
  8809.       /** @type {boolean} */
  8810.       x.ga = true;
  8811.       _keys(tasks, x);
  8812.       return tasks;
  8813.     };
  8814.     /**
  8815.      * @param {?} e
  8816.      * @return {undefined}
  8817.      */
  8818.     self.Bg.prototype.cancel = function(e) {
  8819.       if (0 == this.$) {
  8820.         self.$da(function() {
  8821.           var activeClassName = new self.Gg(e);
  8822.           elementFromPoint(this, activeClassName);
  8823.         }, this);
  8824.       }
  8825.     };
  8826.     /**
  8827.      * @param {Object} doc
  8828.      * @param {Object} element
  8829.      * @return {undefined}
  8830.      */
  8831.     elementFromPoint = function(doc, element) {
  8832.       if (0 == doc.$) {
  8833.         if (doc.ga) {
  8834.           var body = doc.ga;
  8835.           if (body.ia) {
  8836.             /** @type {number} */
  8837.             var self = 0;
  8838.             /** @type {null} */
  8839.             var name = null;
  8840.             /** @type {null} */
  8841.             var fn = null;
  8842.             var n = body.ia;
  8843.             for (;n && (n.ga || (self++, n.$ == doc && (name = n), !(name && 1 < self)));n = n.next) {
  8844.               if (!name) {
  8845.                 fn = n;
  8846.               }
  8847.             }
  8848.             if (name) {
  8849.               if (0 == body.$ && 1 == self) {
  8850.                 elementFromPoint(body, element);
  8851.               } else {
  8852.                 if (fn) {
  8853.                   self = fn;
  8854.                   if (self.next == body.ha) {
  8855.                     body.ha = self;
  8856.                   }
  8857.                   self.next = self.next.next;
  8858.                 } else {
  8859.                   matcher(body);
  8860.                 }
  8861.                 print(body, name, 3, element);
  8862.               }
  8863.             }
  8864.           }
  8865.           /** @type {null} */
  8866.           doc.ga = null;
  8867.         } else {
  8868.           concat(doc, 3, element);
  8869.         }
  8870.       }
  8871.     };
  8872.     /**
  8873.      * @param {?} obj
  8874.      * @param {?} list
  8875.      * @return {undefined}
  8876.      */
  8877.     _keys = function(obj, list) {
  8878.       if (!obj.ia) {
  8879.         if (!(2 != obj.$ && 3 != obj.$)) {
  8880.           isElement(obj);
  8881.         }
  8882.       }
  8883.       if (obj.ha) {
  8884.         obj.ha.next = list;
  8885.       } else {
  8886.         obj.ia = list;
  8887.       }
  8888.       obj.ha = list;
  8889.     };
  8890.     /**
  8891.      * @param {?} results
  8892.      * @param {boolean} matches
  8893.      * @param {boolean} url
  8894.      * @param {?} item
  8895.      * @return {?}
  8896.      */
  8897.     self.gea = function(results, matches, url, item) {
  8898.       var options = sort(null, null, null);
  8899.       options.$ = new self.Bg(function(forOwn, opt_callback) {
  8900.         options.ha = matches ? function(opt_attributes) {
  8901.           try {
  8902.             var attributes = matches.call(item, opt_attributes);
  8903.             forOwn(attributes);
  8904.           } catch (gl) {
  8905.             opt_callback(gl);
  8906.           }
  8907.         } : forOwn;
  8908.         options.ia = url ? function(opt_attributes) {
  8909.           try {
  8910.             var attributes = url.call(item, opt_attributes);
  8911.             if (!self.Uf(attributes) && opt_attributes instanceof self.Gg) {
  8912.               opt_callback(opt_attributes);
  8913.             } else {
  8914.               forOwn(attributes);
  8915.             }
  8916.           } catch (gl) {
  8917.             opt_callback(gl);
  8918.           }
  8919.         } : opt_callback;
  8920.       });
  8921.       options.$.ga = results;
  8922.       _keys(results, options);
  8923.       return options.$;
  8924.     };
  8925.     /**
  8926.      * @param {?} opt_attributes
  8927.      * @return {undefined}
  8928.      */
  8929.     self.Bg.prototype.ra = function(opt_attributes) {
  8930.       /** @type {number} */
  8931.       this.$ = 0;
  8932.       concat(this, 2, opt_attributes);
  8933.     };
  8934.     /**
  8935.      * @param {?} opt_attributes
  8936.      * @return {undefined}
  8937.      */
  8938.     self.Bg.prototype.ya = function(opt_attributes) {
  8939.       /** @type {number} */
  8940.       this.$ = 0;
  8941.       concat(this, 3, opt_attributes);
  8942.     };
  8943.     /**
  8944.      * @param {string} item
  8945.      * @param {number} expectedNumberOfNonCommentArgs
  8946.      * @param {Object} opt_attributes
  8947.      * @return {undefined}
  8948.      */
  8949.     var concat = function(item, expectedNumberOfNonCommentArgs, opt_attributes) {
  8950.       if (0 == item.$) {
  8951.         if (item == opt_attributes) {
  8952.           /** @type {number} */
  8953.           expectedNumberOfNonCommentArgs = 3;
  8954.           /** @type {TypeError} */
  8955.           opt_attributes = new TypeError("Promise cannot resolve to itself");
  8956.         }
  8957.         /** @type {number} */
  8958.         item.$ = 1;
  8959.         if (!objEquiv(opt_attributes, item.ra, item.ya, item)) {
  8960.           /** @type {Object} */
  8961.           item.na = opt_attributes;
  8962.           /** @type {number} */
  8963.           item.$ = expectedNumberOfNonCommentArgs;
  8964.           /** @type {null} */
  8965.           item.ga = null;
  8966.           isElement(item);
  8967.           if (!(3 != expectedNumberOfNonCommentArgs)) {
  8968.             if (!(opt_attributes instanceof self.Gg)) {
  8969.               prepare(item, opt_attributes);
  8970.             }
  8971.           }
  8972.         }
  8973.       }
  8974.     };
  8975.     /**
  8976.      * @param {?} attributes
  8977.      * @param {string} index
  8978.      * @param {Function} next
  8979.      * @param {Object} a
  8980.      * @return {?}
  8981.      */
  8982.     var objEquiv = function(attributes, index, next, a) {
  8983.       if (attributes instanceof self.Bg) {
  8984.         return _keys(attributes, sort(index || self.R, next || null, a)), true;
  8985.       }
  8986.       if (self.cea(attributes)) {
  8987.         return attributes.then(index, next, a), true;
  8988.       }
  8989.       if (self.qa(attributes)) {
  8990.         try {
  8991.           var m = attributes.then;
  8992.           if (self.pa(m)) {
  8993.             return upload(attributes, m, index, next, a), true;
  8994.           }
  8995.         } catch (button) {
  8996.           return next.call(a, button), true;
  8997.         }
  8998.       }
  8999.       return false;
  9000.     };
  9001.     /**
  9002.      * @param {?} a
  9003.      * @param {Function} b
  9004.      * @param {Function} i
  9005.      * @param {Function} url
  9006.      * @param {Object} uri
  9007.      * @return {undefined}
  9008.      */
  9009.     var upload = function(a, b, i, url, uri) {
  9010.       /** @type {boolean} */
  9011.       var f = false;
  9012.       /**
  9013.        * @param {?} args
  9014.        * @return {undefined}
  9015.        */
  9016.       var start = function(args) {
  9017.         if (!f) {
  9018.           /** @type {boolean} */
  9019.           f = true;
  9020.           i.call(uri, args);
  9021.         }
  9022.       };
  9023.       /**
  9024.        * @param {?} callback
  9025.        * @return {undefined}
  9026.        */
  9027.       var end = function(callback) {
  9028.         if (!f) {
  9029.           /** @type {boolean} */
  9030.           f = true;
  9031.           url.call(uri, callback);
  9032.         }
  9033.       };
  9034.       try {
  9035.         b.call(a, start, end);
  9036.       } catch (restoreScript) {
  9037.         end(restoreScript);
  9038.       }
  9039.     };
  9040.     /**
  9041.      * @param {?} child
  9042.      * @return {undefined}
  9043.      */
  9044.     var isElement = function(child) {
  9045.       if (!child.ka) {
  9046.         /** @type {boolean} */
  9047.         child.ka = true;
  9048.         self.$da(child.qa, child);
  9049.       }
  9050.     };
  9051.     /**
  9052.      * @param {?} el
  9053.      * @return {?}
  9054.      */
  9055.     var matcher = function(el) {
  9056.       /** @type {null} */
  9057.       var attr = null;
  9058.       if (el.ia) {
  9059.         attr = el.ia;
  9060.         el.ia = attr.next;
  9061.         /** @type {null} */
  9062.         attr.next = null;
  9063.       }
  9064.       if (!el.ia) {
  9065.         /** @type {null} */
  9066.         el.ha = null;
  9067.       }
  9068.       return attr;
  9069.     };
  9070.     /**
  9071.      * @return {undefined}
  9072.      */
  9073.     self.Bg.prototype.qa = function() {
  9074.       /** @type {null} */
  9075.       var memory = null;
  9076.       for (;memory = matcher(this);) {
  9077.         print(this, memory, this.$, this.na);
  9078.       }
  9079.       /** @type {boolean} */
  9080.       this.ka = false;
  9081.     };
  9082.     /**
  9083.      * @param {Object} s
  9084.      * @param {Object} options
  9085.      * @param {number} defs
  9086.      * @param {Object} ast
  9087.      * @return {undefined}
  9088.      */
  9089.     print = function(s, options, defs, ast) {
  9090.       if (3 == defs && (options.ia && !options.ga)) {
  9091.         for (;s && s.ma;s = s.ga) {
  9092.           /** @type {boolean} */
  9093.           s.ma = false;
  9094.         }
  9095.       }
  9096.       if (options.$) {
  9097.         /** @type {null} */
  9098.         options.$.ga = null;
  9099.         defaults(options, defs, ast);
  9100.       } else {
  9101.         try {
  9102.           if (options.ga) {
  9103.             options.ha.call(options.context);
  9104.           } else {
  9105.             defaults(options, defs, ast);
  9106.           }
  9107.         } catch (prevTag) {
  9108.           constructor.call(null, prevTag);
  9109.         }
  9110.       }
  9111.       append(seg, options);
  9112.     };
  9113.     /**
  9114.      * @param {Object} options
  9115.      * @param {number} defs
  9116.      * @param {Object} args
  9117.      * @return {undefined}
  9118.      */
  9119.     defaults = function(options, defs, args) {
  9120.       if (2 == defs) {
  9121.         options.ha.call(options.context, args);
  9122.       } else {
  9123.         if (options.ia) {
  9124.           options.ia.call(options.context, args);
  9125.         }
  9126.       }
  9127.     };
  9128.     /**
  9129.      * @param {string} stop
  9130.      * @param {Object} node
  9131.      * @return {undefined}
  9132.      */
  9133.     prepare = function(stop, node) {
  9134.       /** @type {boolean} */
  9135.       stop.ma = true;
  9136.       self.$da(function() {
  9137.         if (stop.ma) {
  9138.           constructor.call(null, node);
  9139.         }
  9140.       });
  9141.     };
  9142.     /** @type {function (?): undefined} */
  9143.     constructor = extend;
  9144.     /**
  9145.      * @param {?} mapper
  9146.      * @return {undefined}
  9147.      */
  9148.     self.Gg = function(mapper) {
  9149.       self.va.call(this, mapper);
  9150.     };
  9151.     self.r(self.Gg, self.va);
  9152.     /** @type {string} */
  9153.     self.Gg.prototype.name = "cancel";
  9154.     /**
  9155.      * @param {string} descriptor
  9156.      * @param {?} resolve
  9157.      * @param {Function} reject
  9158.      * @return {undefined}
  9159.      */
  9160.     var Promise = function(descriptor, resolve, reject) {
  9161.       /** @type {string} */
  9162.       this.Mc = descriptor;
  9163.       this.resolve = resolve;
  9164.       /** @type {Function} */
  9165.       this.reject = reject;
  9166.     };
  9167.     self.bf("anim", {
  9168.       /**
  9169.        * @return {undefined}
  9170.        */
  9171.       dispose : function() {
  9172.         /** @type {Array} */
  9173.         out = [];
  9174.         abort();
  9175.       }
  9176.     });
  9177.     /**
  9178.      * @param {?} attributes
  9179.      * @return {undefined}
  9180.      */
  9181.     constructor = function(attributes) {
  9182.       if (attributes instanceof Error) {
  9183.         self.Ee(attributes, {
  9184.           ur : "1"
  9185.         });
  9186.       } else {
  9187.         /** @type {Error} */
  9188.         var opt_attributes = Error("mc");
  9189.         var optgroup = {
  9190.           ur : "1"
  9191.         };
  9192.         if (attributes) {
  9193.           optgroup.r = attributes;
  9194.         }
  9195.         self.Ee(opt_attributes, optgroup);
  9196.       }
  9197.     };
  9198.     self.ua("google.dom.append", self.te);
  9199.     self.ua("google.listen", self.Ce);
  9200.     self.ua("google.unlisten", self.De);
  9201.     self.ua("google.msg.listen", self.vf);
  9202.     self.ua("google.msg.unlisten", self.wf);
  9203.     self.ua("google.msg.send", self.H);
  9204.     self.ua("google.nav.go", self.Rf);
  9205.     self.ua("google.nav.search", self.Tf);
  9206.     self.ua("google.nav.gjh", self.hda);
  9207.     self.ua("google.style.getComputedStyle", self.$f);
  9208.     self.ua("google.style.hasClass", self.J);
  9209.     self.ua("google.style.isRtl", self.Zf);
  9210.     self.ua("google.style.addClass", self.K);
  9211.     self.ua("google.style.removeClass", self.L);
  9212.     self.ua("google.util.logVisibilityChange", self.fg);
  9213.     self.ua("google.nav.getLocation", function() {
  9214.       return window.location.href;
  9215.     });
  9216.     self.La = self.aa("google.ua") || (window.navigator.userAgent || runInContext());
  9217.     var read;
  9218.     var ondata;
  9219.     /**
  9220.      * @param {string} node
  9221.      * @param {Object} optgroup
  9222.      * @return {?}
  9223.      */
  9224.     self.Yf = function(node, optgroup) {
  9225.       var name = self.za("/%s=(.*?)(?:$|/|\\?)", optgroup);
  9226.       return(name = ondata(name).exec(node)) ? name[1] : null;
  9227.     };
  9228.     /**
  9229.      * @param {string} name
  9230.      * @param {string} ver
  9231.      * @return {?}
  9232.      */
  9233.     read = function(name, ver) {
  9234.       var r = name.indexOf("?");
  9235.       if (0 > r) {
  9236.         /** @type {null} */
  9237.         r = null;
  9238.       } else {
  9239.         a: {
  9240.           r = name.substring(r + 1);
  9241.           r = r.length ? r.split("&") : [];
  9242.           /** @type {number} */
  9243.           var j = 0;
  9244.           for (;j < r.length;j++) {
  9245.             var target = r[j];
  9246.             /** @type {(Array.<string>|null)} */
  9247.             var obj = /^(.+?)(?:=|$)/.exec(target);
  9248.             if ((obj ? self.Fa(obj[1]) : null) == ver) {
  9249.               r = (r = /=(.*)$/.exec(target)) ? self.Fa(r[1]) : null;
  9250.               break a;
  9251.             }
  9252.           }
  9253.           /** @type {null} */
  9254.           r = null;
  9255.         }
  9256.       }
  9257.       return r;
  9258.     };
  9259.     ondata = self.Gd(function(punctuation) {
  9260.       return new RegExp(punctuation);
  9261.     });
  9262.     /**
  9263.      * @return {?}
  9264.      */
  9265.     self.gf = function() {
  9266.       return!self.ff() && (self.Ab("iPod") || (self.Ab("iPhone") || (self.Ab("Android") || self.Ab("IEMobile"))));
  9267.     };
  9268.     /**
  9269.      * @return {?}
  9270.      */
  9271.     self.ff = function() {
  9272.       return self.Ab("iPad") || (self.Ab("Android") && !self.Ab("Mobile") || self.Ab("Silk"));
  9273.     };
  9274.     /**
  9275.      * @return {?}
  9276.      */
  9277.     self.hf = function() {
  9278.       return!self.gf() && !self.ff();
  9279.     };
  9280.     /**
  9281.      * @return {undefined}
  9282.      */
  9283.     var copy = function() {
  9284.       self.wb.call(this);
  9285.     };
  9286.     self.r(copy, self.wb);
  9287.     /**
  9288.      * @return {undefined}
  9289.      */
  9290.     copy.prototype.initialize = function() {
  9291.     };
  9292.     /**
  9293.      * @param {?} args
  9294.      * @param {?} update
  9295.      * @return {undefined}
  9296.      */
  9297.     var Subscription = function(args, update) {
  9298.       this.$ = args;
  9299.       this.ia = update;
  9300.     };
  9301.     /**
  9302.      * @param {?} opt_attributes
  9303.      * @return {undefined}
  9304.      */
  9305.     Subscription.prototype.execute = function(opt_attributes) {
  9306.       if (this.$) {
  9307.         this.$.call(this.ia || null, opt_attributes);
  9308.         /** @type {null} */
  9309.         this.$ = this.ia = null;
  9310.       }
  9311.     };
  9312.     /**
  9313.      * @return {undefined}
  9314.      */
  9315.     Subscription.prototype.abort = function() {
  9316.       /** @type {null} */
  9317.       this.ia = this.$ = null;
  9318.     };
  9319.     /**
  9320.      * @param {?} top
  9321.      * @param {?} width
  9322.      * @return {undefined}
  9323.      */
  9324.     var Canvas = function(top, width) {
  9325.       self.wb.call(this);
  9326.       this.ga = top;
  9327.       this.ma = width;
  9328.       /** @type {Array} */
  9329.       this.$ = [];
  9330.       /** @type {Array} */
  9331.       this.ia = [];
  9332.       /** @type {Array} */
  9333.       this.ha = [];
  9334.     };
  9335.     self.r(Canvas, self.wb);
  9336.     /** @type {function (): undefined} */
  9337.     Canvas.prototype.ka = copy;
  9338.     /** @type {null} */
  9339.     Canvas.prototype.ql = null;
  9340.     /**
  9341.      * @return {?}
  9342.      */
  9343.     Canvas.prototype.getId = function() {
  9344.       return this.ma;
  9345.     };
  9346.     /**
  9347.      * @param {Object} a
  9348.      * @param {string} start
  9349.      * @return {undefined}
  9350.      */
  9351.     var slice = function(a, start) {
  9352.       a.ia.push(new Subscription(start, void 0));
  9353.     };
  9354.     /**
  9355.      * @param {Object} options
  9356.      * @param {?} callback
  9357.      * @return {?}
  9358.      */
  9359.     var decrypt = function(options, callback) {
  9360.       var result = new options.ka;
  9361.       result.initialize(callback());
  9362.       options.ql = result;
  9363.       /** @type {boolean} */
  9364.       result = (result = !!createTable(options.ha, callback())) || !!createTable(options.$, callback());
  9365.       if (!result) {
  9366.         /** @type {number} */
  9367.         options.ia.length = 0;
  9368.       }
  9369.       return result;
  9370.     };
  9371.     /**
  9372.      * @param {string} options
  9373.      * @return {undefined}
  9374.      */
  9375.     Canvas.prototype.onError = function(options) {
  9376.       if (options = createTable(this.ia, options)) {
  9377.         window.setTimeout(debug("Module errback failures: " + options), 0);
  9378.       }
  9379.       /** @type {number} */
  9380.       this.ha.length = 0;
  9381.       /** @type {number} */
  9382.       this.$.length = 0;
  9383.     };
  9384.     /**
  9385.      * @param {Array} codeSegments
  9386.      * @param {?} attributes
  9387.      * @return {?}
  9388.      */
  9389.     var createTable = function(codeSegments, attributes) {
  9390.       /** @type {Array} */
  9391.       var re = [];
  9392.       /** @type {number} */
  9393.       var i = 0;
  9394.       for (;i < codeSegments.length;i++) {
  9395.         try {
  9396.           codeSegments[i].execute(attributes);
  9397.         } catch (attribs) {
  9398.           extend(attribs);
  9399.           re.push(attribs);
  9400.         }
  9401.       }
  9402.       /** @type {number} */
  9403.       codeSegments.length = 0;
  9404.       return re.length ? re : null;
  9405.     };
  9406.     /**
  9407.      * @return {undefined}
  9408.      */
  9409.     Canvas.prototype.Ha = function() {
  9410.       Canvas.Ba.Ha.call(this);
  9411.       self.yb(this.ql);
  9412.     };
  9413.     /**
  9414.      * @param {?} opt_attributes
  9415.      * @param {Object} name
  9416.      * @return {undefined}
  9417.      */
  9418.     self.Hg = function(opt_attributes, name) {
  9419.       /** @type {Array} */
  9420.       this.Vp = [];
  9421.       this.Ia = opt_attributes;
  9422.       this.Ea = name || null;
  9423.       /** @type {boolean} */
  9424.       this.ma = this.ia = false;
  9425.       this.ha = void 0;
  9426.       /** @type {boolean} */
  9427.       this.xa = this.Ja = this.qa = false;
  9428.       /** @type {number} */
  9429.       this.na = 0;
  9430.       /** @type {null} */
  9431.       this.ga = null;
  9432.       /** @type {number} */
  9433.       this.ka = 0;
  9434.     };
  9435.     /**
  9436.      * @param {?} evt
  9437.      * @return {undefined}
  9438.      */
  9439.     self.Hg.prototype.cancel = function(evt) {
  9440.       if (this.ia) {
  9441.         if (this.ha instanceof self.Hg) {
  9442.           this.ha.cancel();
  9443.         }
  9444.       } else {
  9445.         if (this.ga) {
  9446.           var item = this.ga;
  9447.           delete this.ga;
  9448.           if (evt) {
  9449.             item.cancel(evt);
  9450.           } else {
  9451.             item.ka--;
  9452.             if (0 >= item.ka) {
  9453.               item.cancel();
  9454.             }
  9455.           }
  9456.         }
  9457.         if (this.Ia) {
  9458.           this.Ia.call(this.Ea, this);
  9459.         } else {
  9460.           /** @type {boolean} */
  9461.           this.xa = true;
  9462.         }
  9463.         if (!this.ia) {
  9464.           this.$(new type);
  9465.         }
  9466.       }
  9467.     };
  9468.     /**
  9469.      * @param {?} opt_attributes
  9470.      * @param {Object} name
  9471.      * @return {undefined}
  9472.      */
  9473.     self.Hg.prototype.za = function(opt_attributes, name) {
  9474.       /** @type {boolean} */
  9475.       this.qa = false;
  9476.       _assert(this, opt_attributes, name);
  9477.     };
  9478.     /**
  9479.      * @param {Object} condition
  9480.      * @param {boolean} recurring
  9481.      * @param {?} keepData
  9482.      * @return {undefined}
  9483.      */
  9484.     var _assert = function(condition, recurring, keepData) {
  9485.       /** @type {boolean} */
  9486.       condition.ia = true;
  9487.       condition.ha = keepData;
  9488.       /** @type {boolean} */
  9489.       condition.ma = !recurring;
  9490.       tick(condition);
  9491.     };
  9492.     /**
  9493.      * @param {?} dataAndEvents
  9494.      * @return {undefined}
  9495.      */
  9496.     var isA = function(dataAndEvents) {
  9497.       if (dataAndEvents.ia) {
  9498.         if (!dataAndEvents.xa) {
  9499.           throw new plugin;
  9500.         }
  9501.         /** @type {boolean} */
  9502.         dataAndEvents.xa = false;
  9503.       }
  9504.     };
  9505.     /**
  9506.      * @param {?} name
  9507.      * @return {undefined}
  9508.      */
  9509.     self.Hg.prototype.be = function(name) {
  9510.       isA(this);
  9511.       _assert(this, true, name);
  9512.     };
  9513.     /**
  9514.      * @param {?} opt_attributes
  9515.      * @return {undefined}
  9516.      */
  9517.     self.Hg.prototype.$ = function(opt_attributes) {
  9518.       isA(this);
  9519.       _assert(this, false, opt_attributes);
  9520.     };
  9521.     /**
  9522.      * @param {?} which
  9523.      * @param {?} index
  9524.      * @return {undefined}
  9525.      */
  9526.     self.Lg = function(which, index) {
  9527.       self.Kg(which, index, null, void 0);
  9528.     };
  9529.     /**
  9530.      * @param {?} callback
  9531.      * @param {?} property
  9532.      * @param {Object} resp
  9533.      * @param {?} handler
  9534.      * @return {undefined}
  9535.      */
  9536.     self.Kg = function(callback, property, resp, handler) {
  9537.       callback.Vp.push([property, resp, handler]);
  9538.       if (callback.ia) {
  9539.         tick(callback);
  9540.       }
  9541.     };
  9542.     /**
  9543.      * @param {string} property
  9544.      * @param {Object} fn
  9545.      * @param {Object} next
  9546.      * @return {?}
  9547.      */
  9548.     self.Hg.prototype.then = function(property, fn, next) {
  9549.       var text;
  9550.       var _progressed;
  9551.       var me = new self.Bg(function(textAlt, dataAndEvents) {
  9552.         text = textAlt;
  9553.         _progressed = dataAndEvents;
  9554.       });
  9555.       self.Kg(this, text, function(value) {
  9556.         if (value instanceof type) {
  9557.           me.cancel();
  9558.         } else {
  9559.           _progressed(value);
  9560.         }
  9561.       });
  9562.       return me.then(property, fn, next);
  9563.     };
  9564.     execute(self.Hg);
  9565.     /**
  9566.      * @param {?} opt_attributes
  9567.      * @return {?}
  9568.      */
  9569.     self.Hg.prototype.Za = function(opt_attributes) {
  9570.       var result = new self.Hg;
  9571.       self.Kg(this, result.be, result.$, result);
  9572.       if (opt_attributes) {
  9573.         result.ga = this;
  9574.         this.ka++;
  9575.       }
  9576.       return result;
  9577.     };
  9578.     /**
  9579.      * @param {?} e
  9580.      * @return {?}
  9581.      */
  9582.     self.Hg.prototype.isError = function(e) {
  9583.       return e instanceof Error;
  9584.     };
  9585.     /**
  9586.      * @param {Object} req
  9587.      * @return {?}
  9588.      */
  9589.     var list = function(req) {
  9590.       return(0, self.bb)(req.Vp, function(r) {
  9591.         return self.pa(r[1]);
  9592.       });
  9593.     };
  9594.     /**
  9595.      * @param {Object} options
  9596.      * @return {undefined}
  9597.      */
  9598.     var tick = function(options) {
  9599.       if (options.na && (options.ia && list(options))) {
  9600.         var start = options.na;
  9601.         var that = range[start];
  9602.         if (that) {
  9603.           self.ca.clearTimeout(that.vx);
  9604.           delete range[start];
  9605.         }
  9606.         /** @type {number} */
  9607.         options.na = 0;
  9608.       }
  9609.       if (options.ga) {
  9610.         options.ga.ka--;
  9611.         delete options.ga;
  9612.       }
  9613.       start = options.ha;
  9614.       /** @type {boolean} */
  9615.       var model = that = false;
  9616.       for (;options.Vp.length && !options.qa;) {
  9617.         var array = options.Vp.shift();
  9618.         var src = array[0];
  9619.         var value = array[1];
  9620.         array = array[2];
  9621.         if (src = options.ma ? value : src) {
  9622.           try {
  9623.             var index = src.call(array || options.Ea, start);
  9624.             if (self.Uf(index)) {
  9625.               options.ma = options.ma && (index == start || options.isError(index));
  9626.               options.ha = start = index;
  9627.             }
  9628.             if (self.cea(start) || "function" === typeof self.ca.Promise && start instanceof self.ca.Promise) {
  9629.               /** @type {boolean} */
  9630.               model = true;
  9631.               /** @type {boolean} */
  9632.               options.qa = true;
  9633.             }
  9634.           } catch (startOrEnd) {
  9635.             start = startOrEnd;
  9636.             /** @type {boolean} */
  9637.             options.ma = true;
  9638.             if (!list(options)) {
  9639.               /** @type {boolean} */
  9640.               that = true;
  9641.             }
  9642.           }
  9643.         }
  9644.       }
  9645.       options.ha = start;
  9646.       if (model) {
  9647.         index = (0, self.p)(options.za, options, true);
  9648.         model = (0, self.p)(options.za, options, false);
  9649.         if (start instanceof self.Hg) {
  9650.           self.Kg(start, index, model);
  9651.           /** @type {boolean} */
  9652.           start.Ja = true;
  9653.         } else {
  9654.           start.then(index, model);
  9655.         }
  9656.       }
  9657.       if (that) {
  9658.         start = new block(start);
  9659.         range[start.vx] = start;
  9660.         options.na = start.vx;
  9661.       }
  9662.     };
  9663.     /**
  9664.      * @return {undefined}
  9665.      */
  9666.     var plugin = function() {
  9667.       self.va.call(this);
  9668.     };
  9669.     self.r(plugin, self.va);
  9670.     /** @type {string} */
  9671.     plugin.prototype.message = "Deferred has already fired";
  9672.     /** @type {string} */
  9673.     plugin.prototype.name = "AlreadyCalledError";
  9674.     /**
  9675.      * @return {undefined}
  9676.      */
  9677.     var type = function() {
  9678.       self.va.call(this);
  9679.     };
  9680.     self.r(type, self.va);
  9681.     /** @type {string} */
  9682.     type.prototype.message = "Deferred was canceled";
  9683.     /** @type {string} */
  9684.     type.prototype.name = "CanceledError";
  9685.     /**
  9686.      * @param {(RegExp|string)} type
  9687.      * @return {undefined}
  9688.      */
  9689.     var block = function(type) {
  9690.       this.vx = self.ca.setTimeout((0, self.p)(this.$, this), 0);
  9691.       /** @type {(RegExp|string)} */
  9692.       this.Qs = type;
  9693.     };
  9694.     /**
  9695.      * @return {undefined}
  9696.      */
  9697.     block.prototype.$ = function() {
  9698.       delete range[this.vx];
  9699.       throw this.Qs;
  9700.     };
  9701.     var range = {};
  9702.     var emit;
  9703.     var resolve;
  9704.     var condition;
  9705.     var getAll;
  9706.     /**
  9707.      * @return {undefined}
  9708.      */
  9709.     self.Sg = function() {
  9710.       self.wb.call(this);
  9711.       this.ia = {};
  9712.       /** @type {Array} */
  9713.       this.ma = [];
  9714.       /** @type {Array} */
  9715.       this.ha = [];
  9716.       /** @type {Array} */
  9717.       this.qa = [];
  9718.       /** @type {Array} */
  9719.       this.ga = [];
  9720.       /** @type {Array} */
  9721.       this.na = [];
  9722.       this.Ea = {};
  9723.       this.ka = this.ra = new Canvas([], "");
  9724.       /** @type {null} */
  9725.       this.Ca = null;
  9726.       this.xa = new self.Hg;
  9727.       /** @type {boolean} */
  9728.       this.za = false;
  9729.       /** @type {null} */
  9730.       this.Ga = null;
  9731.       /** @type {number} */
  9732.       this.ya = 0;
  9733.       /** @type {boolean} */
  9734.       this.Ma = this.Ja = false;
  9735.     };
  9736.     self.r(self.Sg, self.wb);
  9737.     self.ea(self.Sg);
  9738.     /**
  9739.      * @param {?} attributes
  9740.      * @param {?} results
  9741.      * @return {undefined}
  9742.      */
  9743.     self.Sg.prototype.wb = function(attributes, results) {
  9744.       if (self.ma(attributes)) {
  9745.         var parts = attributes.split("/");
  9746.         /** @type {Array} */
  9747.         var buf = [];
  9748.         /** @type {number} */
  9749.         var ii = 0;
  9750.         for (;ii < parts.length;ii++) {
  9751.           var codeSegments = parts[ii].split(":");
  9752.           var prefix = codeSegments[0];
  9753.           if (codeSegments[1]) {
  9754.             codeSegments = codeSegments[1].split(",");
  9755.             /** @type {number} */
  9756.             var i = 0;
  9757.             for (;i < codeSegments.length;i++) {
  9758.               codeSegments[i] = buf[(0, window.parseInt)(codeSegments[i], 36)];
  9759.             }
  9760.           } else {
  9761.             /** @type {Array} */
  9762.             codeSegments = [];
  9763.           }
  9764.           buf.push(prefix);
  9765.           this.ia[prefix] = new Canvas(codeSegments, prefix);
  9766.         }
  9767.         if (results && results.length) {
  9768.           self.ob(this.ma, results);
  9769.           this.Ca = self.Ua(results);
  9770.         } else {
  9771.           if (!this.xa.ia) {
  9772.             this.xa.be();
  9773.           }
  9774.         }
  9775.         if (this.ka == this.ra) {
  9776.           /** @type {null} */
  9777.           this.ka = null;
  9778.           if (decrypt(this.ra, (0, self.p)(this.Ia, this))) {
  9779.             errorHandler(this, 4);
  9780.           }
  9781.           isFunction(this);
  9782.         }
  9783.       }
  9784.     };
  9785.     /**
  9786.      * @return {?}
  9787.      */
  9788.     self.Sg.prototype.Ia = function() {
  9789.       return null;
  9790.     };
  9791.     /**
  9792.      * @return {?}
  9793.      */
  9794.     self.Sg.prototype.dd = function() {
  9795.       return 0 < this.ma.length;
  9796.     };
  9797.     /**
  9798.      * @param {?} item
  9799.      * @return {undefined}
  9800.      */
  9801.     var isFunction = function(item) {
  9802.       var element = item.Ja;
  9803.       var b = item.dd();
  9804.       if (b != element) {
  9805.         comparator(item, b ? "active" : "idle");
  9806.         item.Ja = b;
  9807.       }
  9808.       /** @type {boolean} */
  9809.       element = 0 < item.na.length;
  9810.       if (element != item.Ma) {
  9811.         comparator(item, element ? "userActive" : "userIdle");
  9812.         /** @type {boolean} */
  9813.         item.Ma = element;
  9814.       }
  9815.     };
  9816.     /**
  9817.      * @param {?} node
  9818.      * @param {Array} str
  9819.      * @param {Function} msg
  9820.      * @return {?}
  9821.      */
  9822.     var warn = function(node, str, msg) {
  9823.       /** @type {Array} */
  9824.       var b = [];
  9825.       self.sb(str, b);
  9826.       /** @type {Array} */
  9827.       str = [];
  9828.       var dst = {};
  9829.       /** @type {number} */
  9830.       var j = 0;
  9831.       for (;j < b.length;j++) {
  9832.         var p = b[j];
  9833.         var property = node.ia[p];
  9834.         if (!property) {
  9835.           throw Error("q`" + p);
  9836.         }
  9837.         var result = new self.Hg;
  9838.         dst[p] = result;
  9839.         if (property.ql) {
  9840.           result.be(null);
  9841.         } else {
  9842.           getValue(node, p, property, !!msg, result);
  9843.           if (!condition(node, p)) {
  9844.             str.push(p);
  9845.           }
  9846.         }
  9847.       }
  9848.       if (0 < str.length) {
  9849.         text(node, str);
  9850.       }
  9851.       return dst;
  9852.     };
  9853.     /**
  9854.      * @param {?} node
  9855.      * @param {?} list
  9856.      * @param {Object} value
  9857.      * @param {boolean} defaultValue
  9858.      * @param {Object} result
  9859.      * @return {undefined}
  9860.      */
  9861.     var getValue = function(node, list, value, defaultValue, result) {
  9862.       value.$.push(new Subscription(result.be, result));
  9863.       slice(value, function(msg) {
  9864.         result.$(Error(msg));
  9865.       });
  9866.       if (condition(node, list)) {
  9867.         if (defaultValue) {
  9868.           getAll(node, list);
  9869.           isFunction(node);
  9870.         }
  9871.       } else {
  9872.         if (defaultValue) {
  9873.           getAll(node, list);
  9874.         }
  9875.       }
  9876.     };
  9877.     /**
  9878.      * @param {?} item
  9879.      * @param {?} attributes
  9880.      * @return {undefined}
  9881.      */
  9882.     var text = function(item, attributes) {
  9883.       if (self.gb(item.ma)) {
  9884.         item.Da(attributes);
  9885.       } else {
  9886.         item.ga.push(attributes);
  9887.         isFunction(item);
  9888.       }
  9889.     };
  9890.     /**
  9891.      * @param {?} opt_attributes
  9892.      * @param {Object} name
  9893.      * @param {?} attributes
  9894.      * @return {undefined}
  9895.      */
  9896.     self.Sg.prototype.Da = function(opt_attributes, name, attributes) {
  9897.       if (!name) {
  9898.         /** @type {number} */
  9899.         this.ya = 0;
  9900.       }
  9901.       this.ma = name = emit(this, opt_attributes);
  9902.       if (this.za) {
  9903.         this.ha = opt_attributes;
  9904.       } else {
  9905.         this.ha = self.nb(name);
  9906.       }
  9907.       isFunction(this);
  9908.       if (!self.gb(name)) {
  9909.         this.qa.push.apply(this.qa, name);
  9910.         opt_attributes = (0, self.p)(this.Ga.ya, this.Ga, self.nb(name), this.ia, null, (0, self.p)(this.Na, this, this.ha, name), (0, self.p)(this.Db, this), !!attributes);
  9911.         if (attributes = 5E3 * Math.pow(this.ya, 2)) {
  9912.           window.setTimeout(opt_attributes, attributes);
  9913.         } else {
  9914.           opt_attributes();
  9915.         }
  9916.       }
  9917.     };
  9918.     /**
  9919.      * @param {?} args
  9920.      * @param {Array} codeSegments
  9921.      * @return {?}
  9922.      */
  9923.     emit = function(args, codeSegments) {
  9924.       /** @type {number} */
  9925.       var i = 0;
  9926.       for (;i < codeSegments.length;i++) {
  9927.         if (args.ia[codeSegments[i]].ql) {
  9928.           throw Error("r`" + codeSegments[i]);
  9929.         }
  9930.       }
  9931.       /** @type {Array} */
  9932.       var children = [];
  9933.       /** @type {number} */
  9934.       i = 0;
  9935.       for (;i < codeSegments.length;i++) {
  9936.         /** @type {Array} */
  9937.         children = children.concat(resolve(args, codeSegments[i]));
  9938.       }
  9939.       self.sb(children);
  9940.       return!args.za && 1 < children.length ? (i = children.shift(), args.ga = (0, self.$a)(children, function(dataAndEvents) {
  9941.         return[dataAndEvents];
  9942.       }).concat(args.ga), [i]) : children;
  9943.     };
  9944.     /**
  9945.      * @param {?} a
  9946.      * @param {?} key
  9947.      * @return {?}
  9948.      */
  9949.     resolve = function(a, key) {
  9950.       /** @type {Array} */
  9951.       var copy = [];
  9952.       if (!self.fb(a.qa, key)) {
  9953.         copy.push(key);
  9954.       }
  9955.       var recurring = self.nb(a.ia[key].ga);
  9956.       for (;recurring.length;) {
  9957.         var prefix = recurring.pop();
  9958.         if (!a.ia[prefix].ql) {
  9959.           if (!self.fb(a.qa, prefix)) {
  9960.             copy.unshift(prefix);
  9961.             Array.prototype.unshift.apply(recurring, a.ia[prefix].ga);
  9962.           }
  9963.         }
  9964.       }
  9965.       self.sb(copy);
  9966.       return copy;
  9967.     };
  9968.     /**
  9969.      * @param {string} a
  9970.      * @return {undefined}
  9971.      */
  9972.     self.P = function(a) {
  9973.       var c = self.Sg.Sa();
  9974.       if (!c.isDisposed()) {
  9975.         if (decrypt(c.ia[a], (0, self.p)(c.Ia, c))) {
  9976.           errorHandler(c, 4);
  9977.         }
  9978.         self.kb(c.na, a);
  9979.         self.kb(c.ma, a);
  9980.         if (self.gb(c.ma)) {
  9981.           mixin(c);
  9982.         }
  9983.         if (c.Ca) {
  9984.           if (a == c.Ca) {
  9985.             if (!c.xa.ia) {
  9986.               c.xa.be();
  9987.             }
  9988.           }
  9989.         }
  9990.         isFunction(c);
  9991.       }
  9992.     };
  9993.     /**
  9994.      * @param {?} index
  9995.      * @param {?} node
  9996.      * @return {?}
  9997.      */
  9998.     condition = function(index, node) {
  9999.       if (self.fb(index.ma, node)) {
  10000.         return true;
  10001.       }
  10002.       /** @type {number} */
  10003.       var i = 0;
  10004.       for (;i < index.ga.length;i++) {
  10005.         if (self.fb(index.ga[i], node)) {
  10006.           return true;
  10007.         }
  10008.       }
  10009.       return false;
  10010.     };
  10011.     /**
  10012.      * @param {string} num
  10013.      * @param {Function} b
  10014.      * @return {?}
  10015.      */
  10016.     self.Sg.prototype.load = function(num, b) {
  10017.       return warn(this, [num], b)[num];
  10018.     };
  10019.     /**
  10020.      * @param {?} key
  10021.      * @param {?} reference
  10022.      * @return {undefined}
  10023.      */
  10024.     getAll = function(key, reference) {
  10025.       if (!self.fb(key.na, reference)) {
  10026.         key.na.push(reference);
  10027.       }
  10028.     };
  10029.     /**
  10030.      * @param {strin
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!