API tools faq
paste
Guest User

roulette.js

a guest
May 6th, 2018
119
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 327.62 KB | None | 0 0
raw download clone embed print report
  1. ;var IframeRoulette = function(config) {
  2.     this.config = config;
  3.     this.winning_slice = true;
  4.     this.setUp();
  5.     this.setReady();
  6. };
  7. IframeRoulette.prototype.setUp = function() {
  8.     this.config.form.submit(this.buttonClick.bind(this));
  9.     this.config.played_button.click(function() {
  10.         this.closeWheel();
  11.         this.setPlayedCookie();
  12.         this.setFooterCookie();
  13.         this.postMessage({
  14.             'action': 'showFooter'
  15.         });
  16.         if (typeof this.winning_slice.button_action != 'undefined' && this.winning_slice.button_action == 'redirect') {
  17.             if (this.winning_slice.type == 'coupon') {
  18.                 var redirect = this.winning_slice.button_redirect.replace('[VALUE]', this.winning_slice.value);
  19.             } else {
  20.                 var redirect = this.winning_slice.button_redirect;
  21.             }
  22.             this.postMessage({
  23.                 'action': 'redirect',
  24.                 'url': redirect,
  25.             });
  26.             return;
  27.         }
  28.         if (this.winning_slice.type == 'product') {
  29.             this.postMessage({
  30.                 'action': 'redirect',
  31.                 'url': this.winning_slice.value,
  32.             });
  33.         }
  34.     }
  35.     .bind(this));
  36.     this.config.close.click(function() {
  37.         this.saveCloseStatistic();
  38.         this.closeWheel();
  39.         this.setCloseCookie();
  40.     }
  41.     .bind(this));
  42.     this.config.prize_container.hide();
  43.     $('#id_email').tooltipster({
  44.         'trigger': 'custom',
  45.         'theme': ['tooltipster-default', 'tooltipster-listagram']
  46.     });
  47. }
  48. ;
  49. IframeRoulette.prototype.setReady = function() {
  50.     this.postMessage({
  51.         'action': 'ready',
  52.         'wheel': this.config.wheel
  53.     });
  54. }
  55. ;
  56. IframeRoulette.prototype.saveCloseStatistic = function() {
  57.     if (this.winning_slice) {
  58.         var stat_type = 'rejection_after_spin';
  59.     } else {
  60.         var stat_type = 'rejection_before_spin';
  61.     }
  62.     var data = {
  63.         'token': this.config.token,
  64.         'wheel': this.config.wheel,
  65.         'csrfmiddlewaretoken': this.config.csrfmiddlewaretoken,
  66.         'stat_type': stat_type,
  67.     };
  68.     this.setLoading();
  69.     var xhr = $.post({
  70.         'data': data,
  71.         'dataType': 'json',
  72.         'url': this.config.stats_url,
  73.     });
  74. }
  75. ;
  76. IframeRoulette.prototype.setWinningSlice = function(slice) {
  77.     this.winning_slice = slice;
  78. }
  79. ;
  80. IframeRoulette.prototype.closeWheel = function() {
  81.     this.postMessage({
  82.         'action': 'close',
  83.     });
  84. }
  85. ;
  86. IframeRoulette.prototype.setCouponCookie = function() {
  87.     if (this.winning_slice.type == 'coupon') {
  88.         this.postMessage({
  89.             'action': 'setCookie',
  90.             'name': 'LISTAGRAM-COUPON',
  91.             'value': this.winning_slice.value,
  92.             'days': 7,
  93.         });
  94.     }
  95. }
  96. ;
  97. IframeRoulette.prototype.setFooterCookie = function() {
  98.     if (this.config.footer.enabled) {
  99.         var footer_timeout_minutes = this.config.footer.lifetime;
  100.         var footer_timeout_timestamp = parseInt(new Date().getTime() / 1000) + footer_timeout_minutes * 60;
  101.         var footer_position = 'bottom';
  102.         var cookie_name = 'LISTAGRAM-FOOTER';
  103.         if (this.config.footer.countdown) {
  104.             var footer_countdown = 'countdown';
  105.         } else {
  106.             var footer_countdown = 'regular';
  107.         }
  108.         var cookie_value = footer_timeout_timestamp.toString() + '|' + footer_position + '|' + footer_countdown + '|' + this.config.wheel;
  109.         this.postMessage({
  110.             'action': 'setCookieMinutes',
  111.             'name': cookie_name,
  112.             'value': cookie_value,
  113.             'minutes': footer_timeout_minutes,
  114.         });
  115.     }
  116. }
  117. ;
  118. IframeRoulette.prototype.setPlayedCookie = function() {
  119.     this.postMessage({
  120.         'action': 'setCookie',
  121.         'name': this.config.cookie_name,
  122.         'value': 'played',
  123.         'days': this.config.cookie_lifetime,
  124.     });
  125. }
  126. ;
  127. IframeRoulette.prototype.setCloseCookie = function() {
  128.     this.postMessage({
  129.         'action': 'setCookie',
  130.         'name': this.config.cookie_name,
  131.         'value': 'closed',
  132.         'days': this.config.cookie_lifetime,
  133.     });
  134. }
  135. ;
  136. IframeRoulette.prototype.postMessage = function(data) {
  137.     window.parent.postMessage(data, '*');
  138. }
  139. ;
  140. IframeRoulette.prototype.switchSides = function() {
  141.     this.config.form_container.fadeOut(300, function() {
  142.         this.config.prize_container.fadeIn();
  143.     }
  144.     .bind(this));
  145. }
  146. ;
  147. IframeRoulette.prototype.buttonClick = function(e) {
  148.     e.preventDefault();
  149.     this.config.email.blur();
  150.     if (this.config.email.val() == '') {
  151.         this.setError(this.config.translation.email_invalid);
  152.     } else {
  153.         if (!this.validateEmail(this.config.email.val())) {
  154.             this.setError(this.config.translation.email_invalid);
  155.         } else {
  156.             var data = {
  157.                 'token': this.config.token,
  158.                 'wheel': this.config.wheel,
  159.                 'email': this.config.email.val(),
  160.                 'csrfmiddlewaretoken': this.config.csrfmiddlewaretoken,
  161.                 'url': this.config.referer_url,
  162.             };
  163.             this.setLoading();
  164.             var xhr = $.post({
  165.                 'data': data,
  166.                 'dataType': 'json',
  167.                 'url': this.config.url,
  168.             });
  169.             xhr.done(function(response) {
  170.                 if (response.success) {
  171.                     this.stopLoading();
  172.                     this.config.fortunewheel.setWinningSlice(response.winning_slice.number);
  173.                     this.setWinningSlice(response.winning_slice);
  174.                     this.config.fortunewheel.spin(function() {
  175.                         this.setupPrizeContainer(response.winning_slice);
  176.                         this.switchSides();
  177.                         this.setPlayedCookie();
  178.                         this.setCouponCookie();
  179.                     }
  180.                     .bind(this));
  181.                 } else {
  182.                     this.setError(response.error);
  183.                 }
  184.             }
  185.             .bind(this));
  186.         }
  187.     }
  188. }
  189. ;
  190. IframeRoulette.prototype.setupPrizeContainer = function(winning_slice) {
  191.     var title = this.config.prize_container.find('.roulette-iframe-right-prize-title');
  192.     var desc = this.config.prize_container.find('.roulette-iframe-right-prize-description');
  193.     var btn_div = this.config.prize_container.find('.roulette-iframe-right-prize-button');
  194.     var btn = this.config.prize_container.find('.roulette-iframe-right-prize-button button');
  195.     var coupon_div = this.config.prize_container.find('.roulette-iframe-right-prize-coupon');
  196.     var coupon_input = this.config.prize_container.find('.roulette-iframe-right-prize-coupon input');
  197.     if (typeof winning_slice.custom_title != "undefined" && winning_slice.custom_title !== null) {
  198.         var title_text = winning_slice.custom_title.replace('%s', winning_slice.label)
  199.     } else {
  200.         if (winning_slice.type == 'noprize') {
  201.             var title_text = this.config.translation.noprize_title;
  202.         } else {
  203.             var title_text = this.config.translation.prize_title.replace('%s', winning_slice.label);
  204.         }
  205.     }
  206.     if (typeof winning_slice.custom_description !== "undefined" && winning_slice.custom_description !== null) {
  207.         var desc_text = winning_slice.custom_description;
  208.     } else {
  209.         if (winning_slice.type == 'coupon') {
  210.             var desc_text = this.config.translation.prize_description_coupon;
  211.         } else if (winning_slice.type == 'noprize') {
  212.             var desc_text = this.config.translation.noprize_description;
  213.         } else if (winning_slice.type == 'product') {
  214.             var desc_text = this.config.translation.prize_description_freeproduct;
  215.         }
  216.     }
  217.     if (typeof winning_slice.button_text != "undefined" && winning_slice.button_text !== null) {
  218.         var button_text = winning_slice.button_text;
  219.     } else {
  220.         if (winning_slice.type == 'coupon') {
  221.             var button_text = this.config.translation.button_coupon;
  222.         } else if (winning_slice.type == 'noprize') {
  223.             var button_text = this.config.translation.button_noprize;
  224.         } else if (winning_slice.type == 'product') {
  225.             var button_text = this.config.translation.button_freeproduct;
  226.         }
  227.     }
  228.     title.html(title_text);
  229.     desc.html(desc_text);
  230.     btn.html(button_text);
  231.     if (winning_slice.type == 'coupon') {
  232.         var show_coupon = true;
  233.         if (typeof winning_slice.show_coupon !== "undefined" && winning_slice.show_coupon !== null) {
  234.             if (!winning_slice.show_coupon) {
  235.                 show_coupon = false;
  236.             }
  237.         }
  238.         if (show_coupon) {
  239.             coupon_div.show();
  240.             coupon_input.val(winning_slice.value);
  241.         }
  242.     } else if (winning_slice.type == 'noprize') {} else if (winning_slice.type == 'product') {}
  243.     if (winning_slice.type != 'product' && this.config.iframe_embed) {
  244.         btn.hide();
  245.     }
  246. }
  247. ;
  248. IframeRoulette.prototype.validateEmail = function validateEmail(email) {
  249.     var emailReg = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
  250.     return emailReg.test(email);
  251. }
  252. ;
  253. IframeRoulette.prototype.setLoading = function() {}
  254. ;
  255. IframeRoulette.prototype.stopLoading = function() {}
  256. ;
  257. IframeRoulette.prototype.setError = function(error) {
  258.     $('#id_email').tooltipster('content', error);
  259.     $('#id_email').tooltipster('show');
  260.     setTimeout(function() {
  261.         $('#id_email').tooltipster('hide');
  262.     }, 2000);
  263. }
  264. ;
  265. IframeRoulette.prototype.resetMessage = function() {
  266.     this.config.message.removeClass('roulette-iframe-form-error');
  267.     this.config.message.html('');
  268. }
  269. ;
  270. FortuneWheel = function(config) {
  271.     this.config = config;
  272.     this.container = this.config.container;
  273.     this.setupSlices();
  274. }
  275. ;
  276. FortuneWheel.prototype = {
  277.     setupSlices: function() {
  278.         this.slices = this.container.find('.fortunewheel-slice');
  279.         if (this.config.is_rtl) {
  280.             var degrees = 180;
  281.             var slices = 1;
  282.             var slices = this.slices.length;
  283.             for (var x = 0; x < slices; x++) {
  284.                 var slice = $(this.slices[x]);
  285.                 slice.css('transform', 'rotate(' + degrees + 'deg) translate(0px, -50%)');
  286.                 degrees += 30;
  287.             }
  288.         } else {
  289.             var degrees = 0;
  290.             for (var x = 0; x < this.slices.length; x++) {
  291.                 var slice = $(this.slices[x]);
  292.                 slice.css('transform', 'rotate(' + degrees + 'deg) translate(0px, -50%)');
  293.                 degrees -= 30;
  294.             }
  295.         }
  296.     },
  297.     setWinningSlice: function(slice) {
  298.         this.winning_slice = slice;
  299.         if (this.config.is_rtl) {
  300.             this.container.css('-webkit-animation-name', 'spin-slice-rtl' + slice);
  301.             this.container.css('animation-name', 'spin-slice-rtl' + slice);
  302.         } else {
  303.             this.container.css('-webkit-animation-name', 'spin-slice' + slice);
  304.             this.container.css('animation-name', 'spin-slice' + slice);
  305.         }
  306.     },
  307.     spin: function(callback) {
  308.         this.reset();
  309.         this.container.addClass('fortunewheel-spinning');
  310.         var duration = this.getDuration();
  311.         setTimeout(callback, duration);
  312.     },
  313.     getDuration: function() {
  314.         var duration = this.config.container.css('animation-duration');
  315.         if (duration.split('s').length == 2) {
  316.             return duration.split('s')[0] * 1000;
  317.         } else {
  318.             return duration.split('ms')[0];
  319.         }
  320.         return duration;
  321.     },
  322.     reset: function() {
  323.         this.container.removeClass('fortunewheel-spinning');
  324.     },
  325. };
  326. ;/*!
  327.  * jQuery JavaScript Library v3.2.0
  328.  * https://jquery.com/
  329.  *
  330.  * Includes Sizzle.js
  331.  * https://sizzlejs.com/
  332.  *
  333.  * Copyright JS Foundation and other contributors
  334.  * Released under the MIT license
  335.  * https://jquery.org/license
  336.  *
  337.  * Date: 2017-03-16T21:26Z
  338.  */
  339. (function(global, factory) {
  340.     "use strict";
  341.     if (typeof module === "object" && typeof module.exports === "object") {
  342.         module.exports = global.document ? factory(global, true) : function(w) {
  343.             if (!w.document) {
  344.                 throw new Error("jQuery requires a window with a document");
  345.             }
  346.             return factory(w);
  347.         }
  348.         ;
  349.     } else {
  350.         factory(global);
  351.     }
  352. }
  353. )(typeof window !== "undefined" ? window : this, function(window, noGlobal) {
  354.     "use strict";
  355.     var arr = [];
  356.     var document = window.document;
  357.     var getProto = Object.getPrototypeOf;
  358.     var slice = arr.slice;
  359.     var concat = arr.concat;
  360.     var push = arr.push;
  361.     var indexOf = arr.indexOf;
  362.     var class2type = {};
  363.     var toString = class2type.toString;
  364.     var hasOwn = class2type.hasOwnProperty;
  365.     var fnToString = hasOwn.toString;
  366.     var ObjectFunctionString = fnToString.call(Object);
  367.     var support = {};
  368.     function DOMEval(code, doc) {
  369.         doc = doc || document;
  370.         var script = doc.createElement("script");
  371.         script.text = code;
  372.         doc.head.appendChild(script).parentNode.removeChild(script);
  373.     }
  374.     var version = "3.2.0"
  375.       , jQuery = function(selector, context) {
  376.         return new jQuery.fn.init(selector,context);
  377.     }
  378.       , rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g
  379.       , rmsPrefix = /^-ms-/
  380.       , rdashAlpha = /-([a-z])/g
  381.       , fcamelCase = function(all, letter) {
  382.         return letter.toUpperCase();
  383.     };
  384.     jQuery.fn = jQuery.prototype = {
  385.         jquery: version,
  386.         constructor: jQuery,
  387.         length: 0,
  388.         toArray: function() {
  389.             return slice.call(this);
  390.         },
  391.         get: function(num) {
  392.             if (num == null) {
  393.                 return slice.call(this);
  394.             }
  395.             return num < 0 ? this[num + this.length] : this[num];
  396.         },
  397.         pushStack: function(elems) {
  398.             var ret = jQuery.merge(this.constructor(), elems);
  399.             ret.prevObject = this;
  400.             return ret;
  401.         },
  402.         each: function(callback) {
  403.             return jQuery.each(this, callback);
  404.         },
  405.         map: function(callback) {
  406.             return this.pushStack(jQuery.map(this, function(elem, i) {
  407.                 return callback.call(elem, i, elem);
  408.             }));
  409.         },
  410.         slice: function() {
  411.             return this.pushStack(slice.apply(this, arguments));
  412.         },
  413.         first: function() {
  414.             return this.eq(0);
  415.         },
  416.         last: function() {
  417.             return this.eq(-1);
  418.         },
  419.         eq: function(i) {
  420.             var len = this.length
  421.               , j = +i + (i < 0 ? len : 0);
  422.             return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
  423.         },
  424.         end: function() {
  425.             return this.prevObject || this.constructor();
  426.         },
  427.         push: push,
  428.         sort: arr.sort,
  429.         splice: arr.splice
  430.     };
  431.     jQuery.extend = jQuery.fn.extend = function() {
  432.         var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false;
  433.         if (typeof target === "boolean") {
  434.             deep = target;
  435.             target = arguments[i] || {};
  436.             i++;
  437.         }
  438.         if (typeof target !== "object" && !jQuery.isFunction(target)) {
  439.             target = {};
  440.         }
  441.         if (i === length) {
  442.             target = this;
  443.             i--;
  444.         }
  445.         for (; i < length; i++) {
  446.             if ((options = arguments[i]) != null) {
  447.                 for (name in options) {
  448.                     src = target[name];
  449.                     copy = options[name];
  450.                     if (target === copy) {
  451.                         continue;
  452.                     }
  453.                     if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
  454.                         if (copyIsArray) {
  455.                             copyIsArray = false;
  456.                             clone = src && Array.isArray(src) ? src : [];
  457.                         } else {
  458.                             clone = src && jQuery.isPlainObject(src) ? src : {};
  459.                         }
  460.                         target[name] = jQuery.extend(deep, clone, copy);
  461.                     } else if (copy !== undefined) {
  462.                         target[name] = copy;
  463.                     }
  464.                 }
  465.             }
  466.         }
  467.         return target;
  468.     }
  469.     ;
  470.     jQuery.extend({
  471.         expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
  472.         isReady: true,
  473.         error: function(msg) {
  474.             throw new Error(msg);
  475.         },
  476.         noop: function() {},
  477.         isFunction: function(obj) {
  478.             return jQuery.type(obj) === "function";
  479.         },
  480.         isWindow: function(obj) {
  481.             return obj != null && obj === obj.window;
  482.         },
  483.         isNumeric: function(obj) {
  484.             var type = jQuery.type(obj);
  485.             return (type === "number" || type === "string") && !isNaN(obj - parseFloat(obj));
  486.         },
  487.         isPlainObject: function(obj) {
  488.             var proto, Ctor;
  489.             if (!obj || toString.call(obj) !== "[object Object]") {
  490.                 return false;
  491.             }
  492.             proto = getProto(obj);
  493.             if (!proto) {
  494.                 return true;
  495.             }
  496.             Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
  497.             return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
  498.         },
  499.         isEmptyObject: function(obj) {
  500.             var name;
  501.             for (name in obj) {
  502.                 return false;
  503.             }
  504.             return true;
  505.         },
  506.         type: function(obj) {
  507.             if (obj == null) {
  508.                 return obj + "";
  509.             }
  510.             return typeof obj === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : typeof obj;
  511.         },
  512.         globalEval: function(code) {
  513.             DOMEval(code);
  514.         },
  515.         camelCase: function(string) {
  516.             return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
  517.         },
  518.         each: function(obj, callback) {
  519.             var length, i = 0;
  520.             if (isArrayLike(obj)) {
  521.                 length = obj.length;
  522.                 for (; i < length; i++) {
  523.                     if (callback.call(obj[i], i, obj[i]) === false) {
  524.                         break;
  525.                     }
  526.                 }
  527.             } else {
  528.                 for (i in obj) {
  529.                     if (callback.call(obj[i], i, obj[i]) === false) {
  530.                         break;
  531.                     }
  532.                 }
  533.             }
  534.             return obj;
  535.         },
  536.         trim: function(text) {
  537.             return text == null ? "" : (text + "").replace(rtrim, "");
  538.         },
  539.         makeArray: function(arr, results) {
  540.             var ret = results || [];
  541.             if (arr != null) {
  542.                 if (isArrayLike(Object(arr))) {
  543.                     jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
  544.                 } else {
  545.                     push.call(ret, arr);
  546.                 }
  547.             }
  548.             return ret;
  549.         },
  550.         inArray: function(elem, arr, i) {
  551.             return arr == null ? -1 : indexOf.call(arr, elem, i);
  552.         },
  553.         merge: function(first, second) {
  554.             var len = +second.length
  555.               , j = 0
  556.               , i = first.length;
  557.             for (; j < len; j++) {
  558.                 first[i++] = second[j];
  559.             }
  560.             first.length = i;
  561.             return first;
  562.         },
  563.         grep: function(elems, callback, invert) {
  564.             var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert;
  565.             for (; i < length; i++) {
  566.                 callbackInverse = !callback(elems[i], i);
  567.                 if (callbackInverse !== callbackExpect) {
  568.                     matches.push(elems[i]);
  569.                 }
  570.             }
  571.             return matches;
  572.         },
  573.         map: function(elems, callback, arg) {
  574.             var length, value, i = 0, ret = [];
  575.             if (isArrayLike(elems)) {
  576.                 length = elems.length;
  577.                 for (; i < length; i++) {
  578.                     value = callback(elems[i], i, arg);
  579.                     if (value != null) {
  580.                         ret.push(value);
  581.                     }
  582.                 }
  583.             } else {
  584.                 for (i in elems) {
  585.                     value = callback(elems[i], i, arg);
  586.                     if (value != null) {
  587.                         ret.push(value);
  588.                     }
  589.                 }
  590.             }
  591.             return concat.apply([], ret);
  592.         },
  593.         guid: 1,
  594.         proxy: function(fn, context) {
  595.             var tmp, args, proxy;
  596.             if (typeof context === "string") {
  597.                 tmp = fn[context];
  598.                 context = fn;
  599.                 fn = tmp;
  600.             }
  601.             if (!jQuery.isFunction(fn)) {
  602.                 return undefined;
  603.             }
  604.             args = slice.call(arguments, 2);
  605.             proxy = function() {
  606.                 return fn.apply(context || this, args.concat(slice.call(arguments)));
  607.             }
  608.             ;
  609.             proxy.guid = fn.guid = fn.guid || jQuery.guid++;
  610.             return proxy;
  611.         },
  612.         now: Date.now,
  613.         support: support
  614.     });
  615.     if (typeof Symbol === "function") {
  616.         jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
  617.     }
  618.     jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function(i, name) {
  619.         class2type["[object " + name + "]"] = name.toLowerCase();
  620.     });
  621.     function isArrayLike(obj) {
  622.         var length = !!obj && "length"in obj && obj.length
  623.           , type = jQuery.type(obj);
  624.         if (type === "function" || jQuery.isWindow(obj)) {
  625.             return false;
  626.         }
  627.         return type === "array" || length === 0 || typeof length === "number" && length > 0 && (length - 1)in obj;
  628.     }
  629.     var Sizzle = /*!
  630.  * Sizzle CSS Selector Engine v2.3.3
  631.  * https://sizzlejs.com/
  632.  *
  633.  * Copyright jQuery Foundation and other contributors
  634.  * Released under the MIT license
  635.  * http://jquery.org/license
  636.  *
  637.  * Date: 2016-08-08
  638.  */
  639.     (function(window) {
  640.         var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function(a, b) {
  641.             if (a === b) {
  642.                 hasDuplicate = true;
  643.             }
  644.             return 0;
  645.         }, hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, indexOf = function(list, elem) {
  646.             var i = 0
  647.               , len = list.length;
  648.             for (; i < len; i++) {
  649.                 if (list[i] === elem) {
  650.                     return i;
  651.                 }
  652.             }
  653.             return -1;
  654.         }, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", whitespace = "[\\x20\\t\\r\\n\\f]", identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + "*([*^$|!~]?=)" + whitespace + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + ")(?:\\((" + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + ".*" + ")\\)|)", rwhitespace = new RegExp(whitespace + "+","g"), rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$","g"), rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]","g"), rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), matchExpr = {
  655.             "ID": new RegExp("^#(" + identifier + ")"),
  656.             "CLASS": new RegExp("^\\.(" + identifier + ")"),
  657.             "TAG": new RegExp("^(" + identifier + "|[*])"),
  658.             "ATTR": new RegExp("^" + attributes),
  659.             "PSEUDO": new RegExp("^" + pseudos),
  660.             "CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)","i"),
  661.             "bool": new RegExp("^(?:" + booleans + ")$","i"),
  662.             "needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)","i")
  663.         }, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/, rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)","ig"), funescape = function(_, escaped, escapedWhitespace) {
  664.             var high = "0x" + escaped - 0x10000;
  665.             return high !== high || escapedWhitespace ? escaped : high < 0 ? String.fromCharCode(high + 0x10000) : String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
  666.         }, rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, fcssescape = function(ch, asCodePoint) {
  667.             if (asCodePoint) {
  668.                 if (ch === "\0") {
  669.                     return "\uFFFD";
  670.                 }
  671.                 return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
  672.             }
  673.             return "\\" + ch;
  674.         }, unloadHandler = function() {
  675.             setDocument();
  676.         }, disabledAncestor = addCombinator(function(elem) {
  677.             return elem.disabled === true && ("form"in elem || "label"in elem);
  678.         }, {
  679.             dir: "parentNode",
  680.             next: "legend"
  681.         });
  682.         try {
  683.             push.apply((arr = slice.call(preferredDoc.childNodes)), preferredDoc.childNodes);
  684.             arr[preferredDoc.childNodes.length].nodeType;
  685.         } catch (e) {
  686.             push = {
  687.                 apply: arr.length ? function(target, els) {
  688.                     push_native.apply(target, slice.call(els));
  689.                 }
  690.                 : function(target, els) {
  691.                     var j = target.length
  692.                       , i = 0;
  693.                     while ((target[j++] = els[i++])) {}
  694.                     target.length = j - 1;
  695.                 }
  696.             };
  697.         }
  698.         function Sizzle(selector, context, results, seed) {
  699.             var m, i, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, nodeType = context ? context.nodeType : 9;
  700.             results = results || [];
  701.             if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
  702.                 return results;
  703.             }
  704.             if (!seed) {
  705.                 if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
  706.                     setDocument(context);
  707.                 }
  708.                 context = context || document;
  709.                 if (documentIsHTML) {
  710.                     if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
  711.                         if ((m = match[1])) {
  712.                             if (nodeType === 9) {
  713.                                 if ((elem = context.getElementById(m))) {
  714.                                     if (elem.id === m) {
  715.                                         results.push(elem);
  716.                                         return results;
  717.                                     }
  718.                                 } else {
  719.                                     return results;
  720.                                 }
  721.                             } else {
  722.                                 if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {
  723.                                     results.push(elem);
  724.                                     return results;
  725.                                 }
  726.                             }
  727.                         } else if (match[2]) {
  728.                             push.apply(results, context.getElementsByTagName(selector));
  729.                             return results;
  730.                         } else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
  731.                             push.apply(results, context.getElementsByClassName(m));
  732.                             return results;
  733.                         }
  734.                     }
  735.                     if (support.qsa && !compilerCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
  736.                         if (nodeType !== 1) {
  737.                             newContext = context;
  738.                             newSelector = selector;
  739.                         } else if (context.nodeName.toLowerCase() !== "object") {
  740.                             if ((nid = context.getAttribute("id"))) {
  741.                                 nid = nid.replace(rcssescape, fcssescape);
  742.                             } else {
  743.                                 context.setAttribute("id", (nid = expando));
  744.                             }
  745.                             groups = tokenize(selector);
  746.                             i = groups.length;
  747.                             while (i--) {
  748.                                 groups[i] = "#" + nid + " " + toSelector(groups[i]);
  749.                             }
  750.                             newSelector = groups.join(",");
  751.                             newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
  752.                         }
  753.                         if (newSelector) {
  754.                             try {
  755.                                 push.apply(results, newContext.querySelectorAll(newSelector));
  756.                                 return results;
  757.                             } catch (qsaError) {} finally {
  758.                                 if (nid === expando) {
  759.                                     context.removeAttribute("id");
  760.                                 }
  761.                             }
  762.                         }
  763.                     }
  764.                 }
  765.             }
  766.             return select(selector.replace(rtrim, "$1"), context, results, seed);
  767.         }
  768.         function createCache() {
  769.             var keys = [];
  770.             function cache(key, value) {
  771.                 if (keys.push(key + " ") > Expr.cacheLength) {
  772.                     delete cache[keys.shift()];
  773.                 }
  774.                 return (cache[key + " "] = value);
  775.             }
  776.             return cache;
  777.         }
  778.         function markFunction(fn) {
  779.             fn[expando] = true;
  780.             return fn;
  781.         }
  782.         function assert(fn) {
  783.             var el = document.createElement("fieldset");
  784.             try {
  785.                 return !!fn(el);
  786.             } catch (e) {
  787.                 return false;
  788.             } finally {
  789.                 if (el.parentNode) {
  790.                     el.parentNode.removeChild(el);
  791.                 }
  792.                 el = null;
  793.             }
  794.         }
  795.         function addHandle(attrs, handler) {
  796.             var arr = attrs.split("|")
  797.               , i = arr.length;
  798.             while (i--) {
  799.                 Expr.attrHandle[arr[i]] = handler;
  800.             }
  801.         }
  802.         function siblingCheck(a, b) {
  803.             var cur = b && a
  804.               , diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex;
  805.             if (diff) {
  806.                 return diff;
  807.             }
  808.             if (cur) {
  809.                 while ((cur = cur.nextSibling)) {
  810.                     if (cur === b) {
  811.                         return -1;
  812.                     }
  813.                 }
  814.             }
  815.             return a ? 1 : -1;
  816.         }
  817.         function createInputPseudo(type) {
  818.             return function(elem) {
  819.                 var name = elem.nodeName.toLowerCase();
  820.                 return name === "input" && elem.type === type;
  821.             }
  822.             ;
  823.         }
  824.         function createButtonPseudo(type) {
  825.             return function(elem) {
  826.                 var name = elem.nodeName.toLowerCase();
  827.                 return (name === "input" || name === "button") && elem.type === type;
  828.             }
  829.             ;
  830.         }
  831.         function createDisabledPseudo(disabled) {
  832.             return function(elem) {
  833.                 if ("form"in elem) {
  834.                     if (elem.parentNode && elem.disabled === false) {
  835.                         if ("label"in elem) {
  836.                             if ("label"in elem.parentNode) {
  837.                                 return elem.parentNode.disabled === disabled;
  838.                             } else {
  839.                                 return elem.disabled === disabled;
  840.                             }
  841.                         }
  842.                         return elem.isDisabled === disabled || elem.isDisabled !== !disabled && disabledAncestor(elem) === disabled;
  843.                     }
  844.                     return elem.disabled === disabled;
  845.                 } else if ("label"in elem) {
  846.                     return elem.disabled === disabled;
  847.                 }
  848.                 return false;
  849.             }
  850.             ;
  851.         }
  852.         function createPositionalPseudo(fn) {
  853.             return markFunction(function(argument) {
  854.                 argument = +argument;
  855.                 return markFunction(function(seed, matches) {
  856.                     var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length;
  857.                     while (i--) {
  858.                         if (seed[(j = matchIndexes[i])]) {
  859.                             seed[j] = !(matches[j] = seed[j]);
  860.                         }
  861.                     }
  862.                 });
  863.             });
  864.         }
  865.         function testContext(context) {
  866.             return context && typeof context.getElementsByTagName !== "undefined" && context;
  867.         }
  868.         support = Sizzle.support = {};
  869.         isXML = Sizzle.isXML = function(elem) {
  870.             var documentElement = elem && (elem.ownerDocument || elem).documentElement;
  871.             return documentElement ? documentElement.nodeName !== "HTML" : false;
  872.         }
  873.         ;
  874.         setDocument = Sizzle.setDocument = function(node) {
  875.             var hasCompare, subWindow, doc = node ? node.ownerDocument || node : preferredDoc;
  876.             if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
  877.                 return document;
  878.             }
  879.             document = doc;
  880.             docElem = document.documentElement;
  881.             documentIsHTML = !isXML(document);
  882.             if (preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {
  883.                 if (subWindow.addEventListener) {
  884.                     subWindow.addEventListener("unload", unloadHandler, false);
  885.                 } else if (subWindow.attachEvent) {
  886.                     subWindow.attachEvent("onunload", unloadHandler);
  887.                 }
  888.             }
  889.             support.attributes = assert(function(el) {
  890.                 el.className = "i";
  891.                 return !el.getAttribute("className");
  892.             });
  893.             support.getElementsByTagName = assert(function(el) {
  894.                 el.appendChild(document.createComment(""));
  895.                 return !el.getElementsByTagName("*").length;
  896.             });
  897.             support.getElementsByClassName = rnative.test(document.getElementsByClassName);
  898.             support.getById = assert(function(el) {
  899.                 docElem.appendChild(el).id = expando;
  900.                 return !document.getElementsByName || !document.getElementsByName(expando).length;
  901.             });
  902.             if (support.getById) {
  903.                 Expr.filter["ID"] = function(id) {
  904.                     var attrId = id.replace(runescape, funescape);
  905.                     return function(elem) {
  906.                         return elem.getAttribute("id") === attrId;
  907.                     }
  908.                     ;
  909.                 }
  910.                 ;
  911.                 Expr.find["ID"] = function(id, context) {
  912.                     if (typeof context.getElementById !== "undefined" && documentIsHTML) {
  913.                         var elem = context.getElementById(id);
  914.                         return elem ? [elem] : [];
  915.                     }
  916.                 }
  917.                 ;
  918.             } else {
  919.                 Expr.filter["ID"] = function(id) {
  920.                     var attrId = id.replace(runescape, funescape);
  921.                     return function(elem) {
  922.                         var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
  923.                         return node && node.value === attrId;
  924.                     }
  925.                     ;
  926.                 }
  927.                 ;
  928.                 Expr.find["ID"] = function(id, context) {
  929.                     if (typeof context.getElementById !== "undefined" && documentIsHTML) {
  930.                         var node, i, elems, elem = context.getElementById(id);
  931.                         if (elem) {
  932.                             node = elem.getAttributeNode("id");
  933.                             if (node && node.value === id) {
  934.                                 return [elem];
  935.                             }
  936.                             elems = context.getElementsByName(id);
  937.                             i = 0;
  938.                             while ((elem = elems[i++])) {
  939.                                 node = elem.getAttributeNode("id");
  940.                                 if (node && node.value === id) {
  941.                                     return [elem];
  942.                                 }
  943.                             }
  944.                         }
  945.                         return [];
  946.                     }
  947.                 }
  948.                 ;
  949.             }
  950.             Expr.find["TAG"] = support.getElementsByTagName ? function(tag, context) {
  951.                 if (typeof context.getElementsByTagName !== "undefined") {
  952.                     return context.getElementsByTagName(tag);
  953.                 } else if (support.qsa) {
  954.                     return context.querySelectorAll(tag);
  955.                 }
  956.             }
  957.             : function(tag, context) {
  958.                 var elem, tmp = [], i = 0, results = context.getElementsByTagName(tag);
  959.                 if (tag === "*") {
  960.                     while ((elem = results[i++])) {
  961.                         if (elem.nodeType === 1) {
  962.                             tmp.push(elem);
  963.                         }
  964.                     }
  965.                     return tmp;
  966.                 }
  967.                 return results;
  968.             }
  969.             ;
  970.             Expr.find["CLASS"] = support.getElementsByClassName && function(className, context) {
  971.                 if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
  972.                     return context.getElementsByClassName(className);
  973.                 }
  974.             }
  975.             ;
  976.             rbuggyMatches = [];
  977.             rbuggyQSA = [];
  978.             if ((support.qsa = rnative.test(document.querySelectorAll))) {
  979.                 assert(function(el) {
  980.                     docElem.appendChild(el).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>";
  981.                     if (el.querySelectorAll("[msallowcapture^='']").length) {
  982.                         rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
  983.                     }
  984.                     if (!el.querySelectorAll("[selected]").length) {
  985.                         rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
  986.                     }
  987.                     if (!el.querySelectorAll("[id~=" + expando + "-]").length) {
  988.                         rbuggyQSA.push("~=");
  989.                     }
  990.                     if (!el.querySelectorAll(":checked").length) {
  991.                         rbuggyQSA.push(":checked");
  992.                     }
  993.                     if (!el.querySelectorAll("a#" + expando + "+*").length) {
  994.                         rbuggyQSA.push(".#.+[+~]");
  995.                     }
  996.                 });
  997.                 assert(function(el) {
  998.                     el.innerHTML = "<a href='' disabled='disabled'></a>" + "<select disabled='disabled'><option/></select>";
  999.                     var input = document.createElement("input");
  1000.                     input.setAttribute("type", "hidden");
  1001.                     el.appendChild(input).setAttribute("name", "D");
  1002.                     if (el.querySelectorAll("[name=d]").length) {
  1003.                         rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
  1004.                     }
  1005.                     if (el.querySelectorAll(":enabled").length !== 2) {
  1006.                         rbuggyQSA.push(":enabled", ":disabled");
  1007.                     }
  1008.                     docElem.appendChild(el).disabled = true;
  1009.                     if (el.querySelectorAll(":disabled").length !== 2) {
  1010.                         rbuggyQSA.push(":enabled", ":disabled");
  1011.                     }
  1012.                     el.querySelectorAll("*,:x");
  1013.                     rbuggyQSA.push(",.*:");
  1014.                 });
  1015.             }
  1016.             if ((support.matchesSelector = rnative.test((matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)))) {
  1017.                 assert(function(el) {
  1018.                     support.disconnectedMatch = matches.call(el, "*");
  1019.                     matches.call(el, "[s!='']:x");
  1020.                     rbuggyMatches.push("!=", pseudos);
  1021.                 });
  1022.             }
  1023.             rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
  1024.             rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
  1025.             hasCompare = rnative.test(docElem.compareDocumentPosition);
  1026.             contains = hasCompare || rnative.test(docElem.contains) ? function(a, b) {
  1027.                 var adown = a.nodeType === 9 ? a.documentElement : a
  1028.                   , bup = b && b.parentNode;
  1029.                 return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
  1030.             }
  1031.             : function(a, b) {
  1032.                 if (b) {
  1033.                     while ((b = b.parentNode)) {
  1034.                         if (b === a) {
  1035.                             return true;
  1036.                         }
  1037.                     }
  1038.                 }
  1039.                 return false;
  1040.             }
  1041.             ;
  1042.             sortOrder = hasCompare ? function(a, b) {
  1043.                 if (a === b) {
  1044.                     hasDuplicate = true;
  1045.                     return 0;
  1046.                 }
  1047.                 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
  1048.                 if (compare) {
  1049.                     return compare;
  1050.                 }
  1051.                 compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1;
  1052.                 if (compare & 1 || (!support.sortDetached && b.compareDocumentPosition(a) === compare)) {
  1053.                     if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
  1054.                         return -1;
  1055.                     }
  1056.                     if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
  1057.                         return 1;
  1058.                     }
  1059.                     return sortInput ? (indexOf(sortInput, a) - indexOf(sortInput, b)) : 0;
  1060.                 }
  1061.                 return compare & 4 ? -1 : 1;
  1062.             }
  1063.             : function(a, b) {
  1064.                 if (a === b) {
  1065.                     hasDuplicate = true;
  1066.                     return 0;
  1067.                 }
  1068.                 var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [a], bp = [b];
  1069.                 if (!aup || !bup) {
  1070.                     return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? (indexOf(sortInput, a) - indexOf(sortInput, b)) : 0;
  1071.                 } else if (aup === bup) {
  1072.                     return siblingCheck(a, b);
  1073.                 }
  1074.                 cur = a;
  1075.                 while ((cur = cur.parentNode)) {
  1076.                     ap.unshift(cur);
  1077.                 }
  1078.                 cur = b;
  1079.                 while ((cur = cur.parentNode)) {
  1080.                     bp.unshift(cur);
  1081.                 }
  1082.                 while (ap[i] === bp[i]) {
  1083.                     i++;
  1084.                 }
  1085.                 return i ? siblingCheck(ap[i], bp[i]) : ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
  1086.             }
  1087.             ;
  1088.             return document;
  1089.         }
  1090.         ;
  1091.         Sizzle.matches = function(expr, elements) {
  1092.             return Sizzle(expr, null, null, elements);
  1093.         }
  1094.         ;
  1095.         Sizzle.matchesSelector = function(elem, expr) {
  1096.             if ((elem.ownerDocument || elem) !== document) {
  1097.                 setDocument(elem);
  1098.             }
  1099.             expr = expr.replace(rattributeQuotes, "='$1']");
  1100.             if (support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
  1101.                 try {
  1102.                     var ret = matches.call(elem, expr);
  1103.                     if (ret || support.disconnectedMatch || elem.document && elem.document.nodeType !== 11) {
  1104.                         return ret;
  1105.                     }
  1106.                 } catch (e) {}
  1107.             }
  1108.             return Sizzle(expr, document, null, [elem]).length > 0;
  1109.         }
  1110.         ;
  1111.         Sizzle.contains = function(context, elem) {
  1112.             if ((context.ownerDocument || context) !== document) {
  1113.                 setDocument(context);
  1114.             }
  1115.             return contains(context, elem);
  1116.         }
  1117.         ;
  1118.         Sizzle.attr = function(elem, name) {
  1119.             if ((elem.ownerDocument || elem) !== document) {
  1120.                 setDocument(elem);
  1121.             }
  1122.             var fn = Expr.attrHandle[name.toLowerCase()]
  1123.               , val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;
  1124.             return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  1125.         }
  1126.         ;
  1127.         Sizzle.escape = function(sel) {
  1128.             return (sel + "").replace(rcssescape, fcssescape);
  1129.         }
  1130.         ;
  1131.         Sizzle.error = function(msg) {
  1132.             throw new Error("Syntax error, unrecognized expression: " + msg);
  1133.         }
  1134.         ;
  1135.         Sizzle.uniqueSort = function(results) {
  1136.             var elem, duplicates = [], j = 0, i = 0;
  1137.             hasDuplicate = !support.detectDuplicates;
  1138.             sortInput = !support.sortStable && results.slice(0);
  1139.             results.sort(sortOrder);
  1140.             if (hasDuplicate) {
  1141.                 while ((elem = results[i++])) {
  1142.                     if (elem === results[i]) {
  1143.                         j = duplicates.push(i);
  1144.                     }
  1145.                 }
  1146.                 while (j--) {
  1147.                     results.splice(duplicates[j], 1);
  1148.                 }
  1149.             }
  1150.             sortInput = null;
  1151.             return results;
  1152.         }
  1153.         ;
  1154.         getText = Sizzle.getText = function(elem) {
  1155.             var node, ret = "", i = 0, nodeType = elem.nodeType;
  1156.             if (!nodeType) {
  1157.                 while ((node = elem[i++])) {
  1158.                     ret += getText(node);
  1159.                 }
  1160.             } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
  1161.                 if (typeof elem.textContent === "string") {
  1162.                     return elem.textContent;
  1163.                 } else {
  1164.                     for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
  1165.                         ret += getText(elem);
  1166.                     }
  1167.                 }
  1168.             } else if (nodeType === 3 || nodeType === 4) {
  1169.                 return elem.nodeValue;
  1170.             }
  1171.             return ret;
  1172.         }
  1173.         ;
  1174.         Expr = Sizzle.selectors = {
  1175.             cacheLength: 50,
  1176.             createPseudo: markFunction,
  1177.             match: matchExpr,
  1178.             attrHandle: {},
  1179.             find: {},
  1180.             relative: {
  1181.                 ">": {
  1182.                     dir: "parentNode",
  1183.                     first: true
  1184.                 },
  1185.                 " ": {
  1186.                     dir: "parentNode"
  1187.                 },
  1188.                 "+": {
  1189.                     dir: "previousSibling",
  1190.                     first: true
  1191.                 },
  1192.                 "~": {
  1193.                     dir: "previousSibling"
  1194.                 }
  1195.             },
  1196.             preFilter: {
  1197.                 "ATTR": function(match) {
  1198.                     match[1] = match[1].replace(runescape, funescape);
  1199.                     match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
  1200.                     if (match[2] === "~=") {
  1201.                         match[3] = " " + match[3] + " ";
  1202.                     }
  1203.                     return match.slice(0, 4);
  1204.                 },
  1205.                 "CHILD": function(match) {
  1206.                     match[1] = match[1].toLowerCase();
  1207.                     if (match[1].slice(0, 3) === "nth") {
  1208.                         if (!match[3]) {
  1209.                             Sizzle.error(match[0]);
  1210.                         }
  1211.                         match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
  1212.                         match[5] = +((match[7] + match[8]) || match[3] === "odd");
  1213.                     } else if (match[3]) {
  1214.                         Sizzle.error(match[0]);
  1215.                     }
  1216.                     return match;
  1217.                 },
  1218.                 "PSEUDO": function(match) {
  1219.                     var excess, unquoted = !match[6] && match[2];
  1220.                     if (matchExpr["CHILD"].test(match[0])) {
  1221.                         return null;
  1222.                     }
  1223.                     if (match[3]) {
  1224.                         match[2] = match[4] || match[5] || "";
  1225.                     } else if (unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
  1226.                         match[0] = match[0].slice(0, excess);
  1227.                         match[2] = unquoted.slice(0, excess);
  1228.                     }
  1229.                     return match.slice(0, 3);
  1230.                 }
  1231.             },
  1232.             filter: {
  1233.                 "TAG": function(nodeNameSelector) {
  1234.                     var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
  1235.                     return nodeNameSelector === "*" ? function() {
  1236.                         return true;
  1237.                     }
  1238.                     : function(elem) {
  1239.                         return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  1240.                     }
  1241.                     ;
  1242.                 },
  1243.                 "CLASS": function(className) {
  1244.                     var pattern = classCache[className + " "];
  1245.                     return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function(elem) {
  1246.                         return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
  1247.                     });
  1248.                 },
  1249.                 "ATTR": function(name, operator, check) {
  1250.                     return function(elem) {
  1251.                         var result = Sizzle.attr(elem, name);
  1252.                         if (result == null) {
  1253.                             return operator === "!=";
  1254.                         }
  1255.                         if (!operator) {
  1256.                             return true;
  1257.                         }
  1258.                         result += "";
  1259.                         return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
  1260.                     }
  1261.                     ;
  1262.                 },
  1263.                 "CHILD": function(type, what, argument, first, last) {
  1264.                     var simple = type.slice(0, 3) !== "nth"
  1265.                       , forward = type.slice(-4) !== "last"
  1266.                       , ofType = what === "of-type";
  1267.                     return first === 1 && last === 0 ? function(elem) {
  1268.                         return !!elem.parentNode;
  1269.                     }
  1270.                     : function(elem, context, xml) {
  1271.                         var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false;
  1272.                         if (parent) {
  1273.                             if (simple) {
  1274.                                 while (dir) {
  1275.                                     node = elem;
  1276.                                     while ((node = node[dir])) {
  1277.                                         if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
  1278.                                             return false;
  1279.                                         }
  1280.                                     }
  1281.                                     start = dir = type === "only" && !start && "nextSibling";
  1282.                                 }
  1283.                                 return true;
  1284.                             }
  1285.                             start = [forward ? parent.firstChild : parent.lastChild];
  1286.                             if (forward && useCache) {
  1287.                                 node = parent;
  1288.                                 outerCache = node[expando] || (node[expando] = {});
  1289.                                 uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
  1290.                                 cache = uniqueCache[type] || [];
  1291.                                 nodeIndex = cache[0] === dirruns && cache[1];
  1292.                                 diff = nodeIndex && cache[2];
  1293.                                 node = nodeIndex && parent.childNodes[nodeIndex];
  1294.                                 while ((node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop())) {
  1295.                                     if (node.nodeType === 1 && ++diff && node === elem) {
  1296.                                         uniqueCache[type] = [dirruns, nodeIndex, diff];
  1297.                                         break;
  1298.                                     }
  1299.                                 }
  1300.                             } else {
  1301.                                 if (useCache) {
  1302.                                     node = elem;
  1303.                                     outerCache = node[expando] || (node[expando] = {});
  1304.                                     uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
  1305.                                     cache = uniqueCache[type] || [];
  1306.                                     nodeIndex = cache[0] === dirruns && cache[1];
  1307.                                     diff = nodeIndex;
  1308.                                 }
  1309.                                 if (diff === false) {
  1310.                                     while ((node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop())) {
  1311.                                         if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
  1312.                                             if (useCache) {
  1313.                                                 outerCache = node[expando] || (node[expando] = {});
  1314.                                                 uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
  1315.                                                 uniqueCache[type] = [dirruns, diff];
  1316.                                             }
  1317.                                             if (node === elem) {
  1318.                                                 break;
  1319.                                             }
  1320.                                         }
  1321.                                     }
  1322.                                 }
  1323.                             }
  1324.                             diff -= last;
  1325.                             return diff === first || (diff % first === 0 && diff / first >= 0);
  1326.                         }
  1327.                     }
  1328.                     ;
  1329.                 },
  1330.                 "PSEUDO": function(pseudo, argument) {
  1331.                     var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
  1332.                     if (fn[expando]) {
  1333.                         return fn(argument);
  1334.                     }
  1335.                     if (fn.length > 1) {
  1336.                         args = [pseudo, pseudo, "", argument];
  1337.                         return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches) {
  1338.                             var idx, matched = fn(seed, argument), i = matched.length;
  1339.                             while (i--) {
  1340.                                 idx = indexOf(seed, matched[i]);
  1341.                                 seed[idx] = !(matches[idx] = matched[i]);
  1342.                             }
  1343.                         }) : function(elem) {
  1344.                             return fn(elem, 0, args);
  1345.                         }
  1346.                         ;
  1347.                     }
  1348.                     return fn;
  1349.                 }
  1350.             },
  1351.             pseudos: {
  1352.                 "not": markFunction(function(selector) {
  1353.                     var input = []
  1354.                       , results = []
  1355.                       , matcher = compile(selector.replace(rtrim, "$1"));
  1356.                     return matcher[expando] ? markFunction(function(seed, matches, context, xml) {
  1357.                         var elem, unmatched = matcher(seed, null, xml, []), i = seed.length;
  1358.                         while (i--) {
  1359.                             if ((elem = unmatched[i])) {
  1360.                                 seed[i] = !(matches[i] = elem);
  1361.                             }
  1362.                         }
  1363.                     }) : function(elem, context, xml) {
  1364.                         input[0] = elem;
  1365.                         matcher(input, null, xml, results);
  1366.                         input[0] = null;
  1367.                         return !results.pop();
  1368.                     }
  1369.                     ;
  1370.                 }),
  1371.                 "has": markFunction(function(selector) {
  1372.                     return function(elem) {
  1373.                         return Sizzle(selector, elem).length > 0;
  1374.                     }
  1375.                     ;
  1376.                 }),
  1377.                 "contains": markFunction(function(text) {
  1378.                     text = text.replace(runescape, funescape);
  1379.                     return function(elem) {
  1380.                         return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
  1381.                     }
  1382.                     ;
  1383.                 }),
  1384.                 "lang": markFunction(function(lang) {
  1385.                     if (!ridentifier.test(lang || "")) {
  1386.                         Sizzle.error("unsupported lang: " + lang);
  1387.                     }
  1388.                     lang = lang.replace(runescape, funescape).toLowerCase();
  1389.                     return function(elem) {
  1390.                         var elemLang;
  1391.                         do {
  1392.                             if ((elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang"))) {
  1393.                                 elemLang = elemLang.toLowerCase();
  1394.                                 return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
  1395.                             }
  1396.                         } while ((elem = elem.parentNode) && elem.nodeType === 1);return false;
  1397.                     }
  1398.                     ;
  1399.                 }),
  1400.                 "target": function(elem) {
  1401.                     var hash = window.location && window.location.hash;
  1402.                     return hash && hash.slice(1) === elem.id;
  1403.                 },
  1404.                 "root": function(elem) {
  1405.                     return elem === docElem;
  1406.                 },
  1407.                 "focus": function(elem) {
  1408.                     return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
  1409.                 },
  1410.                 "enabled": createDisabledPseudo(false),
  1411.                 "disabled": createDisabledPseudo(true),
  1412.                 "checked": function(elem) {
  1413.                     var nodeName = elem.nodeName.toLowerCase();
  1414.                     return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
  1415.                 },
  1416.                 "selected": function(elem) {
  1417.                     if (elem.parentNode) {
  1418.                         elem.parentNode.selectedIndex;
  1419.                     }
  1420.                     return elem.selected === true;
  1421.                 },
  1422.                 "empty": function(elem) {
  1423.                     for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
  1424.                         if (elem.nodeType < 6) {
  1425.                             return false;
  1426.                         }
  1427.                     }
  1428.                     return true;
  1429.                 },
  1430.                 "parent": function(elem) {
  1431.                     return !Expr.pseudos["empty"](elem);
  1432.                 },
  1433.                 "header": function(elem) {
  1434.                     return rheader.test(elem.nodeName);
  1435.                 },
  1436.                 "input": function(elem) {
  1437.                     return rinputs.test(elem.nodeName);
  1438.                 },
  1439.                 "button": function(elem) {
  1440.                     var name = elem.nodeName.toLowerCase();
  1441.                     return name === "input" && elem.type === "button" || name === "button";
  1442.                 },
  1443.                 "text": function(elem) {
  1444.                     var attr;
  1445.                     return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
  1446.                 },
  1447.                 "first": createPositionalPseudo(function() {
  1448.                     return [0];
  1449.                 }),
  1450.                 "last": createPositionalPseudo(function(matchIndexes, length) {
  1451.                     return [length - 1];
  1452.                 }),
  1453.                 "eq": createPositionalPseudo(function(matchIndexes, length, argument) {
  1454.                     return [argument < 0 ? argument + length : argument];
  1455.                 }),
  1456.                 "even": createPositionalPseudo(function(matchIndexes, length) {
  1457.                     var i = 0;
  1458.                     for (; i < length; i += 2) {
  1459.                         matchIndexes.push(i);
  1460.                     }
  1461.                     return matchIndexes;
  1462.                 }),
  1463.                 "odd": createPositionalPseudo(function(matchIndexes, length) {
  1464.                     var i = 1;
  1465.                     for (; i < length; i += 2) {
  1466.                         matchIndexes.push(i);
  1467.                     }
  1468.                     return matchIndexes;
  1469.                 }),
  1470.                 "lt": createPositionalPseudo(function(matchIndexes, length, argument) {
  1471.                     var i = argument < 0 ? argument + length : argument;
  1472.                     for (; --i >= 0; ) {
  1473.                         matchIndexes.push(i);
  1474.                     }
  1475.                     return matchIndexes;
  1476.                 }),
  1477.                 "gt": createPositionalPseudo(function(matchIndexes, length, argument) {
  1478.                     var i = argument < 0 ? argument + length : argument;
  1479.                     for (; ++i < length; ) {
  1480.                         matchIndexes.push(i);
  1481.                     }
  1482.                     return matchIndexes;
  1483.                 })
  1484.             }
  1485.         };
  1486.         Expr.pseudos["nth"] = Expr.pseudos["eq"];
  1487.         for (i in {
  1488.             radio: true,
  1489.             checkbox: true,
  1490.             file: true,
  1491.             password: true,
  1492.             image: true
  1493.         }) {
  1494.             Expr.pseudos[i] = createInputPseudo(i);
  1495.         }
  1496.         for (i in {
  1497.             submit: true,
  1498.             reset: true
  1499.         }) {
  1500.             Expr.pseudos[i] = createButtonPseudo(i);
  1501.         }
  1502.         function setFilters() {}
  1503.         setFilters.prototype = Expr.filters = Expr.pseudos;
  1504.         Expr.setFilters = new setFilters();
  1505.         tokenize = Sizzle.tokenize = function(selector, parseOnly) {
  1506.             var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "];
  1507.             if (cached) {
  1508.                 return parseOnly ? 0 : cached.slice(0);
  1509.             }
  1510.             soFar = selector;
  1511.             groups = [];
  1512.             preFilters = Expr.preFilter;
  1513.             while (soFar) {
  1514.                 if (!matched || (match = rcomma.exec(soFar))) {
  1515.                     if (match) {
  1516.                         soFar = soFar.slice(match[0].length) || soFar;
  1517.                     }
  1518.                     groups.push((tokens = []));
  1519.                 }
  1520.                 matched = false;
  1521.                 if ((match = rcombinators.exec(soFar))) {
  1522.                     matched = match.shift();
  1523.                     tokens.push({
  1524.                         value: matched,
  1525.                         type: match[0].replace(rtrim, " ")
  1526.                     });
  1527.                     soFar = soFar.slice(matched.length);
  1528.                 }
  1529.                 for (type in Expr.filter) {
  1530.                     if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
  1531.                         matched = match.shift();
  1532.                         tokens.push({
  1533.                             value: matched,
  1534.                             type: type,
  1535.                             matches: match
  1536.                         });
  1537.                         soFar = soFar.slice(matched.length);
  1538.                     }
  1539.                 }
  1540.                 if (!matched) {
  1541.                     break;
  1542.                 }
  1543.             }
  1544.             return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : tokenCache(selector, groups).slice(0);
  1545.         }
  1546.         ;
  1547.         function toSelector(tokens) {
  1548.             var i = 0
  1549.               , len = tokens.length
  1550.               , selector = "";
  1551.             for (; i < len; i++) {
  1552.                 selector += tokens[i].value;
  1553.             }
  1554.             return selector;
  1555.         }
  1556.         function addCombinator(matcher, combinator, base) {
  1557.             var dir = combinator.dir
  1558.               , skip = combinator.next
  1559.               , key = skip || dir
  1560.               , checkNonElements = base && key === "parentNode"
  1561.               , doneName = done++;
  1562.             return combinator.first ? function(elem, context, xml) {
  1563.                 while ((elem = elem[dir])) {
  1564.                     if (elem.nodeType === 1 || checkNonElements) {
  1565.                         return matcher(elem, context, xml);
  1566.                     }
  1567.                 }
  1568.                 return false;
  1569.             }
  1570.             : function(elem, context, xml) {
  1571.                 var oldCache, uniqueCache, outerCache, newCache = [dirruns, doneName];
  1572.                 if (xml) {
  1573.                     while ((elem = elem[dir])) {
  1574.                         if (elem.nodeType === 1 || checkNonElements) {
  1575.                             if (matcher(elem, context, xml)) {
  1576.                                 return true;
  1577.                             }
  1578.                         }
  1579.                     }
  1580.                 } else {
  1581.                     while ((elem = elem[dir])) {
  1582.                         if (elem.nodeType === 1 || checkNonElements) {
  1583.                             outerCache = elem[expando] || (elem[expando] = {});
  1584.                             uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});
  1585.                             if (skip && skip === elem.nodeName.toLowerCase()) {
  1586.                                 elem = elem[dir] || elem;
  1587.                             } else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
  1588.                                 return (newCache[2] = oldCache[2]);
  1589.                             } else {
  1590.                                 uniqueCache[key] = newCache;
  1591.                                 if ((newCache[2] = matcher(elem, context, xml))) {
  1592.                                     return true;
  1593.                                 }
  1594.                             }
  1595.                         }
  1596.                     }
  1597.                 }
  1598.                 return false;
  1599.             }
  1600.             ;
  1601.         }
  1602.         function elementMatcher(matchers) {
  1603.             return matchers.length > 1 ? function(elem, context, xml) {
  1604.                 var i = matchers.length;
  1605.                 while (i--) {
  1606.                     if (!matchers[i](elem, context, xml)) {
  1607.                         return false;
  1608.                     }
  1609.                 }
  1610.                 return true;
  1611.             }
  1612.             : matchers[0];
  1613.         }
  1614.         function multipleContexts(selector, contexts, results) {
  1615.             var i = 0
  1616.               , len = contexts.length;
  1617.             for (; i < len; i++) {
  1618.                 Sizzle(selector, contexts[i], results);
  1619.             }
  1620.             return results;
  1621.         }
  1622.         function condense(unmatched, map, filter, context, xml) {
  1623.             var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null;
  1624.             for (; i < len; i++) {
  1625.                 if ((elem = unmatched[i])) {
  1626.                     if (!filter || filter(elem, context, xml)) {
  1627.                         newUnmatched.push(elem);
  1628.                         if (mapped) {
  1629.                             map.push(i);
  1630.                         }
  1631.                     }
  1632.                 }
  1633.             }
  1634.             return newUnmatched;
  1635.         }
  1636.         function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
  1637.             if (postFilter && !postFilter[expando]) {
  1638.                 postFilter = setMatcher(postFilter);
  1639.             }
  1640.             if (postFinder && !postFinder[expando]) {
  1641.                 postFinder = setMatcher(postFinder, postSelector);
  1642.             }
  1643.             return markFunction(function(seed, results, context, xml) {
  1644.                 var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []), matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems, matcherOut = matcher ? postFinder || (seed ? preFilter : preexisting || postFilter) ? [] : results : matcherIn;
  1645.                 if (matcher) {
  1646.                     matcher(matcherIn, matcherOut, context, xml);
  1647.                 }
  1648.                 if (postFilter) {
  1649.                     temp = condense(matcherOut, postMap);
  1650.                     postFilter(temp, [], context, xml);
  1651.                     i = temp.length;
  1652.                     while (i--) {
  1653.                         if ((elem = temp[i])) {
  1654.                             matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
  1655.                         }
  1656.                     }
  1657.                 }
  1658.                 if (seed) {
  1659.                     if (postFinder || preFilter) {
  1660.                         if (postFinder) {
  1661.                             temp = [];
  1662.                             i = matcherOut.length;
  1663.                             while (i--) {
  1664.                                 if ((elem = matcherOut[i])) {
  1665.                                     temp.push((matcherIn[i] = elem));
  1666.                                 }
  1667.                             }
  1668.                             postFinder(null, (matcherOut = []), temp, xml);
  1669.                         }
  1670.                         i = matcherOut.length;
  1671.                         while (i--) {
  1672.                             if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {
  1673.                                 seed[temp] = !(results[temp] = elem);
  1674.                             }
  1675.                         }
  1676.                     }
  1677.                 } else {
  1678.                     matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
  1679.                     if (postFinder) {
  1680.                         postFinder(null, results, matcherOut, xml);
  1681.                     } else {
  1682.                         push.apply(results, matcherOut);
  1683.                     }
  1684.                 }
  1685.             });
  1686.         }
  1687.         function matcherFromTokens(tokens) {
  1688.             var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, matchContext = addCombinator(function(elem) {
  1689.                 return elem === checkContext;
  1690.             }, implicitRelative, true), matchAnyContext = addCombinator(function(elem) {
  1691.                 return indexOf(checkContext, elem) > -1;
  1692.             }, implicitRelative, true), matchers = [function(elem, context, xml) {
  1693.                 var ret = (!leadingRelative && (xml || context !== outermostContext)) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
  1694.                 checkContext = null;
  1695.                 return ret;
  1696.             }
  1697.             ];
  1698.             for (; i < len; i++) {
  1699.                 if ((matcher = Expr.relative[tokens[i].type])) {
  1700.                     matchers = [addCombinator(elementMatcher(matchers), matcher)];
  1701.                 } else {
  1702.                     matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
  1703.                     if (matcher[expando]) {
  1704.                         j = ++i;
  1705.                         for (; j < len; j++) {
  1706.                             if (Expr.relative[tokens[j].type]) {
  1707.                                 break;
  1708.                             }
  1709.                         }
  1710.                         return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1).concat({
  1711.                             value: tokens[i - 2].type === " " ? "*" : ""
  1712.                         })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens((tokens = tokens.slice(j))), j < len && toSelector(tokens));
  1713.                     }
  1714.                     matchers.push(matcher);
  1715.                 }
  1716.             }
  1717.             return elementMatcher(matchers);
  1718.         }
  1719.         function matcherFromGroupMatchers(elementMatchers, setMatchers) {
  1720.             var bySet = setMatchers.length > 0
  1721.               , byElement = elementMatchers.length > 0
  1722.               , superMatcher = function(seed, context, xml, results, outermost) {
  1723.                 var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, elems = seed || byElement && Expr.find["TAG"]("*", outermost), dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len = elems.length;
  1724.                 if (outermost) {
  1725.                     outermostContext = context === document || context || outermost;
  1726.                 }
  1727.                 for (; i !== len && (elem = elems[i]) != null; i++) {
  1728.                     if (byElement && elem) {
  1729.                         j = 0;
  1730.                         if (!context && elem.ownerDocument !== document) {
  1731.                             setDocument(elem);
  1732.                             xml = !documentIsHTML;
  1733.                         }
  1734.                         while ((matcher = elementMatchers[j++])) {
  1735.                             if (matcher(elem, context || document, xml)) {
  1736.                                 results.push(elem);
  1737.                                 break;
  1738.                             }
  1739.                         }
  1740.                         if (outermost) {
  1741.                             dirruns = dirrunsUnique;
  1742.                         }
  1743.                     }
  1744.                     if (bySet) {
  1745.                         if ((elem = !matcher && elem)) {
  1746.                             matchedCount--;
  1747.                         }
  1748.                         if (seed) {
  1749.                             unmatched.push(elem);
  1750.                         }
  1751.                     }
  1752.                 }
  1753.                 matchedCount += i;
  1754.                 if (bySet && i !== matchedCount) {
  1755.                     j = 0;
  1756.                     while ((matcher = setMatchers[j++])) {
  1757.                         matcher(unmatched, setMatched, context, xml);
  1758.                     }
  1759.                     if (seed) {
  1760.                         if (matchedCount > 0) {
  1761.                             while (i--) {
  1762.                                 if (!(unmatched[i] || setMatched[i])) {
  1763.                                     setMatched[i] = pop.call(results);
  1764.                                 }
  1765.                             }
  1766.                         }
  1767.                         setMatched = condense(setMatched);
  1768.                     }
  1769.                     push.apply(results, setMatched);
  1770.                     if (outermost && !seed && setMatched.length > 0 && (matchedCount + setMatchers.length) > 1) {
  1771.                         Sizzle.uniqueSort(results);
  1772.                     }
  1773.                 }
  1774.                 if (outermost) {
  1775.                     dirruns = dirrunsUnique;
  1776.                     outermostContext = contextBackup;
  1777.                 }
  1778.                 return unmatched;
  1779.             };
  1780.             return bySet ? markFunction(superMatcher) : superMatcher;
  1781.         }
  1782.         compile = Sizzle.compile = function(selector, match) {
  1783.             var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "];
  1784.             if (!cached) {
  1785.                 if (!match) {
  1786.                     match = tokenize(selector);
  1787.                 }
  1788.                 i = match.length;
  1789.                 while (i--) {
  1790.                     cached = matcherFromTokens(match[i]);
  1791.                     if (cached[expando]) {
  1792.                         setMatchers.push(cached);
  1793.                     } else {
  1794.                         elementMatchers.push(cached);
  1795.                     }
  1796.                 }
  1797.                 cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
  1798.                 cached.selector = selector;
  1799.             }
  1800.             return cached;
  1801.         }
  1802.         ;
  1803.         select = Sizzle.select = function(selector, context, results, seed) {
  1804.             var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize((selector = compiled.selector || selector));
  1805.             results = results || [];
  1806.             if (match.length === 1) {
  1807.                 tokens = match[0] = match[0].slice(0);
  1808.                 if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
  1809.                     context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
  1810.                     if (!context) {
  1811.                         return results;
  1812.                     } else if (compiled) {
  1813.                         context = context.parentNode;
  1814.                     }
  1815.                     selector = selector.slice(tokens.shift().value.length);
  1816.                 }
  1817.                 i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
  1818.                 while (i--) {
  1819.                     token = tokens[i];
  1820.                     if (Expr.relative[(type = token.type)]) {
  1821.                         break;
  1822.                     }
  1823.                     if ((find = Expr.find[type])) {
  1824.                         if ((seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context))) {
  1825.                             tokens.splice(i, 1);
  1826.                             selector = seed.length && toSelector(tokens);
  1827.                             if (!selector) {
  1828.                                 push.apply(results, seed);
  1829.                                 return results;
  1830.                             }
  1831.                             break;
  1832.                         }
  1833.                     }
  1834.                 }
  1835.             }
  1836.             (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
  1837.             return results;
  1838.         }
  1839.         ;
  1840.         support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
  1841.         support.detectDuplicates = !!hasDuplicate;
  1842.         setDocument();
  1843.         support.sortDetached = assert(function(el) {
  1844.             return el.compareDocumentPosition(document.createElement("fieldset")) & 1;
  1845.         });
  1846.         if (!assert(function(el) {
  1847.             el.innerHTML = "<a href='#'></a>";
  1848.             return el.firstChild.getAttribute("href") === "#";
  1849.         })) {
  1850.             addHandle("type|href|height|width", function(elem, name, isXML) {
  1851.                 if (!isXML) {
  1852.                     return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
  1853.                 }
  1854.             });
  1855.         }
  1856.         if (!support.attributes || !assert(function(el) {
  1857.             el.innerHTML = "<input/>";
  1858.             el.firstChild.setAttribute("value", "");
  1859.             return el.firstChild.getAttribute("value") === "";
  1860.         })) {
  1861.             addHandle("value", function(elem, name, isXML) {
  1862.                 if (!isXML && elem.nodeName.toLowerCase() === "input") {
  1863.                     return elem.defaultValue;
  1864.                 }
  1865.             });
  1866.         }
  1867.         if (!assert(function(el) {
  1868.             return el.getAttribute("disabled") == null;
  1869.         })) {
  1870.             addHandle(booleans, function(elem, name, isXML) {
  1871.                 var val;
  1872.                 if (!isXML) {
  1873.                     return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
  1874.                 }
  1875.             });
  1876.         }
  1877.         return Sizzle;
  1878.     }
  1879.     )(window);
  1880.     jQuery.find = Sizzle;
  1881.     jQuery.expr = Sizzle.selectors;
  1882.     jQuery.expr[":"] = jQuery.expr.pseudos;
  1883.     jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
  1884.     jQuery.text = Sizzle.getText;
  1885.     jQuery.isXMLDoc = Sizzle.isXML;
  1886.     jQuery.contains = Sizzle.contains;
  1887.     jQuery.escapeSelector = Sizzle.escape;
  1888.     var dir = function(elem, dir, until) {
  1889.         var matched = []
  1890.           , truncate = until !== undefined;
  1891.         while ((elem = elem[dir]) && elem.nodeType !== 9) {
  1892.             if (elem.nodeType === 1) {
  1893.                 if (truncate && jQuery(elem).is(until)) {
  1894.                     break;
  1895.                 }
  1896.                 matched.push(elem);
  1897.             }
  1898.         }
  1899.         return matched;
  1900.     };
  1901.     var siblings = function(n, elem) {
  1902.         var matched = [];
  1903.         for (; n; n = n.nextSibling) {
  1904.             if (n.nodeType === 1 && n !== elem) {
  1905.                 matched.push(n);
  1906.             }
  1907.         }
  1908.         return matched;
  1909.     };
  1910.     var rneedsContext = jQuery.expr.match.needsContext;
  1911.     function nodeName(elem, name) {
  1912.         return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
  1913.     }
  1914.     ;var rsingleTag = (/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i);
  1915.     var risSimple = /^.[^:#\[\.,]*$/;
  1916.     function winnow(elements, qualifier, not) {
  1917.         if (jQuery.isFunction(qualifier)) {
  1918.             return jQuery.grep(elements, function(elem, i) {
  1919.                 return !!qualifier.call(elem, i, elem) !== not;
  1920.             });
  1921.         }
  1922.         if (qualifier.nodeType) {
  1923.             return jQuery.grep(elements, function(elem) {
  1924.                 return (elem === qualifier) !== not;
  1925.             });
  1926.         }
  1927.         if (typeof qualifier !== "string") {
  1928.             return jQuery.grep(elements, function(elem) {
  1929.                 return (indexOf.call(qualifier, elem) > -1) !== not;
  1930.             });
  1931.         }
  1932.         if (risSimple.test(qualifier)) {
  1933.             return jQuery.filter(qualifier, elements, not);
  1934.         }
  1935.         qualifier = jQuery.filter(qualifier, elements);
  1936.         return jQuery.grep(elements, function(elem) {
  1937.             return (indexOf.call(qualifier, elem) > -1) !== not && elem.nodeType === 1;
  1938.         });
  1939.     }
  1940.     jQuery.filter = function(expr, elems, not) {
  1941.         var elem = elems[0];
  1942.         if (not) {
  1943.             expr = ":not(" + expr + ")";
  1944.         }
  1945.         if (elems.length === 1 && elem.nodeType === 1) {
  1946.             return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];
  1947.         }
  1948.         return jQuery.find.matches(expr, jQuery.grep(elems, function(elem) {
  1949.             return elem.nodeType === 1;
  1950.         }));
  1951.     }
  1952.     ;
  1953.     jQuery.fn.extend({
  1954.         find: function(selector) {
  1955.             var i, ret, len = this.length, self = this;
  1956.             if (typeof selector !== "string") {
  1957.                 return this.pushStack(jQuery(selector).filter(function() {
  1958.                     for (i = 0; i < len; i++) {
  1959.                         if (jQuery.contains(self[i], this)) {
  1960.                             return true;
  1961.                         }
  1962.                     }
  1963.                 }));
  1964.             }
  1965.             ret = this.pushStack([]);
  1966.             for (i = 0; i < len; i++) {
  1967.                 jQuery.find(selector, self[i], ret);
  1968.             }
  1969.             return len > 1 ? jQuery.uniqueSort(ret) : ret;
  1970.         },
  1971.         filter: function(selector) {
  1972.             return this.pushStack(winnow(this, selector || [], false));
  1973.         },
  1974.         not: function(selector) {
  1975.             return this.pushStack(winnow(this, selector || [], true));
  1976.         },
  1977.         is: function(selector) {
  1978.             return !!winnow(this, typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
  1979.         }
  1980.     });
  1981.     var rootjQuery, rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery.fn.init = function(selector, context, root) {
  1982.         var match, elem;
  1983.         if (!selector) {
  1984.             return this;
  1985.         }
  1986.         root = root || rootjQuery;
  1987.         if (typeof selector === "string") {
  1988.             if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
  1989.                 match = [null, selector, null];
  1990.             } else {
  1991.                 match = rquickExpr.exec(selector);
  1992.             }
  1993.             if (match && (match[1] || !context)) {
  1994.                 if (match[1]) {
  1995.                     context = context instanceof jQuery ? context[0] : context;
  1996.                     jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true));
  1997.                     if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
  1998.                         for (match in context) {
  1999.                             if (jQuery.isFunction(this[match])) {
  2000.                                 this[match](context[match]);
  2001.                             } else {
  2002.                                 this.attr(match, context[match]);
  2003.                             }
  2004.                         }
  2005.                     }
  2006.                     return this;
  2007.                 } else {
  2008.                     elem = document.getElementById(match[2]);
  2009.                     if (elem) {
  2010.                         this[0] = elem;
  2011.                         this.length = 1;
  2012.                     }
  2013.                     return this;
  2014.                 }
  2015.             } else if (!context || context.jquery) {
  2016.                 return (context || root).find(selector);
  2017.             } else {
  2018.                 return this.constructor(context).find(selector);
  2019.             }
  2020.         } else if (selector.nodeType) {
  2021.             this[0] = selector;
  2022.             this.length = 1;
  2023.             return this;
  2024.         } else if (jQuery.isFunction(selector)) {
  2025.             return root.ready !== undefined ? root.ready(selector) : selector(jQuery);
  2026.         }
  2027.         return jQuery.makeArray(selector, this);
  2028.     }
  2029.     ;
  2030.     init.prototype = jQuery.fn;
  2031.     rootjQuery = jQuery(document);
  2032.     var rparentsprev = /^(?:parents|prev(?:Until|All))/
  2033.       , guaranteedUnique = {
  2034.         children: true,
  2035.         contents: true,
  2036.         next: true,
  2037.         prev: true
  2038.     };
  2039.     jQuery.fn.extend({
  2040.         has: function(target) {
  2041.             var targets = jQuery(target, this)
  2042.               , l = targets.length;
  2043.             return this.filter(function() {
  2044.                 var i = 0;
  2045.                 for (; i < l; i++) {
  2046.                     if (jQuery.contains(this, targets[i])) {
  2047.                         return true;
  2048.                     }
  2049.                 }
  2050.             });
  2051.         },
  2052.         closest: function(selectors, context) {
  2053.             var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery(selectors);
  2054.             if (!rneedsContext.test(selectors)) {
  2055.                 for (; i < l; i++) {
  2056.                     for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
  2057.                         if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {
  2058.                             matched.push(cur);
  2059.                             break;
  2060.                         }
  2061.                     }
  2062.                 }
  2063.             }
  2064.             return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);
  2065.         },
  2066.         index: function(elem) {
  2067.             if (!elem) {
  2068.                 return (this[0] && this[0].parentNode) ? this.first().prevAll().length : -1;
  2069.             }
  2070.             if (typeof elem === "string") {
  2071.                 return indexOf.call(jQuery(elem), this[0]);
  2072.             }
  2073.             return indexOf.call(this, elem.jquery ? elem[0] : elem);
  2074.         },
  2075.         add: function(selector, context) {
  2076.             return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))));
  2077.         },
  2078.         addBack: function(selector) {
  2079.             return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));
  2080.         }
  2081.     });
  2082.     function sibling(cur, dir) {
  2083.         while ((cur = cur[dir]) && cur.nodeType !== 1) {}
  2084.         return cur;
  2085.     }
  2086.     jQuery.each({
  2087.         parent: function(elem) {
  2088.             var parent = elem.parentNode;
  2089.             return parent && parent.nodeType !== 11 ? parent : null;
  2090.         },
  2091.         parents: function(elem) {
  2092.             return dir(elem, "parentNode");
  2093.         },
  2094.         parentsUntil: function(elem, i, until) {
  2095.             return dir(elem, "parentNode", until);
  2096.         },
  2097.         next: function(elem) {
  2098.             return sibling(elem, "nextSibling");
  2099.         },
  2100.         prev: function(elem) {
  2101.             return sibling(elem, "previousSibling");
  2102.         },
  2103.         nextAll: function(elem) {
  2104.             return dir(elem, "nextSibling");
  2105.         },
  2106.         prevAll: function(elem) {
  2107.             return dir(elem, "previousSibling");
  2108.         },
  2109.         nextUntil: function(elem, i, until) {
  2110.             return dir(elem, "nextSibling", until);
  2111.         },
  2112.         prevUntil: function(elem, i, until) {
  2113.             return dir(elem, "previousSibling", until);
  2114.         },
  2115.         siblings: function(elem) {
  2116.             return siblings((elem.parentNode || {}).firstChild, elem);
  2117.         },
  2118.         children: function(elem) {
  2119.             return siblings(elem.firstChild);
  2120.         },
  2121.         contents: function(elem) {
  2122.             if (nodeName(elem, "iframe")) {
  2123.                 return elem.contentDocument;
  2124.             }
  2125.             if (nodeName(elem, "template")) {
  2126.                 elem = elem.content || elem;
  2127.             }
  2128.             return jQuery.merge([], elem.childNodes);
  2129.         }
  2130.     }, function(name, fn) {
  2131.         jQuery.fn[name] = function(until, selector) {
  2132.             var matched = jQuery.map(this, fn, until);
  2133.             if (name.slice(-5) !== "Until") {
  2134.                 selector = until;
  2135.             }
  2136.             if (selector && typeof selector === "string") {
  2137.                 matched = jQuery.filter(selector, matched);
  2138.             }
  2139.             if (this.length > 1) {
  2140.                 if (!guaranteedUnique[name]) {
  2141.                     jQuery.uniqueSort(matched);
  2142.                 }
  2143.                 if (rparentsprev.test(name)) {
  2144.                     matched.reverse();
  2145.                 }
  2146.             }
  2147.             return this.pushStack(matched);
  2148.         }
  2149.         ;
  2150.     });
  2151.     var rnothtmlwhite = (/[^\x20\t\r\n\f]+/g);
  2152.     function createOptions(options) {
  2153.         var object = {};
  2154.         jQuery.each(options.match(rnothtmlwhite) || [], function(_, flag) {
  2155.             object[flag] = true;
  2156.         });
  2157.         return object;
  2158.     }
  2159.     jQuery.Callbacks = function(options) {
  2160.         options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options);
  2161.         var firing, memory, fired, locked, list = [], queue = [], firingIndex = -1, fire = function() {
  2162.             locked = locked || options.once;
  2163.             fired = firing = true;
  2164.             for (; queue.length; firingIndex = -1) {
  2165.                 memory = queue.shift();
  2166.                 while (++firingIndex < list.length) {
  2167.                     if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {
  2168.                         firingIndex = list.length;
  2169.                         memory = false;
  2170.                     }
  2171.                 }
  2172.             }
  2173.             if (!options.memory) {
  2174.                 memory = false;
  2175.             }
  2176.             firing = false;
  2177.             if (locked) {
  2178.                 if (memory) {
  2179.                     list = [];
  2180.                 } else {
  2181.                     list = "";
  2182.                 }
  2183.             }
  2184.         }, self = {
  2185.             add: function() {
  2186.                 if (list) {
  2187.                     if (memory && !firing) {
  2188.                         firingIndex = list.length - 1;
  2189.                         queue.push(memory);
  2190.                     }
  2191.                     (function add(args) {
  2192.                         jQuery.each(args, function(_, arg) {
  2193.                             if (jQuery.isFunction(arg)) {
  2194.                                 if (!options.unique || !self.has(arg)) {
  2195.                                     list.push(arg);
  2196.                                 }
  2197.                             } else if (arg && arg.length && jQuery.type(arg) !== "string") {
  2198.                                 add(arg);
  2199.                             }
  2200.                         });
  2201.                     }
  2202.                     )(arguments);
  2203.                     if (memory && !firing) {
  2204.                         fire();
  2205.                     }
  2206.                 }
  2207.                 return this;
  2208.             },
  2209.             remove: function() {
  2210.                 jQuery.each(arguments, function(_, arg) {
  2211.                     var index;
  2212.                     while ((index = jQuery.inArray(arg, list, index)) > -1) {
  2213.                         list.splice(index, 1);
  2214.                         if (index <= firingIndex) {
  2215.                             firingIndex--;
  2216.                         }
  2217.                     }
  2218.                 });
  2219.                 return this;
  2220.             },
  2221.             has: function(fn) {
  2222.                 return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0;
  2223.             },
  2224.             empty: function() {
  2225.                 if (list) {
  2226.                     list = [];
  2227.                 }
  2228.                 return this;
  2229.             },
  2230.             disable: function() {
  2231.                 locked = queue = [];
  2232.                 list = memory = "";
  2233.                 return this;
  2234.             },
  2235.             disabled: function() {
  2236.                 return !list;
  2237.             },
  2238.             lock: function() {
  2239.                 locked = queue = [];
  2240.                 if (!memory && !firing) {
  2241.                     list = memory = "";
  2242.                 }
  2243.                 return this;
  2244.             },
  2245.             locked: function() {
  2246.                 return !!locked;
  2247.             },
  2248.             fireWith: function(context, args) {
  2249.                 if (!locked) {
  2250.                     args = args || [];
  2251.                     args = [context, args.slice ? args.slice() : args];
  2252.                     queue.push(args);
  2253.                     if (!firing) {
  2254.                         fire();
  2255.                     }
  2256.                 }
  2257.                 return this;
  2258.             },
  2259.             fire: function() {
  2260.                 self.fireWith(this, arguments);
  2261.                 return this;
  2262.             },
  2263.             fired: function() {
  2264.                 return !!fired;
  2265.             }
  2266.         };
  2267.         return self;
  2268.     }
  2269.     ;
  2270.     function Identity(v) {
  2271.         return v;
  2272.     }
  2273.     function Thrower(ex) {
  2274.         throw ex;
  2275.     }
  2276.     function adoptValue(value, resolve, reject, noValue) {
  2277.         var method;
  2278.         try {
  2279.             if (value && jQuery.isFunction((method = value.promise))) {
  2280.                 method.call(value).done(resolve).fail(reject);
  2281.             } else if (value && jQuery.isFunction((method = value.then))) {
  2282.                 method.call(value, resolve, reject);
  2283.             } else {
  2284.                 resolve.apply(undefined, [value].slice(noValue));
  2285.             }
  2286.         } catch (value) {
  2287.             reject.apply(undefined, [value]);
  2288.         }
  2289.     }
  2290.     jQuery.extend({
  2291.         Deferred: function(func) {
  2292.             var tuples = [["notify", "progress", jQuery.Callbacks("memory"), jQuery.Callbacks("memory"), 2], ["resolve", "done", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 0, "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), jQuery.Callbacks("once memory"), 1, "rejected"]]
  2293.               , state = "pending"
  2294.               , promise = {
  2295.                 state: function() {
  2296.                     return state;
  2297.                 },
  2298.                 always: function() {
  2299.                     deferred.done(arguments).fail(arguments);
  2300.                     return this;
  2301.                 },
  2302.                 "catch": function(fn) {
  2303.                     return promise.then(null, fn);
  2304.                 },
  2305.                 pipe: function() {
  2306.                     var fns = arguments;
  2307.                     return jQuery.Deferred(function(newDefer) {
  2308.                         jQuery.each(tuples, function(i, tuple) {
  2309.                             var fn = jQuery.isFunction(fns[tuple[4]]) && fns[tuple[4]];
  2310.                             deferred[tuple[1]](function() {
  2311.                                 var returned = fn && fn.apply(this, arguments);
  2312.                                 if (returned && jQuery.isFunction(returned.promise)) {
  2313.                                     returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
  2314.                                 } else {
  2315.                                     newDefer[tuple[0] + "With"](this, fn ? [returned] : arguments);
  2316.                                 }
  2317.                             });
  2318.                         });
  2319.                         fns = null;
  2320.                     }).promise();
  2321.                 },
  2322.                 then: function(onFulfilled, onRejected, onProgress) {
  2323.                     var maxDepth = 0;
  2324.                     function resolve(depth, deferred, handler, special) {
  2325.                         return function() {
  2326.                             var that = this
  2327.                               , args = arguments
  2328.                               , mightThrow = function() {
  2329.                                 var returned, then;
  2330.                                 if (depth < maxDepth) {
  2331.                                     return;
  2332.                                 }
  2333.                                 returned = handler.apply(that, args);
  2334.                                 if (returned === deferred.promise()) {
  2335.                                     throw new TypeError("Thenable self-resolution");
  2336.                                 }
  2337.                                 then = returned && (typeof returned === "object" || typeof returned === "function") && returned.then;
  2338.                                 if (jQuery.isFunction(then)) {
  2339.                                     if (special) {
  2340.                                         then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special));
  2341.                                     } else {
  2342.                                         maxDepth++;
  2343.                                         then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith));
  2344.                                     }
  2345.                                 } else {
  2346.                                     if (handler !== Identity) {
  2347.                                         that = undefined;
  2348.                                         args = [returned];
  2349.                                     }
  2350.                                     (special || deferred.resolveWith)(that, args);
  2351.                                 }
  2352.                             }
  2353.                               , process = special ? mightThrow : function() {
  2354.                                 try {
  2355.                                     mightThrow();
  2356.                                 } catch (e) {
  2357.                                     if (jQuery.Deferred.exceptionHook) {
  2358.                                         jQuery.Deferred.exceptionHook(e, process.stackTrace);
  2359.                                     }
  2360.                                     if (depth + 1 >= maxDepth) {
  2361.                                         if (handler !== Thrower) {
  2362.                                             that = undefined;
  2363.                                             args = [e];
  2364.                                         }
  2365.                                         deferred.rejectWith(that, args);
  2366.                                     }
  2367.                                 }
  2368.                             }
  2369.                             ;
  2370.                             if (depth) {
  2371.                                 process();
  2372.                             } else {
  2373.                                 if (jQuery.Deferred.getStackHook) {
  2374.                                     process.stackTrace = jQuery.Deferred.getStackHook();
  2375.                                 }
  2376.                                 window.setTimeout(process);
  2377.                             }
  2378.                         }
  2379.                         ;
  2380.                     }
  2381.                     return jQuery.Deferred(function(newDefer) {
  2382.                         tuples[0][3].add(resolve(0, newDefer, jQuery.isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith));
  2383.                         tuples[1][3].add(resolve(0, newDefer, jQuery.isFunction(onFulfilled) ? onFulfilled : Identity));
  2384.                         tuples[2][3].add(resolve(0, newDefer, jQuery.isFunction(onRejected) ? onRejected : Thrower));
  2385.                     }).promise();
  2386.                 },
  2387.                 promise: function(obj) {
  2388.                     return obj != null ? jQuery.extend(obj, promise) : promise;
  2389.                 }
  2390.             }
  2391.               , deferred = {};
  2392.             jQuery.each(tuples, function(i, tuple) {
  2393.                 var list = tuple[2]
  2394.                   , stateString = tuple[5];
  2395.                 promise[tuple[1]] = list.add;
  2396.                 if (stateString) {
  2397.                     list.add(function() {
  2398.                         state = stateString;
  2399.                     }, tuples[3 - i][2].disable, tuples[0][2].lock);
  2400.                 }
  2401.                 list.add(tuple[3].fire);
  2402.                 deferred[tuple[0]] = function() {
  2403.                     deferred[tuple[0] + "With"](this === deferred ? undefined : this, arguments);
  2404.                     return this;
  2405.                 }
  2406.                 ;
  2407.                 deferred[tuple[0] + "With"] = list.fireWith;
  2408.             });
  2409.             promise.promise(deferred);
  2410.             if (func) {
  2411.                 func.call(deferred, deferred);
  2412.             }
  2413.             return deferred;
  2414.         },
  2415.         when: function(singleValue) {
  2416.             var remaining = arguments.length
  2417.               , i = remaining
  2418.               , resolveContexts = Array(i)
  2419.               , resolveValues = slice.call(arguments)
  2420.               , master = jQuery.Deferred()
  2421.               , updateFunc = function(i) {
  2422.                 return function(value) {
  2423.                     resolveContexts[i] = this;
  2424.                     resolveValues[i] = arguments.length > 1 ? slice.call(arguments) : value;
  2425.                     if (!(--remaining)) {
  2426.                         master.resolveWith(resolveContexts, resolveValues);
  2427.                     }
  2428.                 }
  2429.                 ;
  2430.             };
  2431.             if (remaining <= 1) {
  2432.                 adoptValue(singleValue, master.done(updateFunc(i)).resolve, master.reject, !remaining);
  2433.                 if (master.state() === "pending" || jQuery.isFunction(resolveValues[i] && resolveValues[i].then)) {
  2434.                     return master.then();
  2435.                 }
  2436.             }
  2437.             while (i--) {
  2438.                 adoptValue(resolveValues[i], updateFunc(i), master.reject);
  2439.             }
  2440.             return master.promise();
  2441.         }
  2442.     });
  2443.     var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
  2444.     jQuery.Deferred.exceptionHook = function(error, stack) {
  2445.         if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {
  2446.             window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, stack);
  2447.         }
  2448.     }
  2449.     ;
  2450.     jQuery.readyException = function(error) {
  2451.         window.setTimeout(function() {
  2452.             throw error;
  2453.         });
  2454.     }
  2455.     ;
  2456.     var readyList = jQuery.Deferred();
  2457.     jQuery.fn.ready = function(fn) {
  2458.         readyList.then(fn).catch(function(error) {
  2459.             jQuery.readyException(error);
  2460.         });
  2461.         return this;
  2462.     }
  2463.     ;
  2464.     jQuery.extend({
  2465.         isReady: false,
  2466.         readyWait: 1,
  2467.         ready: function(wait) {
  2468.             if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
  2469.                 return;
  2470.             }
  2471.             jQuery.isReady = true;
  2472.             if (wait !== true && --jQuery.readyWait > 0) {
  2473.                 return;
  2474.             }
  2475.             readyList.resolveWith(document, [jQuery]);
  2476.         }
  2477.     });
  2478.     jQuery.ready.then = readyList.then;
  2479.     function completed() {
  2480.         document.removeEventListener("DOMContentLoaded", completed);
  2481.         window.removeEventListener("load", completed);
  2482.         jQuery.ready();
  2483.     }
  2484.     if (document.readyState === "complete" || (document.readyState !== "loading" && !document.documentElement.doScroll)) {
  2485.         window.setTimeout(jQuery.ready);
  2486.     } else {
  2487.         document.addEventListener("DOMContentLoaded", completed);
  2488.         window.addEventListener("load", completed);
  2489.     }
  2490.     var access = function(elems, fn, key, value, chainable, emptyGet, raw) {
  2491.         var i = 0
  2492.           , len = elems.length
  2493.           , bulk = key == null;
  2494.         if (jQuery.type(key) === "object") {
  2495.             chainable = true;
  2496.             for (i in key) {
  2497.                 access(elems, fn, i, key[i], true, emptyGet, raw);
  2498.             }
  2499.         } else if (value !== undefined) {
  2500.             chainable = true;
  2501.             if (!jQuery.isFunction(value)) {
  2502.                 raw = true;
  2503.             }
  2504.             if (bulk) {
  2505.                 if (raw) {
  2506.                     fn.call(elems, value);
  2507.                     fn = null;
  2508.                 } else {
  2509.                     bulk = fn;
  2510.                     fn = function(elem, key, value) {
  2511.                         return bulk.call(jQuery(elem), value);
  2512.                     }
  2513.                     ;
  2514.                 }
  2515.             }
  2516.             if (fn) {
  2517.                 for (; i < len; i++) {
  2518.                     fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
  2519.                 }
  2520.             }
  2521.         }
  2522.         if (chainable) {
  2523.             return elems;
  2524.         }
  2525.         if (bulk) {
  2526.             return fn.call(elems);
  2527.         }
  2528.         return len ? fn(elems[0], key) : emptyGet;
  2529.     };
  2530.     var acceptData = function(owner) {
  2531.         return owner.nodeType === 1 || owner.nodeType === 9 || !(+owner.nodeType);
  2532.     };
  2533.     function Data() {
  2534.         this.expando = jQuery.expando + Data.uid++;
  2535.     }
  2536.     Data.uid = 1;
  2537.     Data.prototype = {
  2538.         cache: function(owner) {
  2539.             var value = owner[this.expando];
  2540.             if (!value) {
  2541.                 value = {};
  2542.                 if (acceptData(owner)) {
  2543.                     if (owner.nodeType) {
  2544.                         owner[this.expando] = value;
  2545.                     } else {
  2546.                         Object.defineProperty(owner, this.expando, {
  2547.                             value: value,
  2548.                             configurable: true
  2549.                         });
  2550.                     }
  2551.                 }
  2552.             }
  2553.             return value;
  2554.         },
  2555.         set: function(owner, data, value) {
  2556.             var prop, cache = this.cache(owner);
  2557.             if (typeof data === "string") {
  2558.                 cache[jQuery.camelCase(data)] = value;
  2559.             } else {
  2560.                 for (prop in data) {
  2561.                     cache[jQuery.camelCase(prop)] = data[prop];
  2562.                 }
  2563.             }
  2564.             return cache;
  2565.         },
  2566.         get: function(owner, key) {
  2567.             return key === undefined ? this.cache(owner) : owner[this.expando] && owner[this.expando][jQuery.camelCase(key)];
  2568.         },
  2569.         access: function(owner, key, value) {
  2570.             if (key === undefined || ((key && typeof key === "string") && value === undefined)) {
  2571.                 return this.get(owner, key);
  2572.             }
  2573.             this.set(owner, key, value);
  2574.             return value !== undefined ? value : key;
  2575.         },
  2576.         remove: function(owner, key) {
  2577.             var i, cache = owner[this.expando];
  2578.             if (cache === undefined) {
  2579.                 return;
  2580.             }
  2581.             if (key !== undefined) {
  2582.                 if (Array.isArray(key)) {
  2583.                     key = key.map(jQuery.camelCase);
  2584.                 } else {
  2585.                     key = jQuery.camelCase(key);
  2586.                     key = key in cache ? [key] : (key.match(rnothtmlwhite) || []);
  2587.                 }
  2588.                 i = key.length;
  2589.                 while (i--) {
  2590.                     delete cache[key[i]];
  2591.                 }
  2592.             }
  2593.             if (key === undefined || jQuery.isEmptyObject(cache)) {
  2594.                 if (owner.nodeType) {
  2595.                     owner[this.expando] = undefined;
  2596.                 } else {
  2597.                     delete owner[this.expando];
  2598.                 }
  2599.             }
  2600.         },
  2601.         hasData: function(owner) {
  2602.             var cache = owner[this.expando];
  2603.             return cache !== undefined && !jQuery.isEmptyObject(cache);
  2604.         }
  2605.     };
  2606.     var dataPriv = new Data();
  2607.     var dataUser = new Data();
  2608.     var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/
  2609.       , rmultiDash = /[A-Z]/g;
  2610.     function getData(data) {
  2611.         if (data === "true") {
  2612.             return true;
  2613.         }
  2614.         if (data === "false") {
  2615.             return false;
  2616.         }
  2617.         if (data === "null") {
  2618.             return null;
  2619.         }
  2620.         if (data === +data + "") {
  2621.             return +data;
  2622.         }
  2623.         if (rbrace.test(data)) {
  2624.             return JSON.parse(data);
  2625.         }
  2626.         return data;
  2627.     }
  2628.     function dataAttr(elem, key, data) {
  2629.         var name;
  2630.         if (data === undefined && elem.nodeType === 1) {
  2631.             name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
  2632.             data = elem.getAttribute(name);
  2633.             if (typeof data === "string") {
  2634.                 try {
  2635.                     data = getData(data);
  2636.                 } catch (e) {}
  2637.                 dataUser.set(elem, key, data);
  2638.             } else {
  2639.                 data = undefined;
  2640.             }
  2641.         }
  2642.         return data;
  2643.     }
  2644.     jQuery.extend({
  2645.         hasData: function(elem) {
  2646.             return dataUser.hasData(elem) || dataPriv.hasData(elem);
  2647.         },
  2648.         data: function(elem, name, data) {
  2649.             return dataUser.access(elem, name, data);
  2650.         },
  2651.         removeData: function(elem, name) {
  2652.             dataUser.remove(elem, name);
  2653.         },
  2654.         _data: function(elem, name, data) {
  2655.             return dataPriv.access(elem, name, data);
  2656.         },
  2657.         _removeData: function(elem, name) {
  2658.             dataPriv.remove(elem, name);
  2659.         }
  2660.     });
  2661.     jQuery.fn.extend({
  2662.         data: function(key, value) {
  2663.             var i, name, data, elem = this[0], attrs = elem && elem.attributes;
  2664.             if (key === undefined) {
  2665.                 if (this.length) {
  2666.                     data = dataUser.get(elem);
  2667.                     if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
  2668.                         i = attrs.length;
  2669.                         while (i--) {
  2670.                             if (attrs[i]) {
  2671.                                 name = attrs[i].name;
  2672.                                 if (name.indexOf("data-") === 0) {
  2673.                                     name = jQuery.camelCase(name.slice(5));
  2674.                                     dataAttr(elem, name, data[name]);
  2675.                                 }
  2676.                             }
  2677.                         }
  2678.                         dataPriv.set(elem, "hasDataAttrs", true);
  2679.                     }
  2680.                 }
  2681.                 return data;
  2682.             }
  2683.             if (typeof key === "object") {
  2684.                 return this.each(function() {
  2685.                     dataUser.set(this, key);
  2686.                 });
  2687.             }
  2688.             return access(this, function(value) {
  2689.                 var data;
  2690.                 if (elem && value === undefined) {
  2691.                     data = dataUser.get(elem, key);
  2692.                     if (data !== undefined) {
  2693.                         return data;
  2694.                     }
  2695.                     data = dataAttr(elem, key);
  2696.                     if (data !== undefined) {
  2697.                         return data;
  2698.                     }
  2699.                     return;
  2700.                 }
  2701.                 this.each(function() {
  2702.                     dataUser.set(this, key, value);
  2703.                 });
  2704.             }, null, value, arguments.length > 1, null, true);
  2705.         },
  2706.         removeData: function(key) {
  2707.             return this.each(function() {
  2708.                 dataUser.remove(this, key);
  2709.             });
  2710.         }
  2711.     });
  2712.     jQuery.extend({
  2713.         queue: function(elem, type, data) {
  2714.             var queue;
  2715.             if (elem) {
  2716.                 type = (type || "fx") + "queue";
  2717.                 queue = dataPriv.get(elem, type);
  2718.                 if (data) {
  2719.                     if (!queue || Array.isArray(data)) {
  2720.                         queue = dataPriv.access(elem, type, jQuery.makeArray(data));
  2721.                     } else {
  2722.                         queue.push(data);
  2723.                     }
  2724.                 }
  2725.                 return queue || [];
  2726.             }
  2727.         },
  2728.         dequeue: function(elem, type) {
  2729.             type = type || "fx";
  2730.             var queue = jQuery.queue(elem, type)
  2731.               , startLength = queue.length
  2732.               , fn = queue.shift()
  2733.               , hooks = jQuery._queueHooks(elem, type)
  2734.               , next = function() {
  2735.                 jQuery.dequeue(elem, type);
  2736.             };
  2737.             if (fn === "inprogress") {
  2738.                 fn = queue.shift();
  2739.                 startLength--;
  2740.             }
  2741.             if (fn) {
  2742.                 if (type === "fx") {
  2743.                     queue.unshift("inprogress");
  2744.                 }
  2745.                 delete hooks.stop;
  2746.                 fn.call(elem, next, hooks);
  2747.             }
  2748.             if (!startLength && hooks) {
  2749.                 hooks.empty.fire();
  2750.             }
  2751.         },
  2752.         _queueHooks: function(elem, type) {
  2753.             var key = type + "queueHooks";
  2754.             return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
  2755.                 empty: jQuery.Callbacks("once memory").add(function() {
  2756.                     dataPriv.remove(elem, [type + "queue", key]);
  2757.                 })
  2758.             });
  2759.         }
  2760.     });
  2761.     jQuery.fn.extend({
  2762.         queue: function(type, data) {
  2763.             var setter = 2;
  2764.             if (typeof type !== "string") {
  2765.                 data = type;
  2766.                 type = "fx";
  2767.                 setter--;
  2768.             }
  2769.             if (arguments.length < setter) {
  2770.                 return jQuery.queue(this[0], type);
  2771.             }
  2772.             return data === undefined ? this : this.each(function() {
  2773.                 var queue = jQuery.queue(this, type, data);
  2774.                 jQuery._queueHooks(this, type);
  2775.                 if (type === "fx" && queue[0] !== "inprogress") {
  2776.                     jQuery.dequeue(this, type);
  2777.                 }
  2778.             });
  2779.         },
  2780.         dequeue: function(type) {
  2781.             return this.each(function() {
  2782.                 jQuery.dequeue(this, type);
  2783.             });
  2784.         },
  2785.         clearQueue: function(type) {
  2786.             return this.queue(type || "fx", []);
  2787.         },
  2788.         promise: function(type, obj) {
  2789.             var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() {
  2790.                 if (!(--count)) {
  2791.                     defer.resolveWith(elements, [elements]);
  2792.                 }
  2793.             };
  2794.             if (typeof type !== "string") {
  2795.                 obj = type;
  2796.                 type = undefined;
  2797.             }
  2798.             type = type || "fx";
  2799.             while (i--) {
  2800.                 tmp = dataPriv.get(elements[i], type + "queueHooks");
  2801.                 if (tmp && tmp.empty) {
  2802.                     count++;
  2803.                     tmp.empty.add(resolve);
  2804.                 }
  2805.             }
  2806.             resolve();
  2807.             return defer.promise(obj);
  2808.         }
  2809.     });
  2810.     var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;
  2811.     var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$","i");
  2812.     var cssExpand = ["Top", "Right", "Bottom", "Left"];
  2813.     var isHiddenWithinTree = function(elem, el) {
  2814.         elem = el || elem;
  2815.         return elem.style.display === "none" || elem.style.display === "" && jQuery.contains(elem.ownerDocument, elem) && jQuery.css(elem, "display") === "none";
  2816.     };
  2817.     var swap = function(elem, options, callback, args) {
  2818.         var ret, name, old = {};
  2819.         for (name in options) {
  2820.             old[name] = elem.style[name];
  2821.             elem.style[name] = options[name];
  2822.         }
  2823.         ret = callback.apply(elem, args || []);
  2824.         for (name in options) {
  2825.             elem.style[name] = old[name];
  2826.         }
  2827.         return ret;
  2828.     };
  2829.     function adjustCSS(elem, prop, valueParts, tween) {
  2830.         var adjusted, scale = 1, maxIterations = 20, currentValue = tween ? function() {
  2831.             return tween.cur();
  2832.         }
  2833.         : function() {
  2834.             return jQuery.css(elem, prop, "");
  2835.         }
  2836.         , initial = currentValue(), unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px"), initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery.css(elem, prop));
  2837.         if (initialInUnit && initialInUnit[3] !== unit) {
  2838.             unit = unit || initialInUnit[3];
  2839.             valueParts = valueParts || [];
  2840.             initialInUnit = +initial || 1;
  2841.             do {
  2842.                 scale = scale || ".5";
  2843.                 initialInUnit = initialInUnit / scale;
  2844.                 jQuery.style(elem, prop, initialInUnit + unit);
  2845.             } while (scale !== (scale = currentValue() / initial) && scale !== 1 && --maxIterations);
  2846.         }
  2847.         if (valueParts) {
  2848.             initialInUnit = +initialInUnit || +initial || 0;
  2849.             adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
  2850.             if (tween) {
  2851.                 tween.unit = unit;
  2852.                 tween.start = initialInUnit;
  2853.                 tween.end = adjusted;
  2854.             }
  2855.         }
  2856.         return adjusted;
  2857.     }
  2858.     var defaultDisplayMap = {};
  2859.     function getDefaultDisplay(elem) {
  2860.         var temp, doc = elem.ownerDocument, nodeName = elem.nodeName, display = defaultDisplayMap[nodeName];
  2861.         if (display) {
  2862.             return display;
  2863.         }
  2864.         temp = doc.body.appendChild(doc.createElement(nodeName));
  2865.         display = jQuery.css(temp, "display");
  2866.         temp.parentNode.removeChild(temp);
  2867.         if (display === "none") {
  2868.             display = "block";
  2869.         }
  2870.         defaultDisplayMap[nodeName] = display;
  2871.         return display;
  2872.     }
  2873.     function showHide(elements, show) {
  2874.         var display, elem, values = [], index = 0, length = elements.length;
  2875.         for (; index < length; index++) {
  2876.             elem = elements[index];
  2877.             if (!elem.style) {
  2878.                 continue;
  2879.             }
  2880.             display = elem.style.display;
  2881.             if (show) {
  2882.                 if (display === "none") {
  2883.                     values[index] = dataPriv.get(elem, "display") || null;
  2884.                     if (!values[index]) {
  2885.                         elem.style.display = "";
  2886.                     }
  2887.                 }
  2888.                 if (elem.style.display === "" && isHiddenWithinTree(elem)) {
  2889.                     values[index] = getDefaultDisplay(elem);
  2890.                 }
  2891.             } else {
  2892.                 if (display !== "none") {
  2893.                     values[index] = "none";
  2894.                     dataPriv.set(elem, "display", display);
  2895.                 }
  2896.             }
  2897.         }
  2898.         for (index = 0; index < length; index++) {
  2899.             if (values[index] != null) {
  2900.                 elements[index].style.display = values[index];
  2901.             }
  2902.         }
  2903.         return elements;
  2904.     }
  2905.     jQuery.fn.extend({
  2906.         show: function() {
  2907.             return showHide(this, true);
  2908.         },
  2909.         hide: function() {
  2910.             return showHide(this);
  2911.         },
  2912.         toggle: function(state) {
  2913.             if (typeof state === "boolean") {
  2914.                 return state ? this.show() : this.hide();
  2915.             }
  2916.             return this.each(function() {
  2917.                 if (isHiddenWithinTree(this)) {
  2918.                     jQuery(this).show();
  2919.                 } else {
  2920.                     jQuery(this).hide();
  2921.                 }
  2922.             });
  2923.         }
  2924.     });
  2925.     var rcheckableType = (/^(?:checkbox|radio)$/i);
  2926.     var rtagName = (/<([a-z][^\/\0>\x20\t\r\n\f]+)/i);
  2927.     var rscriptType = (/^$|\/(?:java|ecma)script/i);
  2928.     var wrapMap = {
  2929.         option: [1, "<select multiple='multiple'>", "</select>"],
  2930.         thead: [1, "<table>", "</table>"],
  2931.         col: [2, "<table><colgroup>", "</colgroup></table>"],
  2932.         tr: [2, "<table><tbody>", "</tbody></table>"],
  2933.         td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
  2934.         _default: [0, "", ""]
  2935.     };
  2936.     wrapMap.optgroup = wrapMap.option;
  2937.     wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  2938.     wrapMap.th = wrapMap.td;
  2939.     function getAll(context, tag) {
  2940.         var ret;
  2941.         if (typeof context.getElementsByTagName !== "undefined") {
  2942.             ret = context.getElementsByTagName(tag || "*");
  2943.         } else if (typeof context.querySelectorAll !== "undefined") {
  2944.             ret = context.querySelectorAll(tag || "*");
  2945.         } else {
  2946.             ret = [];
  2947.         }
  2948.         if (tag === undefined || tag && nodeName(context, tag)) {
  2949.             return jQuery.merge([context], ret);
  2950.         }
  2951.         return ret;
  2952.     }
  2953.     function setGlobalEval(elems, refElements) {
  2954.         var i = 0
  2955.           , l = elems.length;
  2956.         for (; i < l; i++) {
  2957.             dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
  2958.         }
  2959.     }
  2960.     var rhtml = /<|&#?\w+;/;
  2961.     function buildFragment(elems, context, scripts, selection, ignored) {
  2962.         var elem, tmp, tag, wrap, contains, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length;
  2963.         for (; i < l; i++) {
  2964.             elem = elems[i];
  2965.             if (elem || elem === 0) {
  2966.                 if (jQuery.type(elem) === "object") {
  2967.                     jQuery.merge(nodes, elem.nodeType ? [elem] : elem);
  2968.                 } else if (!rhtml.test(elem)) {
  2969.                     nodes.push(context.createTextNode(elem));
  2970.                 } else {
  2971.                     tmp = tmp || fragment.appendChild(context.createElement("div"));
  2972.                     tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
  2973.                     wrap = wrapMap[tag] || wrapMap._default;
  2974.                     tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];
  2975.                     j = wrap[0];
  2976.                     while (j--) {
  2977.                         tmp = tmp.lastChild;
  2978.                     }
  2979.                     jQuery.merge(nodes, tmp.childNodes);
  2980.                     tmp = fragment.firstChild;
  2981.                     tmp.textContent = "";
  2982.                 }
  2983.             }
  2984.         }
  2985.         fragment.textContent = "";
  2986.         i = 0;
  2987.         while ((elem = nodes[i++])) {
  2988.             if (selection && jQuery.inArray(elem, selection) > -1) {
  2989.                 if (ignored) {
  2990.                     ignored.push(elem);
  2991.                 }
  2992.                 continue;
  2993.             }
  2994.             contains = jQuery.contains(elem.ownerDocument, elem);
  2995.             tmp = getAll(fragment.appendChild(elem), "script");
  2996.             if (contains) {
  2997.                 setGlobalEval(tmp);
  2998.             }
  2999.             if (scripts) {
  3000.                 j = 0;
  3001.                 while ((elem = tmp[j++])) {
  3002.                     if (rscriptType.test(elem.type || "")) {
  3003.                         scripts.push(elem);
  3004.                     }
  3005.                 }
  3006.             }
  3007.         }
  3008.         return fragment;
  3009.     }
  3010.     (function() {
  3011.         var fragment = document.createDocumentFragment()
  3012.           , div = fragment.appendChild(document.createElement("div"))
  3013.           , input = document.createElement("input");
  3014.         input.setAttribute("type", "radio");
  3015.         input.setAttribute("checked", "checked");
  3016.         input.setAttribute("name", "t");
  3017.         div.appendChild(input);
  3018.         support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;
  3019.         div.innerHTML = "<textarea>x</textarea>";
  3020.         support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
  3021.     }
  3022.     )();
  3023.     var documentElement = document.documentElement;
  3024.     var rkeyEvent = /^key/
  3025.       , rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/
  3026.       , rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
  3027.     function returnTrue() {
  3028.         return true;
  3029.     }
  3030.     function returnFalse() {
  3031.         return false;
  3032.     }
  3033.     function safeActiveElement() {
  3034.         try {
  3035.             return document.activeElement;
  3036.         } catch (err) {}
  3037.     }
  3038.     function on(elem, types, selector, data, fn, one) {
  3039.         var origFn, type;
  3040.         if (typeof types === "object") {
  3041.             if (typeof selector !== "string") {
  3042.                 data = data || selector;
  3043.                 selector = undefined;
  3044.             }
  3045.             for (type in types) {
  3046.                 on(elem, type, selector, data, types[type], one);
  3047.             }
  3048.             return elem;
  3049.         }
  3050.         if (data == null && fn == null) {
  3051.             fn = selector;
  3052.             data = selector = undefined;
  3053.         } else if (fn == null) {
  3054.             if (typeof selector === "string") {
  3055.                 fn = data;
  3056.                 data = undefined;
  3057.             } else {
  3058.                 fn = data;
  3059.                 data = selector;
  3060.                 selector = undefined;
  3061.             }
  3062.         }
  3063.         if (fn === false) {
  3064.             fn = returnFalse;
  3065.         } else if (!fn) {
  3066.             return elem;
  3067.         }
  3068.         if (one === 1) {
  3069.             origFn = fn;
  3070.             fn = function(event) {
  3071.                 jQuery().off(event);
  3072.                 return origFn.apply(this, arguments);
  3073.             }
  3074.             ;
  3075.             fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
  3076.         }
  3077.         return elem.each(function() {
  3078.             jQuery.event.add(this, types, fn, data, selector);
  3079.         });
  3080.     }
  3081.     jQuery.event = {
  3082.         global: {},
  3083.         add: function(elem, types, handler, data, selector) {
  3084.             var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get(elem);
  3085.             if (!elemData) {
  3086.                 return;
  3087.             }
  3088.             if (handler.handler) {
  3089.                 handleObjIn = handler;
  3090.                 handler = handleObjIn.handler;
  3091.                 selector = handleObjIn.selector;
  3092.             }
  3093.             if (selector) {
  3094.                 jQuery.find.matchesSelector(documentElement, selector);
  3095.             }
  3096.             if (!handler.guid) {
  3097.                 handler.guid = jQuery.guid++;
  3098.             }
  3099.             if (!(events = elemData.events)) {
  3100.                 events = elemData.events = {};
  3101.             }
  3102.             if (!(eventHandle = elemData.handle)) {
  3103.                 eventHandle = elemData.handle = function(e) {
  3104.                     return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined;
  3105.                 }
  3106.                 ;
  3107.             }
  3108.             types = (types || "").match(rnothtmlwhite) || [""];
  3109.             t = types.length;
  3110.             while (t--) {
  3111.                 tmp = rtypenamespace.exec(types[t]) || [];
  3112.                 type = origType = tmp[1];
  3113.                 namespaces = (tmp[2] || "").split(".").sort();
  3114.                 if (!type) {
  3115.                     continue;
  3116.                 }
  3117.                 special = jQuery.event.special[type] || {};
  3118.                 type = (selector ? special.delegateType : special.bindType) || type;
  3119.                 special = jQuery.event.special[type] || {};
  3120.                 handleObj = jQuery.extend({
  3121.                     type: type,
  3122.                     origType: origType,
  3123.                     data: data,
  3124.                     handler: handler,
  3125.                     guid: handler.guid,
  3126.                     selector: selector,
  3127.                     needsContext: selector && jQuery.expr.match.needsContext.test(selector),
  3128.                     namespace: namespaces.join(".")
  3129.                 }, handleObjIn);
  3130.                 if (!(handlers = events[type])) {
  3131.                     handlers = events[type] = [];
  3132.                     handlers.delegateCount = 0;
  3133.                     if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
  3134.                         if (elem.addEventListener) {
  3135.                             elem.addEventListener(type, eventHandle);
  3136.                         }
  3137.                     }
  3138.                 }
  3139.                 if (special.add) {
  3140.                     special.add.call(elem, handleObj);
  3141.                     if (!handleObj.handler.guid) {
  3142.                         handleObj.handler.guid = handler.guid;
  3143.                     }
  3144.                 }
  3145.                 if (selector) {
  3146.                     handlers.splice(handlers.delegateCount++, 0, handleObj);
  3147.                 } else {
  3148.                     handlers.push(handleObj);
  3149.                 }
  3150.                 jQuery.event.global[type] = true;
  3151.             }
  3152.         },
  3153.         remove: function(elem, types, handler, selector, mappedTypes) {
  3154.             var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
  3155.             if (!elemData || !(events = elemData.events)) {
  3156.                 return;
  3157.             }
  3158.             types = (types || "").match(rnothtmlwhite) || [""];
  3159.             t = types.length;
  3160.             while (t--) {
  3161.                 tmp = rtypenamespace.exec(types[t]) || [];
  3162.                 type = origType = tmp[1];
  3163.                 namespaces = (tmp[2] || "").split(".").sort();
  3164.                 if (!type) {
  3165.                     for (type in events) {
  3166.                         jQuery.event.remove(elem, type + types[t], handler, selector, true);
  3167.                     }
  3168.                     continue;
  3169.                 }
  3170.                 special = jQuery.event.special[type] || {};
  3171.                 type = (selector ? special.delegateType : special.bindType) || type;
  3172.                 handlers = events[type] || [];
  3173.                 tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
  3174.                 origCount = j = handlers.length;
  3175.                 while (j--) {
  3176.                     handleObj = handlers[j];
  3177.                     if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
  3178.                         handlers.splice(j, 1);
  3179.                         if (handleObj.selector) {
  3180.                             handlers.delegateCount--;
  3181.                         }
  3182.                         if (special.remove) {
  3183.                             special.remove.call(elem, handleObj);
  3184.                         }
  3185.                     }
  3186.                 }
  3187.                 if (origCount && !handlers.length) {
  3188.                     if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
  3189.                         jQuery.removeEvent(elem, type, elemData.handle);
  3190.                     }
  3191.                     delete events[type];
  3192.                 }
  3193.             }
  3194.             if (jQuery.isEmptyObject(events)) {
  3195.                 dataPriv.remove(elem, "handle events");
  3196.             }
  3197.         },
  3198.         dispatch: function(nativeEvent) {
  3199.             var event = jQuery.event.fix(nativeEvent);
  3200.             var i, j, ret, matched, handleObj, handlerQueue, args = new Array(arguments.length), handlers = (dataPriv.get(this, "events") || {})[event.type] || [], special = jQuery.event.special[event.type] || {};
  3201.             args[0] = event;
  3202.             for (i = 1; i < arguments.length; i++) {
  3203.                 args[i] = arguments[i];
  3204.             }
  3205.             event.delegateTarget = this;
  3206.             if (special.preDispatch && special.preDispatch.call(this, event) === false) {
  3207.                 return;
  3208.             }
  3209.             handlerQueue = jQuery.event.handlers.call(this, event, handlers);
  3210.             i = 0;
  3211.             while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
  3212.                 event.currentTarget = matched.elem;
  3213.                 j = 0;
  3214.                 while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
  3215.                     if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) {
  3216.                         event.handleObj = handleObj;
  3217.                         event.data = handleObj.data;
  3218.                         ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
  3219.                         if (ret !== undefined) {
  3220.                             if ((event.result = ret) === false) {
  3221.                                 event.preventDefault();
  3222.                                 event.stopPropagation();
  3223.                             }
  3224.                         }
  3225.                     }
  3226.                 }
  3227.             }
  3228.             if (special.postDispatch) {
  3229.                 special.postDispatch.call(this, event);
  3230.             }
  3231.             return event.result;
  3232.         },
  3233.         handlers: function(event, handlers) {
  3234.             var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target;
  3235.             if (delegateCount && cur.nodeType && !(event.type === "click" && event.button >= 1)) {
  3236.                 for (; cur !== this; cur = cur.parentNode || this) {
  3237.                     if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) {
  3238.                         matchedHandlers = [];
  3239.                         matchedSelectors = {};
  3240.                         for (i = 0; i < delegateCount; i++) {
  3241.                             handleObj = handlers[i];
  3242.                             sel = handleObj.selector + " ";
  3243.                             if (matchedSelectors[sel] === undefined) {
  3244.                                 matchedSelectors[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length;
  3245.                             }
  3246.                             if (matchedSelectors[sel]) {
  3247.                                 matchedHandlers.push(handleObj);
  3248.                             }
  3249.                         }
  3250.                         if (matchedHandlers.length) {
  3251.                             handlerQueue.push({
  3252.                                 elem: cur,
  3253.                                 handlers: matchedHandlers
  3254.                             });
  3255.                         }
  3256.                     }
  3257.                 }
  3258.             }
  3259.             cur = this;
  3260.             if (delegateCount < handlers.length) {
  3261.                 handlerQueue.push({
  3262.                     elem: cur,
  3263.                     handlers: handlers.slice(delegateCount)
  3264.                 });
  3265.             }
  3266.             return handlerQueue;
  3267.         },
  3268.         addProp: function(name, hook) {
  3269.             Object.defineProperty(jQuery.Event.prototype, name, {
  3270.                 enumerable: true,
  3271.                 configurable: true,
  3272.                 get: jQuery.isFunction(hook) ? function() {
  3273.                     if (this.originalEvent) {
  3274.                         return hook(this.originalEvent);
  3275.                     }
  3276.                 }
  3277.                 : function() {
  3278.                     if (this.originalEvent) {
  3279.                         return this.originalEvent[name];
  3280.                     }
  3281.                 }
  3282.                 ,
  3283.                 set: function(value) {
  3284.                     Object.defineProperty(this, name, {
  3285.                         enumerable: true,
  3286.                         configurable: true,
  3287.                         writable: true,
  3288.                         value: value
  3289.                     });
  3290.                 }
  3291.             });
  3292.         },
  3293.         fix: function(originalEvent) {
  3294.             return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);
  3295.         },
  3296.         special: {
  3297.             load: {
  3298.                 noBubble: true
  3299.             },
  3300.             focus: {
  3301.                 trigger: function() {
  3302.                     if (this !== safeActiveElement() && this.focus) {
  3303.                         this.focus();
  3304.                         return false;
  3305.                     }
  3306.                 },
  3307.                 delegateType: "focusin"
  3308.             },
  3309.             blur: {
  3310.                 trigger: function() {
  3311.                     if (this === safeActiveElement() && this.blur) {
  3312.                         this.blur();
  3313.                         return false;
  3314.                     }
  3315.                 },
  3316.                 delegateType: "focusout"
  3317.             },
  3318.             click: {
  3319.                 trigger: function() {
  3320.                     if (rcheckableType.test(this.type) && this.click && nodeName(this, "input")) {
  3321.                         this.click();
  3322.                         return false;
  3323.                     }
  3324.                 },
  3325.                 _default: function(event) {
  3326.                     return nodeName(event.target, "a");
  3327.                 }
  3328.             },
  3329.             beforeunload: {
  3330.                 postDispatch: function(event) {
  3331.                     if (event.result !== undefined && event.originalEvent) {
  3332.                         event.originalEvent.returnValue = event.result;
  3333.                     }
  3334.                 }
  3335.             }
  3336.         }
  3337.     };
  3338.     jQuery.removeEvent = function(elem, type, handle) {
  3339.         if (elem.removeEventListener) {
  3340.             elem.removeEventListener(type, handle);
  3341.         }
  3342.     }
  3343.     ;
  3344.     jQuery.Event = function(src, props) {
  3345.         if (!(this instanceof jQuery.Event)) {
  3346.             return new jQuery.Event(src,props);
  3347.         }
  3348.         if (src && src.type) {
  3349.             this.originalEvent = src;
  3350.             this.type = src.type;
  3351.             this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && src.returnValue === false ? returnTrue : returnFalse;
  3352.             this.target = (src.target && src.target.nodeType === 3) ? src.target.parentNode : src.target;
  3353.             this.currentTarget = src.currentTarget;
  3354.             this.relatedTarget = src.relatedTarget;
  3355.         } else {
  3356.             this.type = src;
  3357.         }
  3358.         if (props) {
  3359.             jQuery.extend(this, props);
  3360.         }
  3361.         this.timeStamp = src && src.timeStamp || jQuery.now();
  3362.         this[jQuery.expando] = true;
  3363.     }
  3364.     ;
  3365.     jQuery.Event.prototype = {
  3366.         constructor: jQuery.Event,
  3367.         isDefaultPrevented: returnFalse,
  3368.         isPropagationStopped: returnFalse,
  3369.         isImmediatePropagationStopped: returnFalse,
  3370.         isSimulated: false,
  3371.         preventDefault: function() {
  3372.             var e = this.originalEvent;
  3373.             this.isDefaultPrevented = returnTrue;
  3374.             if (e && !this.isSimulated) {
  3375.                 e.preventDefault();
  3376.             }
  3377.         },
  3378.         stopPropagation: function() {
  3379.             var e = this.originalEvent;
  3380.             this.isPropagationStopped = returnTrue;
  3381.             if (e && !this.isSimulated) {
  3382.                 e.stopPropagation();
  3383.             }
  3384.         },
  3385.         stopImmediatePropagation: function() {
  3386.             var e = this.originalEvent;
  3387.             this.isImmediatePropagationStopped = returnTrue;
  3388.             if (e && !this.isSimulated) {
  3389.                 e.stopImmediatePropagation();
  3390.             }
  3391.             this.stopPropagation();
  3392.         }
  3393.     };
  3394.     jQuery.each({
  3395.         altKey: true,
  3396.         bubbles: true,
  3397.         cancelable: true,
  3398.         changedTouches: true,
  3399.         ctrlKey: true,
  3400.         detail: true,
  3401.         eventPhase: true,
  3402.         metaKey: true,
  3403.         pageX: true,
  3404.         pageY: true,
  3405.         shiftKey: true,
  3406.         view: true,
  3407.         "char": true,
  3408.         charCode: true,
  3409.         key: true,
  3410.         keyCode: true,
  3411.         button: true,
  3412.         buttons: true,
  3413.         clientX: true,
  3414.         clientY: true,
  3415.         offsetX: true,
  3416.         offsetY: true,
  3417.         pointerId: true,
  3418.         pointerType: true,
  3419.         screenX: true,
  3420.         screenY: true,
  3421.         targetTouches: true,
  3422.         toElement: true,
  3423.         touches: true,
  3424.         which: function(event) {
  3425.             var button = event.button;
  3426.             if (event.which == null && rkeyEvent.test(event.type)) {
  3427.                 return event.charCode != null ? event.charCode : event.keyCode;
  3428.             }
  3429.             if (!event.which && button !== undefined && rmouseEvent.test(event.type)) {
  3430.                 if (button & 1) {
  3431.                     return 1;
  3432.                 }
  3433.                 if (button & 2) {
  3434.                     return 3;
  3435.                 }
  3436.                 if (button & 4) {
  3437.                     return 2;
  3438.                 }
  3439.                 return 0;
  3440.             }
  3441.             return event.which;
  3442.         }
  3443.     }, jQuery.event.addProp);
  3444.     jQuery.each({
  3445.         mouseenter: "mouseover",
  3446.         mouseleave: "mouseout",
  3447.         pointerenter: "pointerover",
  3448.         pointerleave: "pointerout"
  3449.     }, function(orig, fix) {
  3450.         jQuery.event.special[orig] = {
  3451.             delegateType: fix,
  3452.             bindType: fix,
  3453.             handle: function(event) {
  3454.                 var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj;
  3455.                 if (!related || (related !== target && !jQuery.contains(target, related))) {
  3456.                     event.type = handleObj.origType;
  3457.                     ret = handleObj.handler.apply(this, arguments);
  3458.                     event.type = fix;
  3459.                 }
  3460.                 return ret;
  3461.             }
  3462.         };
  3463.     });
  3464.     jQuery.fn.extend({
  3465.         on: function(types, selector, data, fn) {
  3466.             return on(this, types, selector, data, fn);
  3467.         },
  3468.         one: function(types, selector, data, fn) {
  3469.             return on(this, types, selector, data, fn, 1);
  3470.         },
  3471.         off: function(types, selector, fn) {
  3472.             var handleObj, type;
  3473.             if (types && types.preventDefault && types.handleObj) {
  3474.                 handleObj = types.handleObj;
  3475.                 jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);
  3476.                 return this;
  3477.             }
  3478.             if (typeof types === "object") {
  3479.                 for (type in types) {
  3480.                     this.off(type, selector, types[type]);
  3481.                 }
  3482.                 return this;
  3483.             }
  3484.             if (selector === false || typeof selector === "function") {
  3485.                 fn = selector;
  3486.                 selector = undefined;
  3487.             }
  3488.             if (fn === false) {
  3489.                 fn = returnFalse;
  3490.             }
  3491.             return this.each(function() {
  3492.                 jQuery.event.remove(this, types, fn, selector);
  3493.             });
  3494.         }
  3495.     });
  3496.     var rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi
  3497.       , rnoInnerhtml = /<script|<style|<link/i
  3498.       , rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i
  3499.       , rscriptTypeMasked = /^true\/(.*)/
  3500.       , rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
  3501.     function manipulationTarget(elem, content) {
  3502.         if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) {
  3503.             return jQuery(">tbody", elem)[0] || elem;
  3504.         }
  3505.         return elem;
  3506.     }
  3507.     function disableScript(elem) {
  3508.         elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
  3509.         return elem;
  3510.     }
  3511.     function restoreScript(elem) {
  3512.         var match = rscriptTypeMasked.exec(elem.type);
  3513.         if (match) {
  3514.             elem.type = match[1];
  3515.         } else {
  3516.             elem.removeAttribute("type");
  3517.         }
  3518.         return elem;
  3519.     }
  3520.     function cloneCopyEvent(src, dest) {
  3521.         var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
  3522.         if (dest.nodeType !== 1) {
  3523.             return;
  3524.         }
  3525.         if (dataPriv.hasData(src)) {
  3526.             pdataOld = dataPriv.access(src);
  3527.             pdataCur = dataPriv.set(dest, pdataOld);
  3528.             events = pdataOld.events;
  3529.             if (events) {
  3530.                 delete pdataCur.handle;
  3531.                 pdataCur.events = {};
  3532.                 for (type in events) {
  3533.                     for (i = 0,
  3534.                     l = events[type].length; i < l; i++) {
  3535.                         jQuery.event.add(dest, type, events[type][i]);
  3536.                     }
  3537.                 }
  3538.             }
  3539.         }
  3540.         if (dataUser.hasData(src)) {
  3541.             udataOld = dataUser.access(src);
  3542.             udataCur = jQuery.extend({}, udataOld);
  3543.             dataUser.set(dest, udataCur);
  3544.         }
  3545.     }
  3546.     function fixInput(src, dest) {
  3547.         var nodeName = dest.nodeName.toLowerCase();
  3548.         if (nodeName === "input" && rcheckableType.test(src.type)) {
  3549.             dest.checked = src.checked;
  3550.         } else if (nodeName === "input" || nodeName === "textarea") {
  3551.             dest.defaultValue = src.defaultValue;
  3552.         }
  3553.     }
  3554.     function domManip(collection, args, callback, ignored) {
  3555.         args = concat.apply([], args);
  3556.         var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], isFunction = jQuery.isFunction(value);
  3557.         if (isFunction || (l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value))) {
  3558.             return collection.each(function(index) {
  3559.                 var self = collection.eq(index);
  3560.                 if (isFunction) {
  3561.                     args[0] = value.call(this, index, self.html());
  3562.                 }
  3563.                 domManip(self, args, callback, ignored);
  3564.             });
  3565.         }
  3566.         if (l) {
  3567.             fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
  3568.             first = fragment.firstChild;
  3569.             if (fragment.childNodes.length === 1) {
  3570.                 fragment = first;
  3571.             }
  3572.             if (first || ignored) {
  3573.                 scripts = jQuery.map(getAll(fragment, "script"), disableScript);
  3574.                 hasScripts = scripts.length;
  3575.                 for (; i < l; i++) {
  3576.                     node = fragment;
  3577.                     if (i !== iNoClone) {
  3578.                         node = jQuery.clone(node, true, true);
  3579.                         if (hasScripts) {
  3580.                             jQuery.merge(scripts, getAll(node, "script"));
  3581.                         }
  3582.                     }
  3583.                     callback.call(collection[i], node, i);
  3584.                 }
  3585.                 if (hasScripts) {
  3586.                     doc = scripts[scripts.length - 1].ownerDocument;
  3587.                     jQuery.map(scripts, restoreScript);
  3588.                     for (i = 0; i < hasScripts; i++) {
  3589.                         node = scripts[i];
  3590.                         if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) {
  3591.                             if (node.src) {
  3592.                                 if (jQuery._evalUrl) {
  3593.                                     jQuery._evalUrl(node.src);
  3594.                                 }
  3595.                             } else {
  3596.                                 DOMEval(node.textContent.replace(rcleanScript, ""), doc);
  3597.                             }
  3598.                         }
  3599.                     }
  3600.                 }
  3601.             }
  3602.         }
  3603.         return collection;
  3604.     }
  3605.     function remove(elem, selector, keepData) {
  3606.         var node, nodes = selector ? jQuery.filter(selector, elem) : elem, i = 0;
  3607.         for (; (node = nodes[i]) != null; i++) {
  3608.             if (!keepData && node.nodeType === 1) {
  3609.                 jQuery.cleanData(getAll(node));
  3610.             }
  3611.             if (node.parentNode) {
  3612.                 if (keepData && jQuery.contains(node.ownerDocument, node)) {
  3613.                     setGlobalEval(getAll(node, "script"));
  3614.                 }
  3615.                 node.parentNode.removeChild(node);
  3616.             }
  3617.         }
  3618.         return elem;
  3619.     }
  3620.     jQuery.extend({
  3621.         htmlPrefilter: function(html) {
  3622.             return html.replace(rxhtmlTag, "<$1></$2>");
  3623.         },
  3624.         clone: function(elem, dataAndEvents, deepDataAndEvents) {
  3625.             var i, l, srcElements, destElements, clone = elem.cloneNode(true), inPage = jQuery.contains(elem.ownerDocument, elem);
  3626.             if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
  3627.                 destElements = getAll(clone);
  3628.                 srcElements = getAll(elem);
  3629.                 for (i = 0,
  3630.                 l = srcElements.length; i < l; i++) {
  3631.                     fixInput(srcElements[i], destElements[i]);
  3632.                 }
  3633.             }
  3634.             if (dataAndEvents) {
  3635.                 if (deepDataAndEvents) {
  3636.                     srcElements = srcElements || getAll(elem);
  3637.                     destElements = destElements || getAll(clone);
  3638.                     for (i = 0,
  3639.                     l = srcElements.length; i < l; i++) {
  3640.                         cloneCopyEvent(srcElements[i], destElements[i]);
  3641.                     }
  3642.                 } else {
  3643.                     cloneCopyEvent(elem, clone);
  3644.                 }
  3645.             }
  3646.             destElements = getAll(clone, "script");
  3647.             if (destElements.length > 0) {
  3648.                 setGlobalEval(destElements, !inPage && getAll(elem, "script"));
  3649.             }
  3650.             return clone;
  3651.         },
  3652.         cleanData: function(elems) {
  3653.             var data, elem, type, special = jQuery.event.special, i = 0;
  3654.             for (; (elem = elems[i]) !== undefined; i++) {
  3655.                 if (acceptData(elem)) {
  3656.                     if ((data = elem[dataPriv.expando])) {
  3657.                         if (data.events) {
  3658.                             for (type in data.events) {
  3659.                                 if (special[type]) {
  3660.                                     jQuery.event.remove(elem, type);
  3661.                                 } else {
  3662.                                     jQuery.removeEvent(elem, type, data.handle);
  3663.                                 }
  3664.                             }
  3665.                         }
  3666.                         elem[dataPriv.expando] = undefined;
  3667.                     }
  3668.                     if (elem[dataUser.expando]) {
  3669.                         elem[dataUser.expando] = undefined;
  3670.                     }
  3671.                 }
  3672.             }
  3673.         }
  3674.     });
  3675.     jQuery.fn.extend({
  3676.         detach: function(selector) {
  3677.             return remove(this, selector, true);
  3678.         },
  3679.         remove: function(selector) {
  3680.             return remove(this, selector);
  3681.         },
  3682.         text: function(value) {
  3683.             return access(this, function(value) {
  3684.                 return value === undefined ? jQuery.text(this) : this.empty().each(function() {
  3685.                     if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
  3686.                         this.textContent = value;
  3687.                     }
  3688.                 });
  3689.             }, null, value, arguments.length);
  3690.         },
  3691.         append: function() {
  3692.             return domManip(this, arguments, function(elem) {
  3693.                 if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
  3694.                     var target = manipulationTarget(this, elem);
  3695.                     target.appendChild(elem);
  3696.                 }
  3697.             });
  3698.         },
  3699.         prepend: function() {
  3700.             return domManip(this, arguments, function(elem) {
  3701.                 if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
  3702.                     var target = manipulationTarget(this, elem);
  3703.                     target.insertBefore(elem, target.firstChild);
  3704.                 }
  3705.             });
  3706.         },
  3707.         before: function() {
  3708.             return domManip(this, arguments, function(elem) {
  3709.                 if (this.parentNode) {
  3710.                     this.parentNode.insertBefore(elem, this);
  3711.                 }
  3712.             });
  3713.         },
  3714.         after: function() {
  3715.             return domManip(this, arguments, function(elem) {
  3716.                 if (this.parentNode) {
  3717.                     this.parentNode.insertBefore(elem, this.nextSibling);
  3718.                 }
  3719.             });
  3720.         },
  3721.         empty: function() {
  3722.             var elem, i = 0;
  3723.             for (; (elem = this[i]) != null; i++) {
  3724.                 if (elem.nodeType === 1) {
  3725.                     jQuery.cleanData(getAll(elem, false));
  3726.                     elem.textContent = "";
  3727.                 }
  3728.             }
  3729.             return this;
  3730.         },
  3731.         clone: function(dataAndEvents, deepDataAndEvents) {
  3732.             dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
  3733.             deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
  3734.             return this.map(function() {
  3735.                 return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
  3736.             });
  3737.         },
  3738.         html: function(value) {
  3739.             return access(this, function(value) {
  3740.                 var elem = this[0] || {}
  3741.                   , i = 0
  3742.                   , l = this.length;
  3743.                 if (value === undefined && elem.nodeType === 1) {
  3744.                     return elem.innerHTML;
  3745.                 }
  3746.                 if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {
  3747.                     value = jQuery.htmlPrefilter(value);
  3748.                     try {
  3749.                         for (; i < l; i++) {
  3750.                             elem = this[i] || {};
  3751.                             if (elem.nodeType === 1) {
  3752.                                 jQuery.cleanData(getAll(elem, false));
  3753.                                 elem.innerHTML = value;
  3754.                             }
  3755.                         }
  3756.                         elem = 0;
  3757.                     } catch (e) {}
  3758.                 }
  3759.                 if (elem) {
  3760.                     this.empty().append(value);
  3761.                 }
  3762.             }, null, value, arguments.length);
  3763.         },
  3764.         replaceWith: function() {
  3765.             var ignored = [];
  3766.             return domManip(this, arguments, function(elem) {
  3767.                 var parent = this.parentNode;
  3768.                 if (jQuery.inArray(this, ignored) < 0) {
  3769.                     jQuery.cleanData(getAll(this));
  3770.                     if (parent) {
  3771.                         parent.replaceChild(elem, this);
  3772.                     }
  3773.                 }
  3774.             }, ignored);
  3775.         }
  3776.     });
  3777.     jQuery.each({
  3778.         appendTo: "append",
  3779.         prependTo: "prepend",
  3780.         insertBefore: "before",
  3781.         insertAfter: "after",
  3782.         replaceAll: "replaceWith"
  3783.     }, function(name, original) {
  3784.         jQuery.fn[name] = function(selector) {
  3785.             var elems, ret = [], insert = jQuery(selector), last = insert.length - 1, i = 0;
  3786.             for (; i <= last; i++) {
  3787.                 elems = i === last ? this : this.clone(true);
  3788.                 jQuery(insert[i])[original](elems);
  3789.                 push.apply(ret, elems.get());
  3790.             }
  3791.             return this.pushStack(ret);
  3792.         }
  3793.         ;
  3794.     });
  3795.     var rmargin = (/^margin/);
  3796.     var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$","i");
  3797.     var getStyles = function(elem) {
  3798.         var view = elem.ownerDocument.defaultView;
  3799.         if (!view || !view.opener) {
  3800.             view = window;
  3801.         }
  3802.         return view.getComputedStyle(elem);
  3803.     };
  3804.     (function() {
  3805.         function computeStyleTests() {
  3806.             if (!div) {
  3807.                 return;
  3808.             }
  3809.             div.style.cssText = "box-sizing:border-box;" + "position:relative;display:block;" + "margin:auto;border:1px;padding:1px;" + "top:1%;width:50%";
  3810.             div.innerHTML = "";
  3811.             documentElement.appendChild(container);
  3812.             var divStyle = window.getComputedStyle(div);
  3813.             pixelPositionVal = divStyle.top !== "1%";
  3814.             reliableMarginLeftVal = divStyle.marginLeft === "2px";
  3815.             boxSizingReliableVal = divStyle.width === "4px";
  3816.             div.style.marginRight = "50%";
  3817.             pixelMarginRightVal = divStyle.marginRight === "4px";
  3818.             documentElement.removeChild(container);
  3819.             div = null;
  3820.         }
  3821.         var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal, container = document.createElement("div"), div = document.createElement("div");
  3822.         if (!div.style) {
  3823.             return;
  3824.         }
  3825.         div.style.backgroundClip = "content-box";
  3826.         div.cloneNode(true).style.backgroundClip = "";
  3827.         support.clearCloneStyle = div.style.backgroundClip === "content-box";
  3828.         container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" + "padding:0;margin-top:1px;position:absolute";
  3829.         container.appendChild(div);
  3830.         jQuery.extend(support, {
  3831.             pixelPosition: function() {
  3832.                 computeStyleTests();
  3833.                 return pixelPositionVal;
  3834.             },
  3835.             boxSizingReliable: function() {
  3836.                 computeStyleTests();
  3837.                 return boxSizingReliableVal;
  3838.             },
  3839.             pixelMarginRight: function() {
  3840.                 computeStyleTests();
  3841.                 return pixelMarginRightVal;
  3842.             },
  3843.             reliableMarginLeft: function() {
  3844.                 computeStyleTests();
  3845.                 return reliableMarginLeftVal;
  3846.             }
  3847.         });
  3848.     }
  3849.     )();
  3850.     function curCSS(elem, name, computed) {
  3851.         var width, minWidth, maxWidth, ret, style = elem.style;
  3852.         computed = computed || getStyles(elem);
  3853.         if (computed) {
  3854.             ret = computed.getPropertyValue(name) || computed[name];
  3855.             if (ret === "" && !jQuery.contains(elem.ownerDocument, elem)) {
  3856.                 ret = jQuery.style(elem, name);
  3857.             }
  3858.             if (!support.pixelMarginRight() && rnumnonpx.test(ret) && rmargin.test(name)) {
  3859.                 width = style.width;
  3860.                 minWidth = style.minWidth;
  3861.                 maxWidth = style.maxWidth;
  3862.                 style.minWidth = style.maxWidth = style.width = ret;
  3863.                 ret = computed.width;
  3864.                 style.width = width;
  3865.                 style.minWidth = minWidth;
  3866.                 style.maxWidth = maxWidth;
  3867.             }
  3868.         }
  3869.         return ret !== undefined ? ret + "" : ret;
  3870.     }
  3871.     function addGetHookIf(conditionFn, hookFn) {
  3872.         return {
  3873.             get: function() {
  3874.                 if (conditionFn()) {
  3875.                     delete this.get;
  3876.                     return;
  3877.                 }
  3878.                 return (this.get = hookFn).apply(this, arguments);
  3879.             }
  3880.         };
  3881.     }
  3882.     var rdisplayswap = /^(none|table(?!-c[ea]).+)/
  3883.       , rcustomProp = /^--/
  3884.       , cssShow = {
  3885.         position: "absolute",
  3886.         visibility: "hidden",
  3887.         display: "block"
  3888.     }
  3889.       , cssNormalTransform = {
  3890.         letterSpacing: "0",
  3891.         fontWeight: "400"
  3892.     }
  3893.       , cssPrefixes = ["Webkit", "Moz", "ms"]
  3894.       , emptyStyle = document.createElement("div").style;
  3895.     function vendorPropName(name) {
  3896.         if (name in emptyStyle) {
  3897.             return name;
  3898.         }
  3899.         var capName = name[0].toUpperCase() + name.slice(1)
  3900.           , i = cssPrefixes.length;
  3901.         while (i--) {
  3902.             name = cssPrefixes[i] + capName;
  3903.             if (name in emptyStyle) {
  3904.                 return name;
  3905.             }
  3906.         }
  3907.     }
  3908.     function finalPropName(name) {
  3909.         var ret = jQuery.cssProps[name];
  3910.         if (!ret) {
  3911.             ret = jQuery.cssProps[name] = vendorPropName(name) || name;
  3912.         }
  3913.         return ret;
  3914.     }
  3915.     function setPositiveNumber(elem, value, subtract) {
  3916.         var matches = rcssNum.exec(value);
  3917.         return matches ? Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") : value;
  3918.     }
  3919.     function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
  3920.         var i, val = 0;
  3921.         if (extra === (isBorderBox ? "border" : "content")) {
  3922.             i = 4;
  3923.         } else {
  3924.             i = name === "width" ? 1 : 0;
  3925.         }
  3926.         for (; i < 4; i += 2) {
  3927.             if (extra === "margin") {
  3928.                 val += jQuery.css(elem, extra + cssExpand[i], true, styles);
  3929.             }
  3930.             if (isBorderBox) {
  3931.                 if (extra === "content") {
  3932.                     val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  3933.                 }
  3934.                 if (extra !== "margin") {
  3935.                     val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  3936.                 }
  3937.             } else {
  3938.                 val += jQuery.css(elem, "padding" + cssExpand[i], true, styles);
  3939.                 if (extra !== "padding") {
  3940.                     val += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
  3941.                 }
  3942.             }
  3943.         }
  3944.         return val;
  3945.     }
  3946.     function getWidthOrHeight(elem, name, extra) {
  3947.         var valueIsBorderBox, styles = getStyles(elem), val = curCSS(elem, name, styles), isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box";
  3948.         if (rnumnonpx.test(val)) {
  3949.             return val;
  3950.         }
  3951.         valueIsBorderBox = isBorderBox && (support.boxSizingReliable() || val === elem.style[name]);
  3952.         val = parseFloat(val) || 0;
  3953.         return (val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles)) + "px";
  3954.     }
  3955.     jQuery.extend({
  3956.         cssHooks: {
  3957.             opacity: {
  3958.                 get: function(elem, computed) {
  3959.                     if (computed) {
  3960.                         var ret = curCSS(elem, "opacity");
  3961.                         return ret === "" ? "1" : ret;
  3962.                     }
  3963.                 }
  3964.             }
  3965.         },
  3966.         cssNumber: {
  3967.             "animationIterationCount": true,
  3968.             "columnCount": true,
  3969.             "fillOpacity": true,
  3970.             "flexGrow": true,
  3971.             "flexShrink": true,
  3972.             "fontWeight": true,
  3973.             "lineHeight": true,
  3974.             "opacity": true,
  3975.             "order": true,
  3976.             "orphans": true,
  3977.             "widows": true,
  3978.             "zIndex": true,
  3979.             "zoom": true
  3980.         },
  3981.         cssProps: {
  3982.             "float": "cssFloat"
  3983.         },
  3984.         style: function(elem, name, value, extra) {
  3985.             if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
  3986.                 return;
  3987.             }
  3988.             var ret, type, hooks, origName = jQuery.camelCase(name), isCustomProp = rcustomProp.test(name), style = elem.style;
  3989.             if (!isCustomProp) {
  3990.                 name = finalPropName(origName);
  3991.             }
  3992.             hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
  3993.             if (value !== undefined) {
  3994.                 type = typeof value;
  3995.                 if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
  3996.                     value = adjustCSS(elem, name, ret);
  3997.                     type = "number";
  3998.                 }
  3999.                 if (value == null || value !== value) {
  4000.                     return;
  4001.                 }
  4002.                 if (type === "number") {
  4003.                     value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px");
  4004.                 }
  4005.                 if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
  4006.                     style[name] = "inherit";
  4007.                 }
  4008.                 if (!hooks || !("set"in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
  4009.                     if (isCustomProp) {
  4010.                         style.setProperty(name, value);
  4011.                     } else {
  4012.                         style[name] = value;
  4013.                     }
  4014.                 }
  4015.             } else {
  4016.                 if (hooks && "get"in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
  4017.                     return ret;
  4018.                 }
  4019.                 return style[name];
  4020.             }
  4021.         },
  4022.         css: function(elem, name, extra, styles) {
  4023.             var val, num, hooks, origName = jQuery.camelCase(name), isCustomProp = rcustomProp.test(name);
  4024.             if (!isCustomProp) {
  4025.                 name = finalPropName(origName);
  4026.             }
  4027.             hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
  4028.             if (hooks && "get"in hooks) {
  4029.                 val = hooks.get(elem, true, extra);
  4030.             }
  4031.             if (val === undefined) {
  4032.                 val = curCSS(elem, name, styles);
  4033.             }
  4034.             if (val === "normal" && name in cssNormalTransform) {
  4035.                 val = cssNormalTransform[name];
  4036.             }
  4037.             if (extra === "" || extra) {
  4038.                 num = parseFloat(val);
  4039.                 return extra === true || isFinite(num) ? num || 0 : val;
  4040.             }
  4041.             return val;
  4042.         }
  4043.     });
  4044.     jQuery.each(["height", "width"], function(i, name) {
  4045.         jQuery.cssHooks[name] = {
  4046.             get: function(elem, computed, extra) {
  4047.                 if (computed) {
  4048.                     return rdisplayswap.test(jQuery.css(elem, "display")) && (!elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function() {
  4049.                         return getWidthOrHeight(elem, name, extra);
  4050.                     }) : getWidthOrHeight(elem, name, extra);
  4051.                 }
  4052.             },
  4053.             set: function(elem, value, extra) {
  4054.                 var matches, styles = extra && getStyles(elem), subtract = extra && augmentWidthOrHeight(elem, name, extra, jQuery.css(elem, "boxSizing", false, styles) === "border-box", styles);
  4055.                 if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") {
  4056.                     elem.style[name] = value;
  4057.                     value = jQuery.css(elem, name);
  4058.                 }
  4059.                 return setPositiveNumber(elem, value, subtract);
  4060.             }
  4061.         };
  4062.     });
  4063.     jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function(elem, computed) {
  4064.         if (computed) {
  4065.             return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, {
  4066.                 marginLeft: 0
  4067.             }, function() {
  4068.                 return elem.getBoundingClientRect().left;
  4069.             })) + "px";
  4070.         }
  4071.     });
  4072.     jQuery.each({
  4073.         margin: "",
  4074.         padding: "",
  4075.         border: "Width"
  4076.     }, function(prefix, suffix) {
  4077.         jQuery.cssHooks[prefix + suffix] = {
  4078.             expand: function(value) {
  4079.                 var i = 0
  4080.                   , expanded = {}
  4081.                   , parts = typeof value === "string" ? value.split(" ") : [value];
  4082.                 for (; i < 4; i++) {
  4083.                     expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
  4084.                 }
  4085.                 return expanded;
  4086.             }
  4087.         };
  4088.         if (!rmargin.test(prefix)) {
  4089.             jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
  4090.         }
  4091.     });
  4092.     jQuery.fn.extend({
  4093.         css: function(name, value) {
  4094.             return access(this, function(elem, name, value) {
  4095.                 var styles, len, map = {}, i = 0;
  4096.                 if (Array.isArray(name)) {
  4097.                     styles = getStyles(elem);
  4098.                     len = name.length;
  4099.                     for (; i < len; i++) {
  4100.                         map[name[i]] = jQuery.css(elem, name[i], false, styles);
  4101.                     }
  4102.                     return map;
  4103.                 }
  4104.                 return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);
  4105.             }, name, value, arguments.length > 1);
  4106.         }
  4107.     });
  4108.     function Tween(elem, options, prop, end, easing) {
  4109.         return new Tween.prototype.init(elem,options,prop,end,easing);
  4110.     }
  4111.     jQuery.Tween = Tween;
  4112.     Tween.prototype = {
  4113.         constructor: Tween,
  4114.         init: function(elem, options, prop, end, easing, unit) {
  4115.             this.elem = elem;
  4116.             this.prop = prop;
  4117.             this.easing = easing || jQuery.easing._default;
  4118.             this.options = options;
  4119.             this.start = this.now = this.cur();
  4120.             this.end = end;
  4121.             this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
  4122.         },
  4123.         cur: function() {
  4124.             var hooks = Tween.propHooks[this.prop];
  4125.             return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
  4126.         },
  4127.         run: function(percent) {
  4128.             var eased, hooks = Tween.propHooks[this.prop];
  4129.             if (this.options.duration) {
  4130.                 this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration);
  4131.             } else {
  4132.                 this.pos = eased = percent;
  4133.             }
  4134.             this.now = (this.end - this.start) * eased + this.start;
  4135.             if (this.options.step) {
  4136.                 this.options.step.call(this.elem, this.now, this);
  4137.             }
  4138.             if (hooks && hooks.set) {
  4139.                 hooks.set(this);
  4140.             } else {
  4141.                 Tween.propHooks._default.set(this);
  4142.             }
  4143.             return this;
  4144.         }
  4145.     };
  4146.     Tween.prototype.init.prototype = Tween.prototype;
  4147.     Tween.propHooks = {
  4148.         _default: {
  4149.             get: function(tween) {
  4150.                 var result;
  4151.                 if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
  4152.                     return tween.elem[tween.prop];
  4153.                 }
  4154.                 result = jQuery.css(tween.elem, tween.prop, "");
  4155.                 return !result || result === "auto" ? 0 : result;
  4156.             },
  4157.             set: function(tween) {
  4158.                 if (jQuery.fx.step[tween.prop]) {
  4159.                     jQuery.fx.step[tween.prop](tween);
  4160.                 } else if (tween.elem.nodeType === 1 && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) {
  4161.                     jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
  4162.                 } else {
  4163.                     tween.elem[tween.prop] = tween.now;
  4164.                 }
  4165.             }
  4166.         }
  4167.     };
  4168.     Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
  4169.         set: function(tween) {
  4170.             if (tween.elem.nodeType && tween.elem.parentNode) {
  4171.                 tween.elem[tween.prop] = tween.now;
  4172.             }
  4173.         }
  4174.     };
  4175.     jQuery.easing = {
  4176.         linear: function(p) {
  4177.             return p;
  4178.         },
  4179.         swing: function(p) {
  4180.             return 0.5 - Math.cos(p * Math.PI) / 2;
  4181.         },
  4182.         _default: "swing"
  4183.     };
  4184.     jQuery.fx = Tween.prototype.init;
  4185.     jQuery.fx.step = {};
  4186.     var fxNow, inProgress, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/;
  4187.     function schedule() {
  4188.         if (inProgress) {
  4189.             if (document.hidden === false && window.requestAnimationFrame) {
  4190.                 window.requestAnimationFrame(schedule);
  4191.             } else {
  4192.                 window.setTimeout(schedule, jQuery.fx.interval);
  4193.             }
  4194.             jQuery.fx.tick();
  4195.         }
  4196.     }
  4197.     function createFxNow() {
  4198.         window.setTimeout(function() {
  4199.             fxNow = undefined;
  4200.         });
  4201.         return (fxNow = jQuery.now());
  4202.     }
  4203.     function genFx(type, includeWidth) {
  4204.         var which, i = 0, attrs = {
  4205.             height: type
  4206.         };
  4207.         includeWidth = includeWidth ? 1 : 0;
  4208.         for (; i < 4; i += 2 - includeWidth) {
  4209.             which = cssExpand[i];
  4210.             attrs["margin" + which] = attrs["padding" + which] = type;
  4211.         }
  4212.         if (includeWidth) {
  4213.             attrs.opacity = attrs.width = type;
  4214.         }
  4215.         return attrs;
  4216.     }
  4217.     function createTween(value, prop, animation) {
  4218.         var tween, collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]), index = 0, length = collection.length;
  4219.         for (; index < length; index++) {
  4220.             if ((tween = collection[index].call(animation, prop, value))) {
  4221.                 return tween;
  4222.             }
  4223.         }
  4224.     }
  4225.     function defaultPrefilter(elem, props, opts) {
  4226.         var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, isBox = "width"in props || "height"in props, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHiddenWithinTree(elem), dataShow = dataPriv.get(elem, "fxshow");
  4227.         if (!opts.queue) {
  4228.             hooks = jQuery._queueHooks(elem, "fx");
  4229.             if (hooks.unqueued == null) {
  4230.                 hooks.unqueued = 0;
  4231.                 oldfire = hooks.empty.fire;
  4232.                 hooks.empty.fire = function() {
  4233.                     if (!hooks.unqueued) {
  4234.                         oldfire();
  4235.                     }
  4236.                 }
  4237.                 ;
  4238.             }
  4239.             hooks.unqueued++;
  4240.             anim.always(function() {
  4241.                 anim.always(function() {
  4242.                     hooks.unqueued--;
  4243.                     if (!jQuery.queue(elem, "fx").length) {
  4244.                         hooks.empty.fire();
  4245.                     }
  4246.                 });
  4247.             });
  4248.         }
  4249.         for (prop in props) {
  4250.             value = props[prop];
  4251.             if (rfxtypes.test(value)) {
  4252.                 delete props[prop];
  4253.                 toggle = toggle || value === "toggle";
  4254.                 if (value === (hidden ? "hide" : "show")) {
  4255.                     if (value === "show" && dataShow && dataShow[prop] !== undefined) {
  4256.                         hidden = true;
  4257.                     } else {
  4258.                         continue;
  4259.                     }
  4260.                 }
  4261.                 orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
  4262.             }
  4263.         }
  4264.         propTween = !jQuery.isEmptyObject(props);
  4265.         if (!propTween && jQuery.isEmptyObject(orig)) {
  4266.             return;
  4267.         }
  4268.         if (isBox && elem.nodeType === 1) {
  4269.             opts.overflow = [style.overflow, style.overflowX, style.overflowY];
  4270.             restoreDisplay = dataShow && dataShow.display;
  4271.             if (restoreDisplay == null) {
  4272.                 restoreDisplay = dataPriv.get(elem, "display");
  4273.             }
  4274.             display = jQuery.css(elem, "display");
  4275.             if (display === "none") {
  4276.                 if (restoreDisplay) {
  4277.                     display = restoreDisplay;
  4278.                 } else {
  4279.                     showHide([elem], true);
  4280.                     restoreDisplay = elem.style.display || restoreDisplay;
  4281.                     display = jQuery.css(elem, "display");
  4282.                     showHide([elem]);
  4283.                 }
  4284.             }
  4285.             if (display === "inline" || display === "inline-block" && restoreDisplay != null) {
  4286.                 if (jQuery.css(elem, "float") === "none") {
  4287.                     if (!propTween) {
  4288.                         anim.done(function() {
  4289.                             style.display = restoreDisplay;
  4290.                         });
  4291.                         if (restoreDisplay == null) {
  4292.                             display = style.display;
  4293.                             restoreDisplay = display === "none" ? "" : display;
  4294.                         }
  4295.                     }
  4296.                     style.display = "inline-block";
  4297.                 }
  4298.             }
  4299.         }
  4300.         if (opts.overflow) {
  4301.             style.overflow = "hidden";
  4302.             anim.always(function() {
  4303.                 style.overflow = opts.overflow[0];
  4304.                 style.overflowX = opts.overflow[1];
  4305.                 style.overflowY = opts.overflow[2];
  4306.             });
  4307.         }
  4308.         propTween = false;
  4309.         for (prop in orig) {
  4310.             if (!propTween) {
  4311.                 if (dataShow) {
  4312.                     if ("hidden"in dataShow) {
  4313.                         hidden = dataShow.hidden;
  4314.                     }
  4315.                 } else {
  4316.                     dataShow = dataPriv.access(elem, "fxshow", {
  4317.                         display: restoreDisplay
  4318.                     });
  4319.                 }
  4320.                 if (toggle) {
  4321.                     dataShow.hidden = !hidden;
  4322.                 }
  4323.                 if (hidden) {
  4324.                     showHide([elem], true);
  4325.                 }
  4326.                 anim.done(function() {
  4327.                     if (!hidden) {
  4328.                         showHide([elem]);
  4329.                     }
  4330.                     dataPriv.remove(elem, "fxshow");
  4331.                     for (prop in orig) {
  4332.                         jQuery.style(elem, prop, orig[prop]);
  4333.                     }
  4334.                 });
  4335.             }
  4336.             propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
  4337.             if (!(prop in dataShow)) {
  4338.                 dataShow[prop] = propTween.start;
  4339.                 if (hidden) {
  4340.                     propTween.end = propTween.start;
  4341.                     propTween.start = 0;
  4342.                 }
  4343.             }
  4344.         }
  4345.     }
  4346.     function propFilter(props, specialEasing) {
  4347.         var index, name, easing, value, hooks;
  4348.         for (index in props) {
  4349.             name = jQuery.camelCase(index);
  4350.             easing = specialEasing[name];
  4351.             value = props[index];
  4352.             if (Array.isArray(value)) {
  4353.                 easing = value[1];
  4354.                 value = props[index] = value[0];
  4355.             }
  4356.             if (index !== name) {
  4357.                 props[name] = value;
  4358.                 delete props[index];
  4359.             }
  4360.             hooks = jQuery.cssHooks[name];
  4361.             if (hooks && "expand"in hooks) {
  4362.                 value = hooks.expand(value);
  4363.                 delete props[name];
  4364.                 for (index in value) {
  4365.                     if (!(index in props)) {
  4366.                         props[index] = value[index];
  4367.                         specialEasing[index] = easing;
  4368.                     }
  4369.                 }
  4370.             } else {
  4371.                 specialEasing[name] = easing;
  4372.             }
  4373.         }
  4374.     }
  4375.     function Animation(elem, properties, options) {
  4376.         var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery.Deferred().always(function() {
  4377.             delete tick.elem;
  4378.         }), tick = function() {
  4379.             if (stopped) {
  4380.                 return false;
  4381.             }
  4382.             var currentTime = fxNow || createFxNow()
  4383.               , remaining = Math.max(0, animation.startTime + animation.duration - currentTime)
  4384.               , temp = remaining / animation.duration || 0
  4385.               , percent = 1 - temp
  4386.               , index = 0
  4387.               , length = animation.tweens.length;
  4388.             for (; index < length; index++) {
  4389.                 animation.tweens[index].run(percent);
  4390.             }
  4391.             deferred.notifyWith(elem, [animation, percent, remaining]);
  4392.             if (percent < 1 && length) {
  4393.                 return remaining;
  4394.             }
  4395.             if (!length) {
  4396.                 deferred.notifyWith(elem, [animation, 1, 0]);
  4397.             }
  4398.             deferred.resolveWith(elem, [animation]);
  4399.             return false;
  4400.         }, animation = deferred.promise({
  4401.             elem: elem,
  4402.             props: jQuery.extend({}, properties),
  4403.             opts: jQuery.extend(true, {
  4404.                 specialEasing: {},
  4405.                 easing: jQuery.easing._default
  4406.             }, options),
  4407.             originalProperties: properties,
  4408.             originalOptions: options,
  4409.             startTime: fxNow || createFxNow(),
  4410.             duration: options.duration,
  4411.             tweens: [],
  4412.             createTween: function(prop, end) {
  4413.                 var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
  4414.                 animation.tweens.push(tween);
  4415.                 return tween;
  4416.             },
  4417.             stop: function(gotoEnd) {
  4418.                 var index = 0
  4419.                   , length = gotoEnd ? animation.tweens.length : 0;
  4420.                 if (stopped) {
  4421.                     return this;
  4422.                 }
  4423.                 stopped = true;
  4424.                 for (; index < length; index++) {
  4425.                     animation.tweens[index].run(1);
  4426.                 }
  4427.                 if (gotoEnd) {
  4428.                     deferred.notifyWith(elem, [animation, 1, 0]);
  4429.                     deferred.resolveWith(elem, [animation, gotoEnd]);
  4430.                 } else {
  4431.                     deferred.rejectWith(elem, [animation, gotoEnd]);
  4432.                 }
  4433.                 return this;
  4434.             }
  4435.         }), props = animation.props;
  4436.         propFilter(props, animation.opts.specialEasing);
  4437.         for (; index < length; index++) {
  4438.             result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
  4439.             if (result) {
  4440.                 if (jQuery.isFunction(result.stop)) {
  4441.                     jQuery._queueHooks(animation.elem, animation.opts.queue).stop = jQuery.proxy(result.stop, result);
  4442.                 }
  4443.                 return result;
  4444.             }
  4445.         }
  4446.         jQuery.map(props, createTween, animation);
  4447.         if (jQuery.isFunction(animation.opts.start)) {
  4448.             animation.opts.start.call(elem, animation);
  4449.         }
  4450.         animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
  4451.         jQuery.fx.timer(jQuery.extend(tick, {
  4452.             elem: elem,
  4453.             anim: animation,
  4454.             queue: animation.opts.queue
  4455.         }));
  4456.         return animation;
  4457.     }
  4458.     jQuery.Animation = jQuery.extend(Animation, {
  4459.         tweeners: {
  4460.             "*": [function(prop, value) {
  4461.                 var tween = this.createTween(prop, value);
  4462.                 adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
  4463.                 return tween;
  4464.             }
  4465.             ]
  4466.         },
  4467.         tweener: function(props, callback) {
  4468.             if (jQuery.isFunction(props)) {
  4469.                 callback = props;
  4470.                 props = ["*"];
  4471.             } else {
  4472.                 props = props.match(rnothtmlwhite);
  4473.             }
  4474.             var prop, index = 0, length = props.length;
  4475.             for (; index < length; index++) {
  4476.                 prop = props[index];
  4477.                 Animation.tweeners[prop] = Animation.tweeners[prop] || [];
  4478.                 Animation.tweeners[prop].unshift(callback);
  4479.             }
  4480.         },
  4481.         prefilters: [defaultPrefilter],
  4482.         prefilter: function(callback, prepend) {
  4483.             if (prepend) {
  4484.                 Animation.prefilters.unshift(callback);
  4485.             } else {
  4486.                 Animation.prefilters.push(callback);
  4487.             }
  4488.         }
  4489.     });
  4490.     jQuery.speed = function(speed, easing, fn) {
  4491.         var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
  4492.             complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
  4493.             duration: speed,
  4494.             easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
  4495.         };
  4496.         if (jQuery.fx.off) {
  4497.             opt.duration = 0;
  4498.         } else {
  4499.             if (typeof opt.duration !== "number") {
  4500.                 if (opt.duration in jQuery.fx.speeds) {
  4501.                     opt.duration = jQuery.fx.speeds[opt.duration];
  4502.                 } else {
  4503.                     opt.duration = jQuery.fx.speeds._default;
  4504.                 }
  4505.             }
  4506.         }
  4507.         if (opt.queue == null || opt.queue === true) {
  4508.             opt.queue = "fx";
  4509.         }
  4510.         opt.old = opt.complete;
  4511.         opt.complete = function() {
  4512.             if (jQuery.isFunction(opt.old)) {
  4513.                 opt.old.call(this);
  4514.             }
  4515.             if (opt.queue) {
  4516.                 jQuery.dequeue(this, opt.queue);
  4517.             }
  4518.         }
  4519.         ;
  4520.         return opt;
  4521.     }
  4522.     ;
  4523.     jQuery.fn.extend({
  4524.         fadeTo: function(speed, to, easing, callback) {
  4525.             return this.filter(isHiddenWithinTree).css("opacity", 0).show().end().animate({
  4526.                 opacity: to
  4527.             }, speed, easing, callback);
  4528.         },
  4529.         animate: function(prop, speed, easing, callback) {
  4530.             var empty = jQuery.isEmptyObject(prop)
  4531.               , optall = jQuery.speed(speed, easing, callback)
  4532.               , doAnimation = function() {
  4533.                 var anim = Animation(this, jQuery.extend({}, prop), optall);
  4534.                 if (empty || dataPriv.get(this, "finish")) {
  4535.                     anim.stop(true);
  4536.                 }
  4537.             };
  4538.             doAnimation.finish = doAnimation;
  4539.             return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
  4540.         },
  4541.         stop: function(type, clearQueue, gotoEnd) {
  4542.             var stopQueue = function(hooks) {
  4543.                 var stop = hooks.stop;
  4544.                 delete hooks.stop;
  4545.                 stop(gotoEnd);
  4546.             };
  4547.             if (typeof type !== "string") {
  4548.                 gotoEnd = clearQueue;
  4549.                 clearQueue = type;
  4550.                 type = undefined;
  4551.             }
  4552.             if (clearQueue && type !== false) {
  4553.                 this.queue(type || "fx", []);
  4554.             }
  4555.             return this.each(function() {
  4556.                 var dequeue = true
  4557.                   , index = type != null && type + "queueHooks"
  4558.                   , timers = jQuery.timers
  4559.                   , data = dataPriv.get(this);
  4560.                 if (index) {
  4561.                     if (data[index] && data[index].stop) {
  4562.                         stopQueue(data[index]);
  4563.                     }
  4564.                 } else {
  4565.                     for (index in data) {
  4566.                         if (data[index] && data[index].stop && rrun.test(index)) {
  4567.                             stopQueue(data[index]);
  4568.                         }
  4569.                     }
  4570.                 }
  4571.                 for (index = timers.length; index--; ) {
  4572.                     if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
  4573.                         timers[index].anim.stop(gotoEnd);
  4574.                         dequeue = false;
  4575.                         timers.splice(index, 1);
  4576.                     }
  4577.                 }
  4578.                 if (dequeue || !gotoEnd) {
  4579.                     jQuery.dequeue(this, type);
  4580.                 }
  4581.             });
  4582.         },
  4583.         finish: function(type) {
  4584.             if (type !== false) {
  4585.                 type = type || "fx";
  4586.             }
  4587.             return this.each(function() {
  4588.                 var index, data = dataPriv.get(this), queue = data[type + "queue"], hooks = data[type + "queueHooks"], timers = jQuery.timers, length = queue ? queue.length : 0;
  4589.                 data.finish = true;
  4590.                 jQuery.queue(this, type, []);
  4591.                 if (hooks && hooks.stop) {
  4592.                     hooks.stop.call(this, true);
  4593.                 }
  4594.                 for (index = timers.length; index--; ) {
  4595.                     if (timers[index].elem === this && timers[index].queue === type) {
  4596.                         timers[index].anim.stop(true);
  4597.                         timers.splice(index, 1);
  4598.                     }
  4599.                 }
  4600.                 for (index = 0; index < length; index++) {
  4601.                     if (queue[index] && queue[index].finish) {
  4602.                         queue[index].finish.call(this);
  4603.                     }
  4604.                 }
  4605.                 delete data.finish;
  4606.             });
  4607.         }
  4608.     });
  4609.     jQuery.each(["toggle", "show", "hide"], function(i, name) {
  4610.         var cssFn = jQuery.fn[name];
  4611.         jQuery.fn[name] = function(speed, easing, callback) {
  4612.             return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);
  4613.         }
  4614.         ;
  4615.     });
  4616.     jQuery.each({
  4617.         slideDown: genFx("show"),
  4618.         slideUp: genFx("hide"),
  4619.         slideToggle: genFx("toggle"),
  4620.         fadeIn: {
  4621.             opacity: "show"
  4622.         },
  4623.         fadeOut: {
  4624.             opacity: "hide"
  4625.         },
  4626.         fadeToggle: {
  4627.             opacity: "toggle"
  4628.         }
  4629.     }, function(name, props) {
  4630.         jQuery.fn[name] = function(speed, easing, callback) {
  4631.             return this.animate(props, speed, easing, callback);
  4632.         }
  4633.         ;
  4634.     });
  4635.     jQuery.timers = [];
  4636.     jQuery.fx.tick = function() {
  4637.         var timer, i = 0, timers = jQuery.timers;
  4638.         fxNow = jQuery.now();
  4639.         for (; i < timers.length; i++) {
  4640.             timer = timers[i];
  4641.             if (!timer() && timers[i] === timer) {
  4642.                 timers.splice(i--, 1);
  4643.             }
  4644.         }
  4645.         if (!timers.length) {
  4646.             jQuery.fx.stop();
  4647.         }
  4648.         fxNow = undefined;
  4649.     }
  4650.     ;
  4651.     jQuery.fx.timer = function(timer) {
  4652.         jQuery.timers.push(timer);
  4653.         jQuery.fx.start();
  4654.     }
  4655.     ;
  4656.     jQuery.fx.interval = 13;
  4657.     jQuery.fx.start = function() {
  4658.         if (inProgress) {
  4659.             return;
  4660.         }
  4661.         inProgress = true;
  4662.         schedule();
  4663.     }
  4664.     ;
  4665.     jQuery.fx.stop = function() {
  4666.         inProgress = null;
  4667.     }
  4668.     ;
  4669.     jQuery.fx.speeds = {
  4670.         slow: 600,
  4671.         fast: 200,
  4672.         _default: 400
  4673.     };
  4674.     jQuery.fn.delay = function(time, type) {
  4675.         time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
  4676.         type = type || "fx";
  4677.         return this.queue(type, function(next, hooks) {
  4678.             var timeout = window.setTimeout(next, time);
  4679.             hooks.stop = function() {
  4680.                 window.clearTimeout(timeout);
  4681.             }
  4682.             ;
  4683.         });
  4684.     }
  4685.     ;
  4686.     (function() {
  4687.         var input = document.createElement("input")
  4688.           , select = document.createElement("select")
  4689.           , opt = select.appendChild(document.createElement("option"));
  4690.         input.type = "checkbox";
  4691.         support.checkOn = input.value !== "";
  4692.         support.optSelected = opt.selected;
  4693.         input = document.createElement("input");
  4694.         input.value = "t";
  4695.         input.type = "radio";
  4696.         support.radioValue = input.value === "t";
  4697.     }
  4698.     )();
  4699.     var boolHook, attrHandle = jQuery.expr.attrHandle;
  4700.     jQuery.fn.extend({
  4701.         attr: function(name, value) {
  4702.             return access(this, jQuery.attr, name, value, arguments.length > 1);
  4703.         },
  4704.         removeAttr: function(name) {
  4705.             return this.each(function() {
  4706.                 jQuery.removeAttr(this, name);
  4707.             });
  4708.         }
  4709.     });
  4710.     jQuery.extend({
  4711.         attr: function(elem, name, value) {
  4712.             var ret, hooks, nType = elem.nodeType;
  4713.             if (nType === 3 || nType === 8 || nType === 2) {
  4714.                 return;
  4715.             }
  4716.             if (typeof elem.getAttribute === "undefined") {
  4717.                 return jQuery.prop(elem, name, value);
  4718.             }
  4719.             if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
  4720.                 hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined);
  4721.             }
  4722.             if (value !== undefined) {
  4723.                 if (value === null) {
  4724.                     jQuery.removeAttr(elem, name);
  4725.                     return;
  4726.                 }
  4727.                 if (hooks && "set"in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
  4728.                     return ret;
  4729.                 }
  4730.                 elem.setAttribute(name, value + "");
  4731.                 return value;
  4732.             }
  4733.             if (hooks && "get"in hooks && (ret = hooks.get(elem, name)) !== null) {
  4734.                 return ret;
  4735.             }
  4736.             ret = jQuery.find.attr(elem, name);
  4737.             return ret == null ? undefined : ret;
  4738.         },
  4739.         attrHooks: {
  4740.             type: {
  4741.                 set: function(elem, value) {
  4742.                     if (!support.radioValue && value === "radio" && nodeName(elem, "input")) {
  4743.                         var val = elem.value;
  4744.                         elem.setAttribute("type", value);
  4745.                         if (val) {
  4746.                             elem.value = val;
  4747.                         }
  4748.                         return value;
  4749.                     }
  4750.                 }
  4751.             }
  4752.         },
  4753.         removeAttr: function(elem, value) {
  4754.             var name, i = 0, attrNames = value && value.match(rnothtmlwhite);
  4755.             if (attrNames && elem.nodeType === 1) {
  4756.                 while ((name = attrNames[i++])) {
  4757.                     elem.removeAttribute(name);
  4758.                 }
  4759.             }
  4760.         }
  4761.     });
  4762.     boolHook = {
  4763.         set: function(elem, value, name) {
  4764.             if (value === false) {
  4765.                 jQuery.removeAttr(elem, name);
  4766.             } else {
  4767.                 elem.setAttribute(name, name);
  4768.             }
  4769.             return name;
  4770.         }
  4771.     };
  4772.     jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function(i, name) {
  4773.         var getter = attrHandle[name] || jQuery.find.attr;
  4774.         attrHandle[name] = function(elem, name, isXML) {
  4775.             var ret, handle, lowercaseName = name.toLowerCase();
  4776.             if (!isXML) {
  4777.                 handle = attrHandle[lowercaseName];
  4778.                 attrHandle[lowercaseName] = ret;
  4779.                 ret = getter(elem, name, isXML) != null ? lowercaseName : null;
  4780.                 attrHandle[lowercaseName] = handle;
  4781.             }
  4782.             return ret;
  4783.         }
  4784.         ;
  4785.     });
  4786.     var rfocusable = /^(?:input|select|textarea|button)$/i
  4787.       , rclickable = /^(?:a|area)$/i;
  4788.     jQuery.fn.extend({
  4789.         prop: function(name, value) {
  4790.             return access(this, jQuery.prop, name, value, arguments.length > 1);
  4791.         },
  4792.         removeProp: function(name) {
  4793.             return this.each(function() {
  4794.                 delete this[jQuery.propFix[name] || name];
  4795.             });
  4796.         }
  4797.     });
  4798.     jQuery.extend({
  4799.         prop: function(elem, name, value) {
  4800.             var ret, hooks, nType = elem.nodeType;
  4801.             if (nType === 3 || nType === 8 || nType === 2) {
  4802.                 return;
  4803.             }
  4804.             if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
  4805.                 name = jQuery.propFix[name] || name;
  4806.                 hooks = jQuery.propHooks[name];
  4807.             }
  4808.             if (value !== undefined) {
  4809.                 if (hooks && "set"in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
  4810.                     return ret;
  4811.                 }
  4812.                 return (elem[name] = value);
  4813.             }
  4814.             if (hooks && "get"in hooks && (ret = hooks.get(elem, name)) !== null) {
  4815.                 return ret;
  4816.             }
  4817.             return elem[name];
  4818.         },
  4819.         propHooks: {
  4820.             tabIndex: {
  4821.                 get: function(elem) {
  4822.                     var tabindex = jQuery.find.attr(elem, "tabindex");
  4823.                     if (tabindex) {
  4824.                         return parseInt(tabindex, 10);
  4825.                     }
  4826.                     if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {
  4827.                         return 0;
  4828.                     }
  4829.                     return -1;
  4830.                 }
  4831.             }
  4832.         },
  4833.         propFix: {
  4834.             "for": "htmlFor",
  4835.             "class": "className"
  4836.         }
  4837.     });
  4838.     if (!support.optSelected) {
  4839.         jQuery.propHooks.selected = {
  4840.             get: function(elem) {
  4841.                 var parent = elem.parentNode;
  4842.                 if (parent && parent.parentNode) {
  4843.                     parent.parentNode.selectedIndex;
  4844.                 }
  4845.                 return null;
  4846.             },
  4847.             set: function(elem) {
  4848.                 var parent = elem.parentNode;
  4849.                 if (parent) {
  4850.                     parent.selectedIndex;
  4851.                     if (parent.parentNode) {
  4852.                         parent.parentNode.selectedIndex;
  4853.                     }
  4854.                 }
  4855.             }
  4856.         };
  4857.     }
  4858.     jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function() {
  4859.         jQuery.propFix[this.toLowerCase()] = this;
  4860.     });
  4861.     function stripAndCollapse(value) {
  4862.         var tokens = value.match(rnothtmlwhite) || [];
  4863.         return tokens.join(" ");
  4864.     }
  4865.     function getClass(elem) {
  4866.         return elem.getAttribute && elem.getAttribute("class") || "";
  4867.     }
  4868.     jQuery.fn.extend({
  4869.         addClass: function(value) {
  4870.             var classes, elem, cur, curValue, clazz, j, finalValue, i = 0;
  4871.             if (jQuery.isFunction(value)) {
  4872.                 return this.each(function(j) {
  4873.                     jQuery(this).addClass(value.call(this, j, getClass(this)));
  4874.                 });
  4875.             }
  4876.             if (typeof value === "string" && value) {
  4877.                 classes = value.match(rnothtmlwhite) || [];
  4878.                 while ((elem = this[i++])) {
  4879.                     curValue = getClass(elem);
  4880.                     cur = elem.nodeType === 1 && (" " + stripAndCollapse(curValue) + " ");
  4881.                     if (cur) {
  4882.                         j = 0;
  4883.                         while ((clazz = classes[j++])) {
  4884.                             if (cur.indexOf(" " + clazz + " ") < 0) {
  4885.                                 cur += clazz + " ";
  4886.                             }
  4887.                         }
  4888.                         finalValue = stripAndCollapse(cur);
  4889.                         if (curValue !== finalValue) {
  4890.                             elem.setAttribute("class", finalValue);
  4891.                         }
  4892.                     }
  4893.                 }
  4894.             }
  4895.             return this;
  4896.         },
  4897.         removeClass: function(value) {
  4898.             var classes, elem, cur, curValue, clazz, j, finalValue, i = 0;
  4899.             if (jQuery.isFunction(value)) {
  4900.                 return this.each(function(j) {
  4901.                     jQuery(this).removeClass(value.call(this, j, getClass(this)));
  4902.                 });
  4903.             }
  4904.             if (!arguments.length) {
  4905.                 return this.attr("class", "");
  4906.             }
  4907.             if (typeof value === "string" && value) {
  4908.                 classes = value.match(rnothtmlwhite) || [];
  4909.                 while ((elem = this[i++])) {
  4910.                     curValue = getClass(elem);
  4911.                     cur = elem.nodeType === 1 && (" " + stripAndCollapse(curValue) + " ");
  4912.                     if (cur) {
  4913.                         j = 0;
  4914.                         while ((clazz = classes[j++])) {
  4915.                             while (cur.indexOf(" " + clazz + " ") > -1) {
  4916.                                 cur = cur.replace(" " + clazz + " ", " ");
  4917.                             }
  4918.                         }
  4919.                         finalValue = stripAndCollapse(cur);
  4920.                         if (curValue !== finalValue) {
  4921.                             elem.setAttribute("class", finalValue);
  4922.                         }
  4923.                     }
  4924.                 }
  4925.             }
  4926.             return this;
  4927.         },
  4928.         toggleClass: function(value, stateVal) {
  4929.             var type = typeof value;
  4930.             if (typeof stateVal === "boolean" && type === "string") {
  4931.                 return stateVal ? this.addClass(value) : this.removeClass(value);
  4932.             }
  4933.             if (jQuery.isFunction(value)) {
  4934.                 return this.each(function(i) {
  4935.                     jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);
  4936.                 });
  4937.             }
  4938.             return this.each(function() {
  4939.                 var className, i, self, classNames;
  4940.                 if (type === "string") {
  4941.                     i = 0;
  4942.                     self = jQuery(this);
  4943.                     classNames = value.match(rnothtmlwhite) || [];
  4944.                     while ((className = classNames[i++])) {
  4945.                         if (self.hasClass(className)) {
  4946.                             self.removeClass(className);
  4947.                         } else {
  4948.                             self.addClass(className);
  4949.                         }
  4950.                     }
  4951.                 } else if (value === undefined || type === "boolean") {
  4952.                     className = getClass(this);
  4953.                     if (className) {
  4954.                         dataPriv.set(this, "__className__", className);
  4955.                     }
  4956.                     if (this.setAttribute) {
  4957.                         this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || "");
  4958.                     }
  4959.                 }
  4960.             });
  4961.         },
  4962.         hasClass: function(selector) {
  4963.             var className, elem, i = 0;
  4964.             className = " " + selector + " ";
  4965.             while ((elem = this[i++])) {
  4966.                 if (elem.nodeType === 1 && (" " + stripAndCollapse(getClass(elem)) + " ").indexOf(className) > -1) {
  4967.                     return true;
  4968.                 }
  4969.             }
  4970.             return false;
  4971.         }
  4972.     });
  4973.     var rreturn = /\r/g;
  4974.     jQuery.fn.extend({
  4975.         val: function(value) {
  4976.             var hooks, ret, isFunction, elem = this[0];
  4977.             if (!arguments.length) {
  4978.                 if (elem) {
  4979.                     hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
  4980.                     if (hooks && "get"in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
  4981.                         return ret;
  4982.                     }
  4983.                     ret = elem.value;
  4984.                     if (typeof ret === "string") {
  4985.                         return ret.replace(rreturn, "");
  4986.                     }
  4987.                     return ret == null ? "" : ret;
  4988.                 }
  4989.                 return;
  4990.             }
  4991.             isFunction = jQuery.isFunction(value);
  4992.             return this.each(function(i) {
  4993.                 var val;
  4994.                 if (this.nodeType !== 1) {
  4995.                     return;
  4996.                 }
  4997.                 if (isFunction) {
  4998.                     val = value.call(this, i, jQuery(this).val());
  4999.                 } else {
  5000.                     val = value;
  5001.                 }
  5002.                 if (val == null) {
  5003.                     val = "";
  5004.                 } else if (typeof val === "number") {
  5005.                     val += "";
  5006.                 } else if (Array.isArray(val)) {
  5007.                     val = jQuery.map(val, function(value) {
  5008.                         return value == null ? "" : value + "";
  5009.                     });
  5010.                 }
  5011.                 hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
  5012.                 if (!hooks || !("set"in hooks) || hooks.set(this, val, "value") === undefined) {
  5013.                     this.value = val;
  5014.                 }
  5015.             });
  5016.         }
  5017.     });
  5018.     jQuery.extend({
  5019.         valHooks: {
  5020.             option: {
  5021.                 get: function(elem) {
  5022.                     var val = jQuery.find.attr(elem, "value");
  5023.                     return val != null ? val : stripAndCollapse(jQuery.text(elem));
  5024.                 }
  5025.             },
  5026.             select: {
  5027.                 get: function(elem) {
  5028.                     var value, option, i, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one", values = one ? null : [], max = one ? index + 1 : options.length;
  5029.                     if (index < 0) {
  5030.                         i = max;
  5031.                     } else {
  5032.                         i = one ? index : 0;
  5033.                     }
  5034.                     for (; i < max; i++) {
  5035.                         option = options[i];
  5036.                         if ((option.selected || i === index) && !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, "optgroup"))) {
  5037.                             value = jQuery(option).val();
  5038.                             if (one) {
  5039.                                 return value;
  5040.                             }
  5041.                             values.push(value);
  5042.                         }
  5043.                     }
  5044.                     return values;
  5045.                 },
  5046.                 set: function(elem, value) {
  5047.                     var optionSet, option, options = elem.options, values = jQuery.makeArray(value), i = options.length;
  5048.                     while (i--) {
  5049.                         option = options[i];
  5050.                         if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {
  5051.                             optionSet = true;
  5052.                         }
  5053.                     }
  5054.                     if (!optionSet) {
  5055.                         elem.selectedIndex = -1;
  5056.                     }
  5057.                     return values;
  5058.                 }
  5059.             }
  5060.         }
  5061.     });
  5062.     jQuery.each(["radio", "checkbox"], function() {
  5063.         jQuery.valHooks[this] = {
  5064.             set: function(elem, value) {
  5065.                 if (Array.isArray(value)) {
  5066.                     return (elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1);
  5067.                 }
  5068.             }
  5069.         };
  5070.         if (!support.checkOn) {
  5071.             jQuery.valHooks[this].get = function(elem) {
  5072.                 return elem.getAttribute("value") === null ? "on" : elem.value;
  5073.             }
  5074.             ;
  5075.         }
  5076.     });
  5077.     var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
  5078.     jQuery.extend(jQuery.event, {
  5079.         trigger: function(event, data, elem, onlyHandlers) {
  5080.             var i, cur, tmp, bubbleType, ontype, handle, special, eventPath = [elem || document], type = hasOwn.call(event, "type") ? event.type : event, namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
  5081.             cur = tmp = elem = elem || document;
  5082.             if (elem.nodeType === 3 || elem.nodeType === 8) {
  5083.                 return;
  5084.             }
  5085.             if (rfocusMorph.test(type + jQuery.event.triggered)) {
  5086.                 return;
  5087.             }
  5088.             if (type.indexOf(".") > -1) {
  5089.                 namespaces = type.split(".");
  5090.                 type = namespaces.shift();
  5091.                 namespaces.sort();
  5092.             }
  5093.             ontype = type.indexOf(":") < 0 && "on" + type;
  5094.             event = event[jQuery.expando] ? event : new jQuery.Event(type,typeof event === "object" && event);
  5095.             event.isTrigger = onlyHandlers ? 2 : 3;
  5096.             event.namespace = namespaces.join(".");
  5097.             event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
  5098.             event.result = undefined;
  5099.             if (!event.target) {
  5100.                 event.target = elem;
  5101.             }
  5102.             data = data == null ? [event] : jQuery.makeArray(data, [event]);
  5103.             special = jQuery.event.special[type] || {};
  5104.             if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
  5105.                 return;
  5106.             }
  5107.             if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
  5108.                 bubbleType = special.delegateType || type;
  5109.                 if (!rfocusMorph.test(bubbleType + type)) {
  5110.                     cur = cur.parentNode;
  5111.                 }
  5112.                 for (; cur; cur = cur.parentNode) {
  5113.                     eventPath.push(cur);
  5114.                     tmp = cur;
  5115.                 }
  5116.                 if (tmp === (elem.ownerDocument || document)) {
  5117.                     eventPath.push(tmp.defaultView || tmp.parentWindow || window);
  5118.                 }
  5119.             }
  5120.             i = 0;
  5121.             while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
  5122.                 event.type = i > 1 ? bubbleType : special.bindType || type;
  5123.                 handle = (dataPriv.get(cur, "events") || {})[event.type] && dataPriv.get(cur, "handle");
  5124.                 if (handle) {
  5125.                     handle.apply(cur, data);
  5126.                 }
  5127.                 handle = ontype && cur[ontype];
  5128.                 if (handle && handle.apply && acceptData(cur)) {
  5129.                     event.result = handle.apply(cur, data);
  5130.                     if (event.result === false) {
  5131.                         event.preventDefault();
  5132.                     }
  5133.                 }
  5134.             }
  5135.             event.type = type;
  5136.             if (!onlyHandlers && !event.isDefaultPrevented()) {
  5137.                 if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {
  5138.                     if (ontype && jQuery.isFunction(elem[type]) && !jQuery.isWindow(elem)) {
  5139.                         tmp = elem[ontype];
  5140.                         if (tmp) {
  5141.                             elem[ontype] = null;
  5142.                         }
  5143.                         jQuery.event.triggered = type;
  5144.                         elem[type]();
  5145.                         jQuery.event.triggered = undefined;
  5146.                         if (tmp) {
  5147.                             elem[ontype] = tmp;
  5148.                         }
  5149.                     }
  5150.                 }
  5151.             }
  5152.             return event.result;
  5153.         },
  5154.         simulate: function(type, elem, event) {
  5155.             var e = jQuery.extend(new jQuery.Event(), event, {
  5156.                 type: type,
  5157.                 isSimulated: true
  5158.             });
  5159.             jQuery.event.trigger(e, null, elem);
  5160.         }
  5161.     });
  5162.     jQuery.fn.extend({
  5163.         trigger: function(type, data) {
  5164.             return this.each(function() {
  5165.                 jQuery.event.trigger(type, data, this);
  5166.             });
  5167.         },
  5168.         triggerHandler: function(type, data) {
  5169.             var elem = this[0];
  5170.             if (elem) {
  5171.                 return jQuery.event.trigger(type, data, elem, true);
  5172.             }
  5173.         }
  5174.     });
  5175.     jQuery.each(("blur focus focusin focusout resize scroll click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup contextmenu").split(" "), function(i, name) {
  5176.         jQuery.fn[name] = function(data, fn) {
  5177.             return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
  5178.         }
  5179.         ;
  5180.     });
  5181.     jQuery.fn.extend({
  5182.         hover: function(fnOver, fnOut) {
  5183.             return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
  5184.         }
  5185.     });
  5186.     support.focusin = "onfocusin"in window;
  5187.     if (!support.focusin) {
  5188.         jQuery.each({
  5189.             focus: "focusin",
  5190.             blur: "focusout"
  5191.         }, function(orig, fix) {
  5192.             var handler = function(event) {
  5193.                 jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
  5194.             };
  5195.             jQuery.event.special[fix] = {
  5196.                 setup: function() {
  5197.                     var doc = this.ownerDocument || this
  5198.                       , attaches = dataPriv.access(doc, fix);
  5199.                     if (!attaches) {
  5200.                         doc.addEventListener(orig, handler, true);
  5201.                     }
  5202.                     dataPriv.access(doc, fix, (attaches || 0) + 1);
  5203.                 },
  5204.                 teardown: function() {
  5205.                     var doc = this.ownerDocument || this
  5206.                       , attaches = dataPriv.access(doc, fix) - 1;
  5207.                     if (!attaches) {
  5208.                         doc.removeEventListener(orig, handler, true);
  5209.                         dataPriv.remove(doc, fix);
  5210.                     } else {
  5211.                         dataPriv.access(doc, fix, attaches);
  5212.                     }
  5213.                 }
  5214.             };
  5215.         });
  5216.     }
  5217.     var location = window.location;
  5218.     var nonce = jQuery.now();
  5219.     var rquery = (/\?/);
  5220.     jQuery.parseXML = function(data) {
  5221.         var xml;
  5222.         if (!data || typeof data !== "string") {
  5223.             return null;
  5224.         }
  5225.         try {
  5226.             xml = (new window.DOMParser()).parseFromString(data, "text/xml");
  5227.         } catch (e) {
  5228.             xml = undefined;
  5229.         }
  5230.         if (!xml || xml.getElementsByTagName("parsererror").length) {
  5231.             jQuery.error("Invalid XML: " + data);
  5232.         }
  5233.         return xml;
  5234.     }
  5235.     ;
  5236.     var rbracket = /\[\]$/
  5237.       , rCRLF = /\r?\n/g
  5238.       , rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i
  5239.       , rsubmittable = /^(?:input|select|textarea|keygen)/i;
  5240.     function buildParams(prefix, obj, traditional, add) {
  5241.         var name;
  5242.         if (Array.isArray(obj)) {
  5243.             jQuery.each(obj, function(i, v) {
  5244.                 if (traditional || rbracket.test(prefix)) {
  5245.                     add(prefix, v);
  5246.                 } else {
  5247.                     buildParams(prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]", v, traditional, add);
  5248.                 }
  5249.             });
  5250.         } else if (!traditional && jQuery.type(obj) === "object") {
  5251.             for (name in obj) {
  5252.                 buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
  5253.             }
  5254.         } else {
  5255.             add(prefix, obj);
  5256.         }
  5257.     }
  5258.     jQuery.param = function(a, traditional) {
  5259.         var prefix, s = [], add = function(key, valueOrFunction) {
  5260.             var value = jQuery.isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;
  5261.             s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value);
  5262.         };
  5263.         if (Array.isArray(a) || (a.jquery && !jQuery.isPlainObject(a))) {
  5264.             jQuery.each(a, function() {
  5265.                 add(this.name, this.value);
  5266.             });
  5267.         } else {
  5268.             for (prefix in a) {
  5269.                 buildParams(prefix, a[prefix], traditional, add);
  5270.             }
  5271.         }
  5272.         return s.join("&");
  5273.     }
  5274.     ;
  5275.     jQuery.fn.extend({
  5276.         serialize: function() {
  5277.             return jQuery.param(this.serializeArray());
  5278.         },
  5279.         serializeArray: function() {
  5280.             return this.map(function() {
  5281.                 var elements = jQuery.prop(this, "elements");
  5282.                 return elements ? jQuery.makeArray(elements) : this;
  5283.             }).filter(function() {
  5284.                 var type = this.type;
  5285.                 return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));
  5286.             }).map(function(i, elem) {
  5287.                 var val = jQuery(this).val();
  5288.                 if (val == null) {
  5289.                     return null;
  5290.                 }
  5291.                 if (Array.isArray(val)) {
  5292.                     return jQuery.map(val, function(val) {
  5293.                         return {
  5294.                             name: elem.name,
  5295.                             value: val.replace(rCRLF, "\r\n")
  5296.                         };
  5297.                     });
  5298.                 }
  5299.                 return {
  5300.                     name: elem.name,
  5301.                     value: val.replace(rCRLF, "\r\n")
  5302.                 };
  5303.             }).get();
  5304.         }
  5305.     });
  5306.     var r20 = /%20/g
  5307.       , rhash = /#.*$/
  5308.       , rantiCache = /([?&])_=[^&]*/
  5309.       , rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg
  5310.       , rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/
  5311.       , rnoContent = /^(?:GET|HEAD)$/
  5312.       , rprotocol = /^\/\//
  5313.       , prefilters = {}
  5314.       , transports = {}
  5315.       , allTypes = "*/".concat("*")
  5316.       , originAnchor = document.createElement("a");
  5317.     originAnchor.href = location.href;
  5318.     function addToPrefiltersOrTransports(structure) {
  5319.         return function(dataTypeExpression, func) {
  5320.             if (typeof dataTypeExpression !== "string") {
  5321.                 func = dataTypeExpression;
  5322.                 dataTypeExpression = "*";
  5323.             }
  5324.             var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];
  5325.             if (jQuery.isFunction(func)) {
  5326.                 while ((dataType = dataTypes[i++])) {
  5327.                     if (dataType[0] === "+") {
  5328.                         dataType = dataType.slice(1) || "*";
  5329.                         (structure[dataType] = structure[dataType] || []).unshift(func);
  5330.                     } else {
  5331.                         (structure[dataType] = structure[dataType] || []).push(func);
  5332.                     }
  5333.                 }
  5334.             }
  5335.         }
  5336.         ;
  5337.     }
  5338.     function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
  5339.         var inspected = {}
  5340.           , seekingTransport = (structure === transports);
  5341.         function inspect(dataType) {
  5342.             var selected;
  5343.             inspected[dataType] = true;
  5344.             jQuery.each(structure[dataType] || [], function(_, prefilterOrFactory) {
  5345.                 var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
  5346.                 if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {
  5347.                     options.dataTypes.unshift(dataTypeOrTransport);
  5348.                     inspect(dataTypeOrTransport);
  5349.                     return false;
  5350.                 } else if (seekingTransport) {
  5351.                     return !(selected = dataTypeOrTransport);
  5352.                 }
  5353.             });
  5354.             return selected;
  5355.         }
  5356.         return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
  5357.     }
  5358.     function ajaxExtend(target, src) {
  5359.         var key, deep, flatOptions = jQuery.ajaxSettings.flatOptions || {};
  5360.         for (key in src) {
  5361.             if (src[key] !== undefined) {
  5362.                 (flatOptions[key] ? target : (deep || (deep = {})))[key] = src[key];
  5363.             }
  5364.         }
  5365.         if (deep) {
  5366.             jQuery.extend(true, target, deep);
  5367.         }
  5368.         return target;
  5369.     }
  5370.     function ajaxHandleResponses(s, jqXHR, responses) {
  5371.         var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes;
  5372.         while (dataTypes[0] === "*") {
  5373.             dataTypes.shift();
  5374.             if (ct === undefined) {
  5375.                 ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
  5376.             }
  5377.         }
  5378.         if (ct) {
  5379.             for (type in contents) {
  5380.                 if (contents[type] && contents[type].test(ct)) {
  5381.                     dataTypes.unshift(type);
  5382.                     break;
  5383.                 }
  5384.             }
  5385.         }
  5386.         if (dataTypes[0]in responses) {
  5387.             finalDataType = dataTypes[0];
  5388.         } else {
  5389.             for (type in responses) {
  5390.                 if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
  5391.                     finalDataType = type;
  5392.                     break;
  5393.                 }
  5394.                 if (!firstDataType) {
  5395.                     firstDataType = type;
  5396.                 }
  5397.             }
  5398.             finalDataType = finalDataType || firstDataType;
  5399.         }
  5400.         if (finalDataType) {
  5401.             if (finalDataType !== dataTypes[0]) {
  5402.                 dataTypes.unshift(finalDataType);
  5403.             }
  5404.             return responses[finalDataType];
  5405.         }
  5406.     }
  5407.     function ajaxConvert(s, response, jqXHR, isSuccess) {
  5408.         var conv2, current, conv, tmp, prev, converters = {}, dataTypes = s.dataTypes.slice();
  5409.         if (dataTypes[1]) {
  5410.             for (conv in s.converters) {
  5411.                 converters[conv.toLowerCase()] = s.converters[conv];
  5412.             }
  5413.         }
  5414.         current = dataTypes.shift();
  5415.         while (current) {
  5416.             if (s.responseFields[current]) {
  5417.                 jqXHR[s.responseFields[current]] = response;
  5418.             }
  5419.             if (!prev && isSuccess && s.dataFilter) {
  5420.                 response = s.dataFilter(response, s.dataType);
  5421.             }
  5422.             prev = current;
  5423.             current = dataTypes.shift();
  5424.             if (current) {
  5425.                 if (current === "*") {
  5426.                     current = prev;
  5427.                 } else if (prev !== "*" && prev !== current) {
  5428.                     conv = converters[prev + " " + current] || converters["* " + current];
  5429.                     if (!conv) {
  5430.                         for (conv2 in converters) {
  5431.                             tmp = conv2.split(" ");
  5432.                             if (tmp[1] === current) {
  5433.                                 conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]];
  5434.                                 if (conv) {
  5435.                                     if (conv === true) {
  5436.                                         conv = converters[conv2];
  5437.                                     } else if (converters[conv2] !== true) {
  5438.                                         current = tmp[0];
  5439.                                         dataTypes.unshift(tmp[1]);
  5440.                                     }
  5441.                                     break;
  5442.                                 }
  5443.                             }
  5444.                         }
  5445.                     }
  5446.                     if (conv !== true) {
  5447.                         if (conv && s.throws) {
  5448.                             response = conv(response);
  5449.                         } else {
  5450.                             try {
  5451.                                 response = conv(response);
  5452.                             } catch (e) {
  5453.                                 return {
  5454.                                     state: "parsererror",
  5455.                                     error: conv ? e : "No conversion from " + prev + " to " + current
  5456.                                 };
  5457.                             }
  5458.                         }
  5459.                     }
  5460.                 }
  5461.             }
  5462.         }
  5463.         return {
  5464.             state: "success",
  5465.             data: response
  5466.         };
  5467.     }
  5468.     jQuery.extend({
  5469.         active: 0,
  5470.         lastModified: {},
  5471.         etag: {},
  5472.         ajaxSettings: {
  5473.             url: location.href,
  5474.             type: "GET",
  5475.             isLocal: rlocalProtocol.test(location.protocol),
  5476.             global: true,
  5477.             processData: true,
  5478.             async: true,
  5479.             contentType: "application/x-www-form-urlencoded; charset=UTF-8",
  5480.             accepts: {
  5481.                 "*": allTypes,
  5482.                 text: "text/plain",
  5483.                 html: "text/html",
  5484.                 xml: "application/xml, text/xml",
  5485.                 json: "application/json, text/javascript"
  5486.             },
  5487.             contents: {
  5488.                 xml: /\bxml\b/,
  5489.                 html: /\bhtml/,
  5490.                 json: /\bjson\b/
  5491.             },
  5492.             responseFields: {
  5493.                 xml: "responseXML",
  5494.                 text: "responseText",
  5495.                 json: "responseJSON"
  5496.             },
  5497.             converters: {
  5498.                 "* text": String,
  5499.                 "text html": true,
  5500.                 "text json": JSON.parse,
  5501.                 "text xml": jQuery.parseXML
  5502.             },
  5503.             flatOptions: {
  5504.                 url: true,
  5505.                 context: true
  5506.             }
  5507.         },
  5508.         ajaxSetup: function(target, settings) {
  5509.             return settings ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : ajaxExtend(jQuery.ajaxSettings, target);
  5510.         },
  5511.         ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
  5512.         ajaxTransport: addToPrefiltersOrTransports(transports),
  5513.         ajax: function(url, options) {
  5514.             if (typeof url === "object") {
  5515.                 options = url;
  5516.                 url = undefined;
  5517.             }
  5518.             options = options || {};
  5519.             var transport, cacheURL, responseHeadersString, responseHeaders, timeoutTimer, urlAnchor, completed, fireGlobals, i, uncached, s = jQuery.ajaxSetup({}, options), callbackContext = s.context || s, globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event, deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks("once memory"), statusCode = s.statusCode || {}, requestHeaders = {}, requestHeadersNames = {}, strAbort = "canceled", jqXHR = {
  5520.                 readyState: 0,
  5521.                 getResponseHeader: function(key) {
  5522.                     var match;
  5523.                     if (completed) {
  5524.                         if (!responseHeaders) {
  5525.                             responseHeaders = {};
  5526.                             while ((match = rheaders.exec(responseHeadersString))) {
  5527.                                 responseHeaders[match[1].toLowerCase()] = match[2];
  5528.                             }
  5529.                         }
  5530.                         match = responseHeaders[key.toLowerCase()];
  5531.                     }
  5532.                     return match == null ? null : match;
  5533.                 },
  5534.                 getAllResponseHeaders: function() {
  5535.                     return completed ? responseHeadersString : null;
  5536.                 },
  5537.                 setRequestHeader: function(name, value) {
  5538.                     if (completed == null) {
  5539.                         name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name;
  5540.                         requestHeaders[name] = value;
  5541.                     }
  5542.                     return this;
  5543.                 },
  5544.                 overrideMimeType: function(type) {
  5545.                     if (completed == null) {
  5546.                         s.mimeType = type;
  5547.                     }
  5548.                     return this;
  5549.                 },
  5550.                 statusCode: function(map) {
  5551.                     var code;
  5552.                     if (map) {
  5553.                         if (completed) {
  5554.                             jqXHR.always(map[jqXHR.status]);
  5555.                         } else {
  5556.                             for (code in map) {
  5557.                                 statusCode[code] = [statusCode[code], map[code]];
  5558.                             }
  5559.                         }
  5560.                     }
  5561.                     return this;
  5562.                 },
  5563.                 abort: function(statusText) {
  5564.                     var finalText = statusText || strAbort;
  5565.                     if (transport) {
  5566.                         transport.abort(finalText);
  5567.                     }
  5568.                     done(0, finalText);
  5569.                     return this;
  5570.                 }
  5571.             };
  5572.             deferred.promise(jqXHR);
  5573.             s.url = ((url || s.url || location.href) + "").replace(rprotocol, location.protocol + "//");
  5574.             s.type = options.method || options.type || s.method || s.type;
  5575.             s.dataTypes = (s.dataType || "*").toLowerCase().match(rnothtmlwhite) || [""];
  5576.             if (s.crossDomain == null) {
  5577.                 urlAnchor = document.createElement("a");
  5578.                 try {
  5579.                     urlAnchor.href = s.url;
  5580.                     urlAnchor.href = urlAnchor.href;
  5581.                     s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host;
  5582.                 } catch (e) {
  5583.                     s.crossDomain = true;
  5584.                 }
  5585.             }
  5586.             if (s.data && s.processData && typeof s.data !== "string") {
  5587.                 s.data = jQuery.param(s.data, s.traditional);
  5588.             }
  5589.             inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
  5590.             if (completed) {
  5591.                 return jqXHR;
  5592.             }
  5593.             fireGlobals = jQuery.event && s.global;
  5594.             if (fireGlobals && jQuery.active++ === 0) {
  5595.                 jQuery.event.trigger("ajaxStart");
  5596.             }
  5597.             s.type = s.type.toUpperCase();
  5598.             s.hasContent = !rnoContent.test(s.type);
  5599.             cacheURL = s.url.replace(rhash, "");
  5600.             if (!s.hasContent) {
  5601.                 uncached = s.url.slice(cacheURL.length);
  5602.                 if (s.data) {
  5603.                     cacheURL += (rquery.test(cacheURL) ? "&" : "?") + s.data;
  5604.                     delete s.data;
  5605.                 }
  5606.                 if (s.cache === false) {
  5607.                     cacheURL = cacheURL.replace(rantiCache, "$1");
  5608.                     uncached = (rquery.test(cacheURL) ? "&" : "?") + "_=" + (nonce++) + uncached;
  5609.                 }
  5610.                 s.url = cacheURL + uncached;
  5611.             } else if (s.data && s.processData && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0) {
  5612.                 s.data = s.data.replace(r20, "+");
  5613.             }
  5614.             if (s.ifModified) {
  5615.                 if (jQuery.lastModified[cacheURL]) {
  5616.                     jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
  5617.                 }
  5618.                 if (jQuery.etag[cacheURL]) {
  5619.                     jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
  5620.                 }
  5621.             }
  5622.             if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
  5623.                 jqXHR.setRequestHeader("Content-Type", s.contentType);
  5624.             }
  5625.             jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]);
  5626.             for (i in s.headers) {
  5627.                 jqXHR.setRequestHeader(i, s.headers[i]);
  5628.             }
  5629.             if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {
  5630.                 return jqXHR.abort();
  5631.             }
  5632.             strAbort = "abort";
  5633.             completeDeferred.add(s.complete);
  5634.             jqXHR.done(s.success);
  5635.             jqXHR.fail(s.error);
  5636.             transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
  5637.             if (!transport) {
  5638.                 done(-1, "No Transport");
  5639.             } else {
  5640.                 jqXHR.readyState = 1;
  5641.                 if (fireGlobals) {
  5642.                     globalEventContext.trigger("ajaxSend", [jqXHR, s]);
  5643.                 }
  5644.                 if (completed) {
  5645.                     return jqXHR;
  5646.                 }
  5647.                 if (s.async && s.timeout > 0) {
  5648.                     timeoutTimer = window.setTimeout(function() {
  5649.                         jqXHR.abort("timeout");
  5650.                     }, s.timeout);
  5651.                 }
  5652.                 try {
  5653.                     completed = false;
  5654.                     transport.send(requestHeaders, done);
  5655.                 } catch (e) {
  5656.                     if (completed) {
  5657.                         throw e;
  5658.                     }
  5659.                     done(-1, e);
  5660.                 }
  5661.             }
  5662.             function done(status, nativeStatusText, responses, headers) {
  5663.                 var isSuccess, success, error, response, modified, statusText = nativeStatusText;
  5664.                 if (completed) {
  5665.                     return;
  5666.                 }
  5667.                 completed = true;
  5668.                 if (timeoutTimer) {
  5669.                     window.clearTimeout(timeoutTimer);
  5670.                 }
  5671.                 transport = undefined;
  5672.                 responseHeadersString = headers || "";
  5673.                 jqXHR.readyState = status > 0 ? 4 : 0;
  5674.                 isSuccess = status >= 200 && status < 300 || status === 304;
  5675.                 if (responses) {
  5676.                     response = ajaxHandleResponses(s, jqXHR, responses);
  5677.                 }
  5678.                 response = ajaxConvert(s, response, jqXHR, isSuccess);
  5679.                 if (isSuccess) {
  5680.                     if (s.ifModified) {
  5681.                         modified = jqXHR.getResponseHeader("Last-Modified");
  5682.                         if (modified) {
  5683.                             jQuery.lastModified[cacheURL] = modified;
  5684.                         }
  5685.                         modified = jqXHR.getResponseHeader("etag");
  5686.                         if (modified) {
  5687.                             jQuery.etag[cacheURL] = modified;
  5688.                         }
  5689.                     }
  5690.                     if (status === 204 || s.type === "HEAD") {
  5691.                         statusText = "nocontent";
  5692.                     } else if (status === 304) {
  5693.                         statusText = "notmodified";
  5694.                     } else {
  5695.                         statusText = response.state;
  5696.                         success = response.data;
  5697.                         error = response.error;
  5698.                         isSuccess = !error;
  5699.                     }
  5700.                 } else {
  5701.                     error = statusText;
  5702.                     if (status || !statusText) {
  5703.                         statusText = "error";
  5704.                         if (status < 0) {
  5705.                             status = 0;
  5706.                         }
  5707.                     }
  5708.                 }
  5709.                 jqXHR.status = status;
  5710.                 jqXHR.statusText = (nativeStatusText || statusText) + "";
  5711.                 if (isSuccess) {
  5712.                     deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
  5713.                 } else {
  5714.                     deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
  5715.                 }
  5716.                 jqXHR.statusCode(statusCode);
  5717.                 statusCode = undefined;
  5718.                 if (fireGlobals) {
  5719.                     globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
  5720.                 }
  5721.                 completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
  5722.                 if (fireGlobals) {
  5723.                     globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
  5724.                     if (!(--jQuery.active)) {
  5725.                         jQuery.event.trigger("ajaxStop");
  5726.                     }
  5727.                 }
  5728.             }
  5729.             return jqXHR;
  5730.         },
  5731.         getJSON: function(url, data, callback) {
  5732.             return jQuery.get(url, data, callback, "json");
  5733.         },
  5734.         getScript: function(url, callback) {
  5735.             return jQuery.get(url, undefined, callback, "script");
  5736.         }
  5737.     });
  5738.     jQuery.each(["get", "post"], function(i, method) {
  5739.         jQuery[method] = function(url, data, callback, type) {
  5740.             if (jQuery.isFunction(data)) {
  5741.                 type = type || callback;
  5742.                 callback = data;
  5743.                 data = undefined;
  5744.             }
  5745.             return jQuery.ajax(jQuery.extend({
  5746.                 url: url,
  5747.                 type: method,
  5748.                 dataType: type,
  5749.                 data: data,
  5750.                 success: callback
  5751.             }, jQuery.isPlainObject(url) && url));
  5752.         }
  5753.         ;
  5754.     });
  5755.     jQuery._evalUrl = function(url) {
  5756.         return jQuery.ajax({
  5757.             url: url,
  5758.             type: "GET",
  5759.             dataType: "script",
  5760.             cache: true,
  5761.             async: false,
  5762.             global: false,
  5763.             "throws": true
  5764.         });
  5765.     }
  5766.     ;
  5767.     jQuery.fn.extend({
  5768.         wrapAll: function(html) {
  5769.             var wrap;
  5770.             if (this[0]) {
  5771.                 if (jQuery.isFunction(html)) {
  5772.                     html = html.call(this[0]);
  5773.                 }
  5774.                 wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
  5775.                 if (this[0].parentNode) {
  5776.                     wrap.insertBefore(this[0]);
  5777.                 }
  5778.                 wrap.map(function() {
  5779.                     var elem = this;
  5780.                     while (elem.firstElementChild) {
  5781.                         elem = elem.firstElementChild;
  5782.                     }
  5783.                     return elem;
  5784.                 }).append(this);
  5785.             }
  5786.             return this;
  5787.         },
  5788.         wrapInner: function(html) {
  5789.             if (jQuery.isFunction(html)) {
  5790.                 return this.each(function(i) {
  5791.                     jQuery(this).wrapInner(html.call(this, i));
  5792.                 });
  5793.             }
  5794.             return this.each(function() {
  5795.                 var self = jQuery(this)
  5796.                   , contents = self.contents();
  5797.                 if (contents.length) {
  5798.                     contents.wrapAll(html);
  5799.                 } else {
  5800.                     self.append(html);
  5801.                 }
  5802.             });
  5803.         },
  5804.         wrap: function(html) {
  5805.             var isFunction = jQuery.isFunction(html);
  5806.             return this.each(function(i) {
  5807.                 jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
  5808.             });
  5809.         },
  5810.         unwrap: function(selector) {
  5811.             this.parent(selector).not("body").each(function() {
  5812.                 jQuery(this).replaceWith(this.childNodes);
  5813.             });
  5814.             return this;
  5815.         }
  5816.     });
  5817.     jQuery.expr.pseudos.hidden = function(elem) {
  5818.         return !jQuery.expr.pseudos.visible(elem);
  5819.     }
  5820.     ;
  5821.     jQuery.expr.pseudos.visible = function(elem) {
  5822.         return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
  5823.     }
  5824.     ;
  5825.     jQuery.ajaxSettings.xhr = function() {
  5826.         try {
  5827.             return new window.XMLHttpRequest();
  5828.         } catch (e) {}
  5829.     }
  5830.     ;
  5831.     var xhrSuccessStatus = {
  5832.         0: 200,
  5833.         1223: 204
  5834.     }
  5835.       , xhrSupported = jQuery.ajaxSettings.xhr();
  5836.     support.cors = !!xhrSupported && ("withCredentials"in xhrSupported);
  5837.     support.ajax = xhrSupported = !!xhrSupported;
  5838.     jQuery.ajaxTransport(function(options) {
  5839.         var callback, errorCallback;
  5840.         if (support.cors || xhrSupported && !options.crossDomain) {
  5841.             return {
  5842.                 send: function(headers, complete) {
  5843.                     var i, xhr = options.xhr();
  5844.                     xhr.open(options.type, options.url, options.async, options.username, options.password);
  5845.                     if (options.xhrFields) {
  5846.                         for (i in options.xhrFields) {
  5847.                             xhr[i] = options.xhrFields[i];
  5848.                         }
  5849.                     }
  5850.                     if (options.mimeType && xhr.overrideMimeType) {
  5851.                         xhr.overrideMimeType(options.mimeType);
  5852.                     }
  5853.                     if (!options.crossDomain && !headers["X-Requested-With"]) {
  5854.                         headers["X-Requested-With"] = "XMLHttpRequest";
  5855.                     }
  5856.                     for (i in headers) {
  5857.                         xhr.setRequestHeader(i, headers[i]);
  5858.                     }
  5859.                     callback = function(type) {
  5860.                         return function() {
  5861.                             if (callback) {
  5862.                                 callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
  5863.                                 if (type === "abort") {
  5864.                                     xhr.abort();
  5865.                                 } else if (type === "error") {
  5866.                                     if (typeof xhr.status !== "number") {
  5867.                                         complete(0, "error");
  5868.                                     } else {
  5869.                                         complete(xhr.status, xhr.statusText);
  5870.                                     }
  5871.                                 } else {
  5872.                                     complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, (xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? {
  5873.                                         binary: xhr.response
  5874.                                     } : {
  5875.                                         text: xhr.responseText
  5876.                                     }, xhr.getAllResponseHeaders());
  5877.                                 }
  5878.                             }
  5879.                         }
  5880.                         ;
  5881.                     }
  5882.                     ;
  5883.                     xhr.onload = callback();
  5884.                     errorCallback = xhr.onerror = callback("error");
  5885.                     if (xhr.onabort !== undefined) {
  5886.                         xhr.onabort = errorCallback;
  5887.                     } else {
  5888.                         xhr.onreadystatechange = function() {
  5889.                             if (xhr.readyState === 4) {
  5890.                                 window.setTimeout(function() {
  5891.                                     if (callback) {
  5892.                                         errorCallback();
  5893.                                     }
  5894.                                 });
  5895.                             }
  5896.                         }
  5897.                         ;
  5898.                     }
  5899.                     callback = callback("abort");
  5900.                     try {
  5901.                         xhr.send(options.hasContent && options.data || null);
  5902.                     } catch (e) {
  5903.                         if (callback) {
  5904.                             throw e;
  5905.                         }
  5906.                     }
  5907.                 },
  5908.                 abort: function() {
  5909.                     if (callback) {
  5910.                         callback();
  5911.                     }
  5912.                 }
  5913.             };
  5914.         }
  5915.     });
  5916.     jQuery.ajaxPrefilter(function(s) {
  5917.         if (s.crossDomain) {
  5918.             s.contents.script = false;
  5919.         }
  5920.     });
  5921.     jQuery.ajaxSetup({
  5922.         accepts: {
  5923.             script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript"
  5924.         },
  5925.         contents: {
  5926.             script: /\b(?:java|ecma)script\b/
  5927.         },
  5928.         converters: {
  5929.             "text script": function(text) {
  5930.                 jQuery.globalEval(text);
  5931.                 return text;
  5932.             }
  5933.         }
  5934.     });
  5935.     jQuery.ajaxPrefilter("script", function(s) {
  5936.         if (s.cache === undefined) {
  5937.             s.cache = false;
  5938.         }
  5939.         if (s.crossDomain) {
  5940.             s.type = "GET";
  5941.         }
  5942.     });
  5943.     jQuery.ajaxTransport("script", function(s) {
  5944.         if (s.crossDomain) {
  5945.             var script, callback;
  5946.             return {
  5947.                 send: function(_, complete) {
  5948.                     script = jQuery("<script>").prop({
  5949.                         charset: s.scriptCharset,
  5950.                         src: s.url
  5951.                     }).on("load error", callback = function(evt) {
  5952.                         script.remove();
  5953.                         callback = null;
  5954.                         if (evt) {
  5955.                             complete(evt.type === "error" ? 404 : 200, evt.type);
  5956.                         }
  5957.                     }
  5958.                     );
  5959.                     document.head.appendChild(script[0]);
  5960.                 },
  5961.                 abort: function() {
  5962.                     if (callback) {
  5963.                         callback();
  5964.                     }
  5965.                 }
  5966.             };
  5967.         }
  5968.     });
  5969.     var oldCallbacks = []
  5970.       , rjsonp = /(=)\?(?=&|$)|\?\?/;
  5971.     jQuery.ajaxSetup({
  5972.         jsonp: "callback",
  5973.         jsonpCallback: function() {
  5974.             var callback = oldCallbacks.pop() || (jQuery.expando + "_" + (nonce++));
  5975.             this[callback] = true;
  5976.             return callback;
  5977.         }
  5978.     });
  5979.     jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, jqXHR) {
  5980.         var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 && rjsonp.test(s.data) && "data");
  5981.         if (jsonProp || s.dataTypes[0] === "jsonp") {
  5982.             callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback;
  5983.             if (jsonProp) {
  5984.                 s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
  5985.             } else if (s.jsonp !== false) {
  5986.                 s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
  5987.             }
  5988.             s.converters["script json"] = function() {
  5989.                 if (!responseContainer) {
  5990.                     jQuery.error(callbackName + " was not called");
  5991.                 }
  5992.                 return responseContainer[0];
  5993.             }
  5994.             ;
  5995.             s.dataTypes[0] = "json";
  5996.             overwritten = window[callbackName];
  5997.             window[callbackName] = function() {
  5998.                 responseContainer = arguments;
  5999.             }
  6000.             ;
  6001.             jqXHR.always(function() {
  6002.                 if (overwritten === undefined) {
  6003.                     jQuery(window).removeProp(callbackName);
  6004.                 } else {
  6005.                     window[callbackName] = overwritten;
  6006.                 }
  6007.                 if (s[callbackName]) {
  6008.                     s.jsonpCallback = originalSettings.jsonpCallback;
  6009.                     oldCallbacks.push(callbackName);
  6010.                 }
  6011.                 if (responseContainer && jQuery.isFunction(overwritten)) {
  6012.                     overwritten(responseContainer[0]);
  6013.                 }
  6014.                 responseContainer = overwritten = undefined;
  6015.             });
  6016.             return "script";
  6017.         }
  6018.     });
  6019.     support.createHTMLDocument = (function() {
  6020.         var body = document.implementation.createHTMLDocument("").body;
  6021.         body.innerHTML = "<form></form><form></form>";
  6022.         return body.childNodes.length === 2;
  6023.     }
  6024.     )();
  6025.     jQuery.parseHTML = function(data, context, keepScripts) {
  6026.         if (typeof data !== "string") {
  6027.             return [];
  6028.         }
  6029.         if (typeof context === "boolean") {
  6030.             keepScripts = context;
  6031.             context = false;
  6032.         }
  6033.         var base, parsed, scripts;
  6034.         if (!context) {
  6035.             if (support.createHTMLDocument) {
  6036.                 context = document.implementation.createHTMLDocument("");
  6037.                 base = context.createElement("base");
  6038.                 base.href = document.location.href;
  6039.                 context.head.appendChild(base);
  6040.             } else {
  6041.                 context = document;
  6042.             }
  6043.         }
  6044.         parsed = rsingleTag.exec(data);
  6045.         scripts = !keepScripts && [];
  6046.         if (parsed) {
  6047.             return [context.createElement(parsed[1])];
  6048.         }
  6049.         parsed = buildFragment([data], context, scripts);
  6050.         if (scripts && scripts.length) {
  6051.             jQuery(scripts).remove();
  6052.         }
  6053.         return jQuery.merge([], parsed.childNodes);
  6054.     }
  6055.     ;
  6056.     jQuery.fn.load = function(url, params, callback) {
  6057.         var selector, type, response, self = this, off = url.indexOf(" ");
  6058.         if (off > -1) {
  6059.             selector = stripAndCollapse(url.slice(off));
  6060.             url = url.slice(0, off);
  6061.         }
  6062.         if (jQuery.isFunction(params)) {
  6063.             callback = params;
  6064.             params = undefined;
  6065.         } else if (params && typeof params === "object") {
  6066.             type = "POST";
  6067.         }
  6068.         if (self.length > 0) {
  6069.             jQuery.ajax({
  6070.                 url: url,
  6071.                 type: type || "GET",
  6072.                 dataType: "html",
  6073.                 data: params
  6074.             }).done(function(responseText) {
  6075.                 response = arguments;
  6076.                 self.html(selector ? jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : responseText);
  6077.             }).always(callback && function(jqXHR, status) {
  6078.                 self.each(function() {
  6079.                     callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);
  6080.                 });
  6081.             }
  6082.             );
  6083.         }
  6084.         return this;
  6085.     }
  6086.     ;
  6087.     jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function(i, type) {
  6088.         jQuery.fn[type] = function(fn) {
  6089.             return this.on(type, fn);
  6090.         }
  6091.         ;
  6092.     });
  6093.     jQuery.expr.pseudos.animated = function(elem) {
  6094.         return jQuery.grep(jQuery.timers, function(fn) {
  6095.             return elem === fn.elem;
  6096.         }).length;
  6097.     }
  6098.     ;
  6099.     jQuery.offset = {
  6100.         setOffset: function(elem, options, i) {
  6101.             var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery.css(elem, "position"), curElem = jQuery(elem), props = {};
  6102.             if (position === "static") {
  6103.                 elem.style.position = "relative";
  6104.             }
  6105.             curOffset = curElem.offset();
  6106.             curCSSTop = jQuery.css(elem, "top");
  6107.             curCSSLeft = jQuery.css(elem, "left");
  6108.             calculatePosition = (position === "absolute" || position === "fixed") && (curCSSTop + curCSSLeft).indexOf("auto") > -1;
  6109.             if (calculatePosition) {
  6110.                 curPosition = curElem.position();
  6111.                 curTop = curPosition.top;
  6112.                 curLeft = curPosition.left;
  6113.             } else {
  6114.                 curTop = parseFloat(curCSSTop) || 0;
  6115.                 curLeft = parseFloat(curCSSLeft) || 0;
  6116.             }
  6117.             if (jQuery.isFunction(options)) {
  6118.                 options = options.call(elem, i, jQuery.extend({}, curOffset));
  6119.             }
  6120.             if (options.top != null) {
  6121.                 props.top = (options.top - curOffset.top) + curTop;
  6122.             }
  6123.             if (options.left != null) {
  6124.                 props.left = (options.left - curOffset.left) + curLeft;
  6125.             }
  6126.             if ("using"in options) {
  6127.                 options.using.call(elem, props);
  6128.             } else {
  6129.                 curElem.css(props);
  6130.             }
  6131.         }
  6132.     };
  6133.     jQuery.fn.extend({
  6134.         offset: function(options) {
  6135.             if (arguments.length) {
  6136.                 return options === undefined ? this : this.each(function(i) {
  6137.                     jQuery.offset.setOffset(this, options, i);
  6138.                 });
  6139.             }
  6140.             var doc, docElem, rect, win, elem = this[0];
  6141.             if (!elem) {
  6142.                 return;
  6143.             }
  6144.             if (!elem.getClientRects().length) {
  6145.                 return {
  6146.                     top: 0,
  6147.                     left: 0
  6148.                 };
  6149.             }
  6150.             rect = elem.getBoundingClientRect();
  6151.             doc = elem.ownerDocument;
  6152.             docElem = doc.documentElement;
  6153.             win = doc.defaultView;
  6154.             return {
  6155.                 top: rect.top + win.pageYOffset - docElem.clientTop,
  6156.                 left: rect.left + win.pageXOffset - docElem.clientLeft
  6157.             };
  6158.         },
  6159.         position: function() {
  6160.             if (!this[0]) {
  6161.                 return;
  6162.             }
  6163.             var offsetParent, offset, elem = this[0], parentOffset = {
  6164.                 top: 0,
  6165.                 left: 0
  6166.             };
  6167.             if (jQuery.css(elem, "position") === "fixed") {
  6168.                 offset = elem.getBoundingClientRect();
  6169.             } else {
  6170.                 offsetParent = this.offsetParent();
  6171.                 offset = this.offset();
  6172.                 if (!nodeName(offsetParent[0], "html")) {
  6173.                     parentOffset = offsetParent.offset();
  6174.                 }
  6175.                 parentOffset = {
  6176.                     top: parentOffset.top + jQuery.css(offsetParent[0], "borderTopWidth", true),
  6177.                     left: parentOffset.left + jQuery.css(offsetParent[0], "borderLeftWidth", true)
  6178.                 };
  6179.             }
  6180.             return {
  6181.                 top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
  6182.                 left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)
  6183.             };
  6184.         },
  6185.         offsetParent: function() {
  6186.             return this.map(function() {
  6187.                 var offsetParent = this.offsetParent;
  6188.                 while (offsetParent && jQuery.css(offsetParent, "position") === "static") {
  6189.                     offsetParent = offsetParent.offsetParent;
  6190.                 }
  6191.                 return offsetParent || documentElement;
  6192.             });
  6193.         }
  6194.     });
  6195.     jQuery.each({
  6196.         scrollLeft: "pageXOffset",
  6197.         scrollTop: "pageYOffset"
  6198.     }, function(method, prop) {
  6199.         var top = "pageYOffset" === prop;
  6200.         jQuery.fn[method] = function(val) {
  6201.             return access(this, function(elem, method, val) {
  6202.                 var win;
  6203.                 if (jQuery.isWindow(elem)) {
  6204.                     win = elem;
  6205.                 } else if (elem.nodeType === 9) {
  6206.                     win = elem.defaultView;
  6207.                 }
  6208.                 if (val === undefined) {
  6209.                     return win ? win[prop] : elem[method];
  6210.                 }
  6211.                 if (win) {
  6212.                     win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset);
  6213.                 } else {
  6214.                     elem[method] = val;
  6215.                 }
  6216.             }, method, val, arguments.length);
  6217.         }
  6218.         ;
  6219.     });
  6220.     jQuery.each(["top", "left"], function(i, prop) {
  6221.         jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, computed) {
  6222.             if (computed) {
  6223.                 computed = curCSS(elem, prop);
  6224.                 return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed;
  6225.             }
  6226.         });
  6227.     });
  6228.     jQuery.each({
  6229.         Height: "height",
  6230.         Width: "width"
  6231.     }, function(name, type) {
  6232.         jQuery.each({
  6233.             padding: "inner" + name,
  6234.             content: type,
  6235.             "": "outer" + name
  6236.         }, function(defaultExtra, funcName) {
  6237.             jQuery.fn[funcName] = function(margin, value) {
  6238.                 var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean")
  6239.                   , extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
  6240.                 return access(this, function(elem, type, value) {
  6241.                     var doc;
  6242.                     if (jQuery.isWindow(elem)) {
  6243.                         return funcName.indexOf("outer") === 0 ? elem["inner" + name] : elem.document.documentElement["client" + name];
  6244.                     }
  6245.                     if (elem.nodeType === 9) {
  6246.                         doc = elem.documentElement;
  6247.                         return Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name]);
  6248.                     }
  6249.                     return value === undefined ? jQuery.css(elem, type, extra) : jQuery.style(elem, type, value, extra);
  6250.                 }, type, chainable ? margin : undefined, chainable);
  6251.             }
  6252.             ;
  6253.         });
  6254.     });
  6255.     jQuery.fn.extend({
  6256.         bind: function(types, data, fn) {
  6257.             return this.on(types, null, data, fn);
  6258.         },
  6259.         unbind: function(types, fn) {
  6260.             return this.off(types, null, fn);
  6261.         },
  6262.         delegate: function(selector, types, data, fn) {
  6263.             return this.on(types, selector, data, fn);
  6264.         },
  6265.         undelegate: function(selector, types, fn) {
  6266.             return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn);
  6267.         },
  6268.         holdReady: function(hold) {
  6269.             if (hold) {
  6270.                 jQuery.readyWait++;
  6271.             } else {
  6272.                 jQuery.ready(true);
  6273.             }
  6274.         }
  6275.     });
  6276.     jQuery.isArray = Array.isArray;
  6277.     jQuery.parseJSON = JSON.parse;
  6278.     jQuery.nodeName = nodeName;
  6279.     if (typeof define === "function" && define.amd) {
  6280.         define("jquery", [], function() {
  6281.             return jQuery;
  6282.         });
  6283.     }
  6284.     var _jQuery = window.jQuery
  6285.       , _$ = window.$;
  6286.     jQuery.noConflict = function(deep) {
  6287.         if (window.$ === jQuery) {
  6288.             window.$ = _$;
  6289.         }
  6290.         if (deep && window.jQuery === jQuery) {
  6291.             window.jQuery = _jQuery;
  6292.         }
  6293.         return jQuery;
  6294.     }
  6295.     ;
  6296.     if (!noGlobal) {
  6297.         window.jQuery = window.$ = jQuery;
  6298.     }
  6299.     return jQuery;
  6300. });
  6301. ;/*! tooltipster v4.2.5 */
  6302. !function(a, b) {
  6303.     "function" == typeof define && define.amd ? define(["jquery"], function(a) {
  6304.         return b(a)
  6305.     }) : "object" == typeof exports ? module.exports = b(require("jquery")) : b(jQuery)
  6306. }(this, function(a) {
  6307.     function b(a) {
  6308.         this.$container,
  6309.         this.constraints = null,
  6310.         this.__$tooltip,
  6311.         this.__init(a)
  6312.     }
  6313.     function c(b, c) {
  6314.         var d = !0;
  6315.         return a.each(b, function(a, e) {
  6316.             return void 0 === c[a] || b[a] !== c[a] ? (d = !1,
  6317.             !1) : void 0
  6318.         }),
  6319.         d
  6320.     }
  6321.     function d(b) {
  6322.         var c = b.attr("id")
  6323.           , d = c ? h.window.document.getElementById(c) : null;
  6324.         return d ? d === b[0] : a.contains(h.window.document.body, b[0])
  6325.     }
  6326.     function e() {
  6327.         if (!g)
  6328.             return !1;
  6329.         var a = g.document.body || g.document.documentElement
  6330.           , b = a.style
  6331.           , c = "transition"
  6332.           , d = ["Moz", "Webkit", "Khtml", "O", "ms"];
  6333.         if ("string" == typeof b[c])
  6334.             return !0;
  6335.         c = c.charAt(0).toUpperCase() + c.substr(1);
  6336.         for (var e = 0; e < d.length; e++)
  6337.             if ("string" == typeof b[d[e] + c])
  6338.                 return !0;
  6339.         return !1
  6340.     }
  6341.     var f = {
  6342.         animation: "fade",
  6343.         animationDuration: 350,
  6344.         content: null,
  6345.         contentAsHTML: !1,
  6346.         contentCloning: !1,
  6347.         debug: !0,
  6348.         delay: 300,
  6349.         delayTouch: [300, 500],
  6350.         functionInit: null,
  6351.         functionBefore: null,
  6352.         functionReady: null,
  6353.         functionAfter: null,
  6354.         functionFormat: null,
  6355.         IEmin: 6,
  6356.         interactive: !1,
  6357.         multiple: !1,
  6358.         parent: null,
  6359.         plugins: ["sideTip"],
  6360.         repositionOnScroll: !1,
  6361.         restoration: "none",
  6362.         selfDestruction: !0,
  6363.         theme: [],
  6364.         timer: 0,
  6365.         trackerInterval: 500,
  6366.         trackOrigin: !1,
  6367.         trackTooltip: !1,
  6368.         trigger: "hover",
  6369.         triggerClose: {
  6370.             click: !1,
  6371.             mouseleave: !1,
  6372.             originClick: !1,
  6373.             scroll: !1,
  6374.             tap: !1,
  6375.             touchleave: !1
  6376.         },
  6377.         triggerOpen: {
  6378.             click: !1,
  6379.             mouseenter: !1,
  6380.             tap: !1,
  6381.             touchstart: !1
  6382.         },
  6383.         updateAnimation: "rotate",
  6384.         zIndex: 9999999
  6385.     }
  6386.       , g = "undefined" != typeof window ? window : null
  6387.       , h = {
  6388.         hasTouchCapability: !(!g || !("ontouchstart"in g || g.DocumentTouch && g.document instanceof g.DocumentTouch || g.navigator.maxTouchPoints)),
  6389.         hasTransitions: e(),
  6390.         IE: !1,
  6391.         semVer: "4.2.5",
  6392.         window: g
  6393.     }
  6394.       , i = function() {
  6395.         this.__$emitterPrivate = a({}),
  6396.         this.__$emitterPublic = a({}),
  6397.         this.__instancesLatestArr = [],
  6398.         this.__plugins = {},
  6399.         this._env = h
  6400.     };
  6401.     i.prototype = {
  6402.         __bridge: function(b, c, d) {
  6403.             if (!c[d]) {
  6404.                 var e = function() {};
  6405.                 e.prototype = b;
  6406.                 var g = new e;
  6407.                 g.__init && g.__init(c),
  6408.                 a.each(b, function(a, b) {
  6409.                     0 != a.indexOf("__") && (c[a] ? f.debug && console.log("The " + a + " method of the " + d + " plugin conflicts with another plugin or native methods") : (c[a] = function() {
  6410.                         return g[a].apply(g, Array.prototype.slice.apply(arguments))
  6411.                     }
  6412.                     ,
  6413.                     c[a].bridged = g))
  6414.                 }),
  6415.                 c[d] = g
  6416.             }
  6417.             return this
  6418.         },
  6419.         __setWindow: function(a) {
  6420.             return h.window = a,
  6421.             this
  6422.         },
  6423.         _getRuler: function(a) {
  6424.             return new b(a)
  6425.         },
  6426.         _off: function() {
  6427.             return this.__$emitterPrivate.off.apply(this.__$emitterPrivate, Array.prototype.slice.apply(arguments)),
  6428.             this
  6429.         },
  6430.         _on: function() {
  6431.             return this.__$emitterPrivate.on.apply(this.__$emitterPrivate, Array.prototype.slice.apply(arguments)),
  6432.             this
  6433.         },
  6434.         _one: function() {
  6435.             return this.__$emitterPrivate.one.apply(this.__$emitterPrivate, Array.prototype.slice.apply(arguments)),
  6436.             this
  6437.         },
  6438.         _plugin: function(b) {
  6439.             var c = this;
  6440.             if ("string" == typeof b) {
  6441.                 var d = b
  6442.                   , e = null;
  6443.                 return d.indexOf(".") > 0 ? e = c.__plugins[d] : a.each(c.__plugins, function(a, b) {
  6444.                     return b.name.substring(b.name.length - d.length - 1) == "." + d ? (e = b,
  6445.                     !1) : void 0
  6446.                 }),
  6447.                 e
  6448.             }
  6449.             if (b.name.indexOf(".") < 0)
  6450.                 throw new Error("Plugins must be namespaced");
  6451.             return c.__plugins[b.name] = b,
  6452.             b.core && c.__bridge(b.core, c, b.name),
  6453.             this
  6454.         },
  6455.         _trigger: function() {
  6456.             var a = Array.prototype.slice.apply(arguments);
  6457.             return "string" == typeof a[0] && (a[0] = {
  6458.                 type: a[0]
  6459.             }),
  6460.             this.__$emitterPrivate.trigger.apply(this.__$emitterPrivate, a),
  6461.             this.__$emitterPublic.trigger.apply(this.__$emitterPublic, a),
  6462.             this
  6463.         },
  6464.         instances: function(b) {
  6465.             var c = []
  6466.               , d = b || ".tooltipstered";
  6467.             return a(d).each(function() {
  6468.                 var b = a(this)
  6469.                   , d = b.data("tooltipster-ns");
  6470.                 d && a.each(d, function(a, d) {
  6471.                     c.push(b.data(d))
  6472.                 })
  6473.             }),
  6474.             c
  6475.         },
  6476.         instancesLatest: function() {
  6477.             return this.__instancesLatestArr
  6478.         },
  6479.         off: function() {
  6480.             return this.__$emitterPublic.off.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  6481.             this
  6482.         },
  6483.         on: function() {
  6484.             return this.__$emitterPublic.on.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  6485.             this
  6486.         },
  6487.         one: function() {
  6488.             return this.__$emitterPublic.one.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  6489.             this
  6490.         },
  6491.         origins: function(b) {
  6492.             var c = b ? b + " " : "";
  6493.             return a(c + ".tooltipstered").toArray()
  6494.         },
  6495.         setDefaults: function(b) {
  6496.             return a.extend(f, b),
  6497.             this
  6498.         },
  6499.         triggerHandler: function() {
  6500.             return this.__$emitterPublic.triggerHandler.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  6501.             this
  6502.         }
  6503.     },
  6504.     a.tooltipster = new i,
  6505.     a.Tooltipster = function(b, c) {
  6506.         this.__callbacks = {
  6507.             close: [],
  6508.             open: []
  6509.         },
  6510.         this.__closingTime,
  6511.         this.__Content,
  6512.         this.__contentBcr,
  6513.         this.__destroyed = !1,
  6514.         this.__$emitterPrivate = a({}),
  6515.         this.__$emitterPublic = a({}),
  6516.         this.__enabled = !0,
  6517.         this.__garbageCollector,
  6518.         this.__Geometry,
  6519.         this.__lastPosition,
  6520.         this.__namespace = "tooltipster-" + Math.round(1e6 * Math.random()),
  6521.         this.__options,
  6522.         this.__$originParents,
  6523.         this.__pointerIsOverOrigin = !1,
  6524.         this.__previousThemes = [],
  6525.         this.__state = "closed",
  6526.         this.__timeouts = {
  6527.             close: [],
  6528.             open: null
  6529.         },
  6530.         this.__touchEvents = [],
  6531.         this.__tracker = null,
  6532.         this._$origin,
  6533.         this._$tooltip,
  6534.         this.__init(b, c)
  6535.     }
  6536.     ,
  6537.     a.Tooltipster.prototype = {
  6538.         __init: function(b, c) {
  6539.             var d = this;
  6540.             if (d._$origin = a(b),
  6541.             d.__options = a.extend(!0, {}, f, c),
  6542.             d.__optionsFormat(),
  6543.             !h.IE || h.IE >= d.__options.IEmin) {
  6544.                 var e = null;
  6545.                 if (void 0 === d._$origin.data("tooltipster-initialTitle") && (e = d._$origin.attr("title"),
  6546.                 void 0 === e && (e = null),
  6547.                 d._$origin.data("tooltipster-initialTitle", e)),
  6548.                 null !== d.__options.content)
  6549.                     d.__contentSet(d.__options.content);
  6550.                 else {
  6551.                     var g, i = d._$origin.attr("data-tooltip-content");
  6552.                     i && (g = a(i)),
  6553.                     g && g[0] ? d.__contentSet(g.first()) : d.__contentSet(e)
  6554.                 }
  6555.                 d._$origin.removeAttr("title").addClass("tooltipstered"),
  6556.                 d.__prepareOrigin(),
  6557.                 d.__prepareGC(),
  6558.                 a.each(d.__options.plugins, function(a, b) {
  6559.                     d._plug(b)
  6560.                 }),
  6561.                 h.hasTouchCapability && a(h.window.document.body).on("touchmove." + d.__namespace + "-triggerOpen", function(a) {
  6562.                     d._touchRecordEvent(a)
  6563.                 }),
  6564.                 d._on("created", function() {
  6565.                     d.__prepareTooltip()
  6566.                 })._on("repositioned", function(a) {
  6567.                     d.__lastPosition = a.position
  6568.                 })
  6569.             } else
  6570.                 d.__options.disabled = !0
  6571.         },
  6572.         __contentInsert: function() {
  6573.             var a = this
  6574.               , b = a._$tooltip.find(".tooltipster-content")
  6575.               , c = a.__Content
  6576.               , d = function(a) {
  6577.                 c = a
  6578.             };
  6579.             return a._trigger({
  6580.                 type: "format",
  6581.                 content: a.__Content,
  6582.                 format: d
  6583.             }),
  6584.             a.__options.functionFormat && (c = a.__options.functionFormat.call(a, a, {
  6585.                 origin: a._$origin[0]
  6586.             }, a.__Content)),
  6587.             "string" != typeof c || a.__options.contentAsHTML ? b.empty().append(c) : b.text(c),
  6588.             a
  6589.         },
  6590.         __contentSet: function(b) {
  6591.             return b instanceof a && this.__options.contentCloning && (b = b.clone(!0)),
  6592.             this.__Content = b,
  6593.             this._trigger({
  6594.                 type: "updated",
  6595.                 content: b
  6596.             }),
  6597.             this
  6598.         },
  6599.         __destroyError: function() {
  6600.             throw new Error("This tooltip has been destroyed and cannot execute your method call.")
  6601.         },
  6602.         __geometry: function() {
  6603.             var b = this
  6604.               , c = b._$origin
  6605.               , d = b._$origin.is("area");
  6606.             if (d) {
  6607.                 var e = b._$origin.parent().attr("name");
  6608.                 c = a('img[usemap="#' + e + '"]')
  6609.             }
  6610.             var f = c[0].getBoundingClientRect()
  6611.               , g = a(h.window.document)
  6612.               , i = a(h.window)
  6613.               , j = c
  6614.               , k = {
  6615.                 available: {
  6616.                     document: null,
  6617.                     window: null
  6618.                 },
  6619.                 document: {
  6620.                     size: {
  6621.                         height: g.height(),
  6622.                         width: g.width()
  6623.                     }
  6624.                 },
  6625.                 window: {
  6626.                     scroll: {
  6627.                         left: h.window.scrollX || h.window.document.documentElement.scrollLeft,
  6628.                         top: h.window.scrollY || h.window.document.documentElement.scrollTop
  6629.                     },
  6630.                     size: {
  6631.                         height: i.height(),
  6632.                         width: i.width()
  6633.                     }
  6634.                 },
  6635.                 origin: {
  6636.                     fixedLineage: !1,
  6637.                     offset: {},
  6638.                     size: {
  6639.                         height: f.bottom - f.top,
  6640.                         width: f.right - f.left
  6641.                     },
  6642.                     usemapImage: d ? c[0] : null,
  6643.                     windowOffset: {
  6644.                         bottom: f.bottom,
  6645.                         left: f.left,
  6646.                         right: f.right,
  6647.                         top: f.top
  6648.                     }
  6649.                 }
  6650.             };
  6651.             if (d) {
  6652.                 var l = b._$origin.attr("shape")
  6653.                   , m = b._$origin.attr("coords");
  6654.                 if (m && (m = m.split(","),
  6655.                 a.map(m, function(a, b) {
  6656.                     m[b] = parseInt(a)
  6657.                 })),
  6658.                 "default" != l)
  6659.                     switch (l) {
  6660.                     case "circle":
  6661.                         var n = m[0]
  6662.                           , o = m[1]
  6663.                           , p = m[2]
  6664.                           , q = o - p
  6665.                           , r = n - p;
  6666.                         k.origin.size.height = 2 * p,
  6667.                         k.origin.size.width = k.origin.size.height,
  6668.                         k.origin.windowOffset.left += r,
  6669.                         k.origin.windowOffset.top += q;
  6670.                         break;
  6671.                     case "rect":
  6672.                         var s = m[0]
  6673.                           , t = m[1]
  6674.                           , u = m[2]
  6675.                           , v = m[3];
  6676.                         k.origin.size.height = v - t,
  6677.                         k.origin.size.width = u - s,
  6678.                         k.origin.windowOffset.left += s,
  6679.                         k.origin.windowOffset.top += t;
  6680.                         break;
  6681.                     case "poly":
  6682.                         for (var w = 0, x = 0, y = 0, z = 0, A = "even", B = 0; B < m.length; B++) {
  6683.                             var C = m[B];
  6684.                             "even" == A ? (C > y && (y = C,
  6685.                             0 === B && (w = y)),
  6686.                             w > C && (w = C),
  6687.                             A = "odd") : (C > z && (z = C,
  6688.                             1 == B && (x = z)),
  6689.                             x > C && (x = C),
  6690.                             A = "even")
  6691.                         }
  6692.                         k.origin.size.height = z - x,
  6693.                         k.origin.size.width = y - w,
  6694.                         k.origin.windowOffset.left += w,
  6695.                         k.origin.windowOffset.top += x
  6696.                     }
  6697.             }
  6698.             var D = function(a) {
  6699.                 k.origin.size.height = a.height,
  6700.                 k.origin.windowOffset.left = a.left,
  6701.                 k.origin.windowOffset.top = a.top,
  6702.                 k.origin.size.width = a.width
  6703.             };
  6704.             for (b._trigger({
  6705.                 type: "geometry",
  6706.                 edit: D,
  6707.                 geometry: {
  6708.                     height: k.origin.size.height,
  6709.                     left: k.origin.windowOffset.left,
  6710.                     top: k.origin.windowOffset.top,
  6711.                     width: k.origin.size.width
  6712.                 }
  6713.             }),
  6714.             k.origin.windowOffset.right = k.origin.windowOffset.left + k.origin.size.width,
  6715.             k.origin.windowOffset.bottom = k.origin.windowOffset.top + k.origin.size.height,
  6716.             k.origin.offset.left = k.origin.windowOffset.left + k.window.scroll.left,
  6717.             k.origin.offset.top = k.origin.windowOffset.top + k.window.scroll.top,
  6718.             k.origin.offset.bottom = k.origin.offset.top + k.origin.size.height,
  6719.             k.origin.offset.right = k.origin.offset.left + k.origin.size.width,
  6720.             k.available.document = {
  6721.                 bottom: {
  6722.                     height: k.document.size.height - k.origin.offset.bottom,
  6723.                     width: k.document.size.width
  6724.                 },
  6725.                 left: {
  6726.                     height: k.document.size.height,
  6727.                     width: k.origin.offset.left
  6728.                 },
  6729.                 right: {
  6730.                     height: k.document.size.height,
  6731.                     width: k.document.size.width - k.origin.offset.right
  6732.                 },
  6733.                 top: {
  6734.                     height: k.origin.offset.top,
  6735.                     width: k.document.size.width
  6736.                 }
  6737.             },
  6738.             k.available.window = {
  6739.                 bottom: {
  6740.                     height: Math.max(k.window.size.height - Math.max(k.origin.windowOffset.bottom, 0), 0),
  6741.                     width: k.window.size.width
  6742.                 },
  6743.                 left: {
  6744.                     height: k.window.size.height,
  6745.                     width: Math.max(k.origin.windowOffset.left, 0)
  6746.                 },
  6747.                 right: {
  6748.                     height: k.window.size.height,
  6749.                     width: Math.max(k.window.size.width - Math.max(k.origin.windowOffset.right, 0), 0)
  6750.                 },
  6751.                 top: {
  6752.                     height: Math.max(k.origin.windowOffset.top, 0),
  6753.                     width: k.window.size.width
  6754.                 }
  6755.             }; "html" != j[0].tagName.toLowerCase(); ) {
  6756.                 if ("fixed" == j.css("position")) {
  6757.                     k.origin.fixedLineage = !0;
  6758.                     break
  6759.                 }
  6760.                 j = j.parent()
  6761.             }
  6762.             return k
  6763.         },
  6764.         __optionsFormat: function() {
  6765.             return "number" == typeof this.__options.animationDuration && (this.__options.animationDuration = [this.__options.animationDuration, this.__options.animationDuration]),
  6766.             "number" == typeof this.__options.delay && (this.__options.delay = [this.__options.delay, this.__options.delay]),
  6767.             "number" == typeof this.__options.delayTouch && (this.__options.delayTouch = [this.__options.delayTouch, this.__options.delayTouch]),
  6768.             "string" == typeof this.__options.theme && (this.__options.theme = [this.__options.theme]),
  6769.             null === this.__options.parent ? this.__options.parent = a(h.window.document.body) : "string" == typeof this.__options.parent && (this.__options.parent = a(this.__options.parent)),
  6770.             "hover" == this.__options.trigger ? (this.__options.triggerOpen = {
  6771.                 mouseenter: !0,
  6772.                 touchstart: !0
  6773.             },
  6774.             this.__options.triggerClose = {
  6775.                 mouseleave: !0,
  6776.                 originClick: !0,
  6777.                 touchleave: !0
  6778.             }) : "click" == this.__options.trigger && (this.__options.triggerOpen = {
  6779.                 click: !0,
  6780.                 tap: !0
  6781.             },
  6782.             this.__options.triggerClose = {
  6783.                 click: !0,
  6784.                 tap: !0
  6785.             }),
  6786.             this._trigger("options"),
  6787.             this
  6788.         },
  6789.         __prepareGC: function() {
  6790.             var b = this;
  6791.             return b.__options.selfDestruction ? b.__garbageCollector = setInterval(function() {
  6792.                 var c = (new Date).getTime();
  6793.                 b.__touchEvents = a.grep(b.__touchEvents, function(a, b) {
  6794.                     return c - a.time > 6e4
  6795.                 }),
  6796.                 d(b._$origin) || b.close(function() {
  6797.                     b.destroy()
  6798.                 })
  6799.             }, 2e4) : clearInterval(b.__garbageCollector),
  6800.             b
  6801.         },
  6802.         __prepareOrigin: function() {
  6803.             var a = this;
  6804.             if (a._$origin.off("." + a.__namespace + "-triggerOpen"),
  6805.             h.hasTouchCapability && a._$origin.on("touchstart." + a.__namespace + "-triggerOpen touchend." + a.__namespace + "-triggerOpen touchcancel." + a.__namespace + "-triggerOpen", function(b) {
  6806.                 a._touchRecordEvent(b)
  6807.             }),
  6808.             a.__options.triggerOpen.click || a.__options.triggerOpen.tap && h.hasTouchCapability) {
  6809.                 var b = "";
  6810.                 a.__options.triggerOpen.click && (b += "click." + a.__namespace + "-triggerOpen "),
  6811.                 a.__options.triggerOpen.tap && h.hasTouchCapability && (b += "touchend." + a.__namespace + "-triggerOpen"),
  6812.                 a._$origin.on(b, function(b) {
  6813.                     a._touchIsMeaningfulEvent(b) && a._open(b)
  6814.                 })
  6815.             }
  6816.             if (a.__options.triggerOpen.mouseenter || a.__options.triggerOpen.touchstart && h.hasTouchCapability) {
  6817.                 var b = "";
  6818.                 a.__options.triggerOpen.mouseenter && (b += "mouseenter." + a.__namespace + "-triggerOpen "),
  6819.                 a.__options.triggerOpen.touchstart && h.hasTouchCapability && (b += "touchstart." + a.__namespace + "-triggerOpen"),
  6820.                 a._$origin.on(b, function(b) {
  6821.                     !a._touchIsTouchEvent(b) && a._touchIsEmulatedEvent(b) || (a.__pointerIsOverOrigin = !0,
  6822.                     a._openShortly(b))
  6823.                 })
  6824.             }
  6825.             if (a.__options.triggerClose.mouseleave || a.__options.triggerClose.touchleave && h.hasTouchCapability) {
  6826.                 var b = "";
  6827.                 a.__options.triggerClose.mouseleave && (b += "mouseleave." + a.__namespace + "-triggerOpen "),
  6828.                 a.__options.triggerClose.touchleave && h.hasTouchCapability && (b += "touchend." + a.__namespace + "-triggerOpen touchcancel." + a.__namespace + "-triggerOpen"),
  6829.                 a._$origin.on(b, function(b) {
  6830.                     a._touchIsMeaningfulEvent(b) && (a.__pointerIsOverOrigin = !1)
  6831.                 })
  6832.             }
  6833.             return a
  6834.         },
  6835.         __prepareTooltip: function() {
  6836.             var b = this
  6837.               , c = b.__options.interactive ? "auto" : "";
  6838.             return b._$tooltip.attr("id", b.__namespace).css({
  6839.                 "pointer-events": c,
  6840.                 zIndex: b.__options.zIndex
  6841.             }),
  6842.             a.each(b.__previousThemes, function(a, c) {
  6843.                 b._$tooltip.removeClass(c)
  6844.             }),
  6845.             a.each(b.__options.theme, function(a, c) {
  6846.                 b._$tooltip.addClass(c)
  6847.             }),
  6848.             b.__previousThemes = a.merge([], b.__options.theme),
  6849.             b
  6850.         },
  6851.         __scrollHandler: function(b) {
  6852.             var c = this;
  6853.             if (c.__options.triggerClose.scroll)
  6854.                 c._close(b);
  6855.             else if (d(c._$origin) && d(c._$tooltip)) {
  6856.                 var e = null;
  6857.                 if (b.target === h.window.document)
  6858.                     c.__Geometry.origin.fixedLineage || c.__options.repositionOnScroll && c.reposition(b);
  6859.                 else {
  6860.                     e = c.__geometry();
  6861.                     var f = !1;
  6862.                     if ("fixed" != c._$origin.css("position") && c.__$originParents.each(function(b, c) {
  6863.                         var d = a(c)
  6864.                           , g = d.css("overflow-x")
  6865.                           , h = d.css("overflow-y");
  6866.                         if ("visible" != g || "visible" != h) {
  6867.                             var i = c.getBoundingClientRect();
  6868.                             if ("visible" != g && (e.origin.windowOffset.left < i.left || e.origin.windowOffset.right > i.right))
  6869.                                 return f = !0,
  6870.                                 !1;
  6871.                             if ("visible" != h && (e.origin.windowOffset.top < i.top || e.origin.windowOffset.bottom > i.bottom))
  6872.                                 return f = !0,
  6873.                                 !1
  6874.                         }
  6875.                         return "fixed" == d.css("position") ? !1 : void 0
  6876.                     }),
  6877.                     f)
  6878.                         c._$tooltip.css("visibility", "hidden");
  6879.                     else if (c._$tooltip.css("visibility", "visible"),
  6880.                     c.__options.repositionOnScroll)
  6881.                         c.reposition(b);
  6882.                     else {
  6883.                         var g = e.origin.offset.left - c.__Geometry.origin.offset.left
  6884.                           , i = e.origin.offset.top - c.__Geometry.origin.offset.top;
  6885.                         c._$tooltip.css({
  6886.                             left: c.__lastPosition.coord.left + g,
  6887.                             top: c.__lastPosition.coord.top + i
  6888.                         })
  6889.                     }
  6890.                 }
  6891.                 c._trigger({
  6892.                     type: "scroll",
  6893.                     event: b,
  6894.                     geo: e
  6895.                 })
  6896.             }
  6897.             return c
  6898.         },
  6899.         __stateSet: function(a) {
  6900.             return this.__state = a,
  6901.             this._trigger({
  6902.                 type: "state",
  6903.                 state: a
  6904.             }),
  6905.             this
  6906.         },
  6907.         __timeoutsClear: function() {
  6908.             return clearTimeout(this.__timeouts.open),
  6909.             this.__timeouts.open = null,
  6910.             a.each(this.__timeouts.close, function(a, b) {
  6911.                 clearTimeout(b)
  6912.             }),
  6913.             this.__timeouts.close = [],
  6914.             this
  6915.         },
  6916.         __trackerStart: function() {
  6917.             var a = this
  6918.               , b = a._$tooltip.find(".tooltipster-content");
  6919.             return a.__options.trackTooltip && (a.__contentBcr = b[0].getBoundingClientRect()),
  6920.             a.__tracker = setInterval(function() {
  6921.                 if (d(a._$origin) && d(a._$tooltip)) {
  6922.                     if (a.__options.trackOrigin) {
  6923.                         var e = a.__geometry()
  6924.                           , f = !1;
  6925.                         c(e.origin.size, a.__Geometry.origin.size) && (a.__Geometry.origin.fixedLineage ? c(e.origin.windowOffset, a.__Geometry.origin.windowOffset) && (f = !0) : c(e.origin.offset, a.__Geometry.origin.offset) && (f = !0)),
  6926.                         f || (a.__options.triggerClose.mouseleave ? a._close() : a.reposition())
  6927.                     }
  6928.                     if (a.__options.trackTooltip) {
  6929.                         var g = b[0].getBoundingClientRect();
  6930.                         g.height === a.__contentBcr.height && g.width === a.__contentBcr.width || (a.reposition(),
  6931.                         a.__contentBcr = g)
  6932.                     }
  6933.                 } else
  6934.                     a._close()
  6935.             }, a.__options.trackerInterval),
  6936.             a
  6937.         },
  6938.         _close: function(b, c, d) {
  6939.             var e = this
  6940.               , f = !0;
  6941.             if (e._trigger({
  6942.                 type: "close",
  6943.                 event: b,
  6944.                 stop: function() {
  6945.                     f = !1
  6946.                 }
  6947.             }),
  6948.             f || d) {
  6949.                 c && e.__callbacks.close.push(c),
  6950.                 e.__callbacks.open = [],
  6951.                 e.__timeoutsClear();
  6952.                 var g = function() {
  6953.                     a.each(e.__callbacks.close, function(a, c) {
  6954.                         c.call(e, e, {
  6955.                             event: b,
  6956.                             origin: e._$origin[0]
  6957.                         })
  6958.                     }),
  6959.                     e.__callbacks.close = []
  6960.                 };
  6961.                 if ("closed" != e.__state) {
  6962.                     var i = !0
  6963.                       , j = new Date
  6964.                       , k = j.getTime()
  6965.                       , l = k + e.__options.animationDuration[1];
  6966.                     if ("disappearing" == e.__state && l > e.__closingTime && e.__options.animationDuration[1] > 0 && (i = !1),
  6967.                     i) {
  6968.                         e.__closingTime = l,
  6969.                         "disappearing" != e.__state && e.__stateSet("disappearing");
  6970.                         var m = function() {
  6971.                             clearInterval(e.__tracker),
  6972.                             e._trigger({
  6973.                                 type: "closing",
  6974.                                 event: b
  6975.                             }),
  6976.                             e._$tooltip.off("." + e.__namespace + "-triggerClose").removeClass("tooltipster-dying"),
  6977.                             a(h.window).off("." + e.__namespace + "-triggerClose"),
  6978.                             e.__$originParents.each(function(b, c) {
  6979.                                 a(c).off("scroll." + e.__namespace + "-triggerClose")
  6980.                             }),
  6981.                             e.__$originParents = null,
  6982.                             a(h.window.document.body).off("." + e.__namespace + "-triggerClose"),
  6983.                             e._$origin.off("." + e.__namespace + "-triggerClose"),
  6984.                             e._off("dismissable"),
  6985.                             e.__stateSet("closed"),
  6986.                             e._trigger({
  6987.                                 type: "after",
  6988.                                 event: b
  6989.                             }),
  6990.                             e.__options.functionAfter && e.__options.functionAfter.call(e, e, {
  6991.                                 event: b,
  6992.                                 origin: e._$origin[0]
  6993.                             }),
  6994.                             g()
  6995.                         };
  6996.                         h.hasTransitions ? (e._$tooltip.css({
  6997.                             "-moz-animation-duration": e.__options.animationDuration[1] + "ms",
  6998.                             "-ms-animation-duration": e.__options.animationDuration[1] + "ms",
  6999.                             "-o-animation-duration": e.__options.animationDuration[1] + "ms",
  7000.                             "-webkit-animation-duration": e.__options.animationDuration[1] + "ms",
  7001.                             "animation-duration": e.__options.animationDuration[1] + "ms",
  7002.                             "transition-duration": e.__options.animationDuration[1] + "ms"
  7003.                         }),
  7004.                         e._$tooltip.clearQueue().removeClass("tooltipster-show").addClass("tooltipster-dying"),
  7005.                         e.__options.animationDuration[1] > 0 && e._$tooltip.delay(e.__options.animationDuration[1]),
  7006.                         e._$tooltip.queue(m)) : e._$tooltip.stop().fadeOut(e.__options.animationDuration[1], m)
  7007.                     }
  7008.                 } else
  7009.                     g()
  7010.             }
  7011.             return e
  7012.         },
  7013.         _off: function() {
  7014.             return this.__$emitterPrivate.off.apply(this.__$emitterPrivate, Array.prototype.slice.apply(arguments)),
  7015.             this
  7016.         },
  7017.         _on: function() {
  7018.             return this.__$emitterPrivate.on.apply(this.__$emitterPrivate, Array.prototype.slice.apply(arguments)),
  7019.             this
  7020.         },
  7021.         _one: function() {
  7022.             return this.__$emitterPrivate.one.apply(this.__$emitterPrivate, Array.prototype.slice.apply(arguments)),
  7023.             this
  7024.         },
  7025.         _open: function(b, c) {
  7026.             var e = this;
  7027.             if (!e.__destroying && d(e._$origin) && e.__enabled) {
  7028.                 var f = !0;
  7029.                 if ("closed" == e.__state && (e._trigger({
  7030.                     type: "before",
  7031.                     event: b,
  7032.                     stop: function() {
  7033.                         f = !1
  7034.                     }
  7035.                 }),
  7036.                 f && e.__options.functionBefore && (f = e.__options.functionBefore.call(e, e, {
  7037.                     event: b,
  7038.                     origin: e._$origin[0]
  7039.                 }))),
  7040.                 f !== !1 && null !== e.__Content) {
  7041.                     c && e.__callbacks.open.push(c),
  7042.                     e.__callbacks.close = [],
  7043.                     e.__timeoutsClear();
  7044.                     var g, i = function() {
  7045.                         "stable" != e.__state && e.__stateSet("stable"),
  7046.                         a.each(e.__callbacks.open, function(a, b) {
  7047.                             b.call(e, e, {
  7048.                                 origin: e._$origin[0],
  7049.                                 tooltip: e._$tooltip[0]
  7050.                             })
  7051.                         }),
  7052.                         e.__callbacks.open = []
  7053.                     };
  7054.                     if ("closed" !== e.__state)
  7055.                         g = 0,
  7056.                         "disappearing" === e.__state ? (e.__stateSet("appearing"),
  7057.                         h.hasTransitions ? (e._$tooltip.clearQueue().removeClass("tooltipster-dying").addClass("tooltipster-show"),
  7058.                         e.__options.animationDuration[0] > 0 && e._$tooltip.delay(e.__options.animationDuration[0]),
  7059.                         e._$tooltip.queue(i)) : e._$tooltip.stop().fadeIn(i)) : "stable" == e.__state && i();
  7060.                     else {
  7061.                         if (e.__stateSet("appearing"),
  7062.                         g = e.__options.animationDuration[0],
  7063.                         e.__contentInsert(),
  7064.                         e.reposition(b, !0),
  7065.                         h.hasTransitions ? (e._$tooltip.addClass("tooltipster-" + e.__options.animation).addClass("tooltipster-initial").css({
  7066.                             "-moz-animation-duration": e.__options.animationDuration[0] + "ms",
  7067.                             "-ms-animation-duration": e.__options.animationDuration[0] + "ms",
  7068.                             "-o-animation-duration": e.__options.animationDuration[0] + "ms",
  7069.                             "-webkit-animation-duration": e.__options.animationDuration[0] + "ms",
  7070.                             "animation-duration": e.__options.animationDuration[0] + "ms",
  7071.                             "transition-duration": e.__options.animationDuration[0] + "ms"
  7072.                         }),
  7073.                         setTimeout(function() {
  7074.                             "closed" != e.__state && (e._$tooltip.addClass("tooltipster-show").removeClass("tooltipster-initial"),
  7075.                             e.__options.animationDuration[0] > 0 && e._$tooltip.delay(e.__options.animationDuration[0]),
  7076.                             e._$tooltip.queue(i))
  7077.                         }, 0)) : e._$tooltip.css("display", "none").fadeIn(e.__options.animationDuration[0], i),
  7078.                         e.__trackerStart(),
  7079.                         a(h.window).on("resize." + e.__namespace + "-triggerClose", function(b) {
  7080.                             var c = a(document.activeElement);
  7081.                             (c.is("input") || c.is("textarea")) && a.contains(e._$tooltip[0], c[0]) || e.reposition(b)
  7082.                         }).on("scroll." + e.__namespace + "-triggerClose", function(a) {
  7083.                             e.__scrollHandler(a)
  7084.                         }),
  7085.                         e.__$originParents = e._$origin.parents(),
  7086.                         e.__$originParents.each(function(b, c) {
  7087.                             a(c).on("scroll." + e.__namespace + "-triggerClose", function(a) {
  7088.                                 e.__scrollHandler(a)
  7089.                             })
  7090.                         }),
  7091.                         e.__options.triggerClose.mouseleave || e.__options.triggerClose.touchleave && h.hasTouchCapability) {
  7092.                             e._on("dismissable", function(a) {
  7093.                                 a.dismissable ? a.delay ? (m = setTimeout(function() {
  7094.                                     e._close(a.event)
  7095.                                 }, a.delay),
  7096.                                 e.__timeouts.close.push(m)) : e._close(a) : clearTimeout(m)
  7097.                             });
  7098.                             var j = e._$origin
  7099.                               , k = ""
  7100.                               , l = ""
  7101.                               , m = null;
  7102.                             e.__options.interactive && (j = j.add(e._$tooltip)),
  7103.                             e.__options.triggerClose.mouseleave && (k += "mouseenter." + e.__namespace + "-triggerClose ",
  7104.                             l += "mouseleave." + e.__namespace + "-triggerClose "),
  7105.                             e.__options.triggerClose.touchleave && h.hasTouchCapability && (k += "touchstart." + e.__namespace + "-triggerClose",
  7106.                             l += "touchend." + e.__namespace + "-triggerClose touchcancel." + e.__namespace + "-triggerClose"),
  7107.                             j.on(l, function(a) {
  7108.                                 if (e._touchIsTouchEvent(a) || !e._touchIsEmulatedEvent(a)) {
  7109.                                     var b = "mouseleave" == a.type ? e.__options.delay : e.__options.delayTouch;
  7110.                                     e._trigger({
  7111.                                         delay: b[1],
  7112.                                         dismissable: !0,
  7113.                                         event: a,
  7114.                                         type: "dismissable"
  7115.                                     })
  7116.                                 }
  7117.                             }).on(k, function(a) {
  7118.                                 !e._touchIsTouchEvent(a) && e._touchIsEmulatedEvent(a) || e._trigger({
  7119.                                     dismissable: !1,
  7120.                                     event: a,
  7121.                                     type: "dismissable"
  7122.                                 })
  7123.                             })
  7124.                         }
  7125.                         e.__options.triggerClose.originClick && e._$origin.on("click." + e.__namespace + "-triggerClose", function(a) {
  7126.                             e._touchIsTouchEvent(a) || e._touchIsEmulatedEvent(a) || e._close(a)
  7127.                         }),
  7128.                         (e.__options.triggerClose.click || e.__options.triggerClose.tap && h.hasTouchCapability) && setTimeout(function() {
  7129.                             if ("closed" != e.__state) {
  7130.                                 var b = ""
  7131.                                   , c = a(h.window.document.body);
  7132.                                 e.__options.triggerClose.click && (b += "click." + e.__namespace + "-triggerClose "),
  7133.                                 e.__options.triggerClose.tap && h.hasTouchCapability && (b += "touchend." + e.__namespace + "-triggerClose"),
  7134.                                 c.on(b, function(b) {
  7135.                                     e._touchIsMeaningfulEvent(b) && (e._touchRecordEvent(b),
  7136.                                     e.__options.interactive && a.contains(e._$tooltip[0], b.target) || e._close(b))
  7137.                                 }),
  7138.                                 e.__options.triggerClose.tap && h.hasTouchCapability && c.on("touchstart." + e.__namespace + "-triggerClose", function(a) {
  7139.                                     e._touchRecordEvent(a)
  7140.                                 })
  7141.                             }
  7142.                         }, 0),
  7143.                         e._trigger("ready"),
  7144.                         e.__options.functionReady && e.__options.functionReady.call(e, e, {
  7145.                             origin: e._$origin[0],
  7146.                             tooltip: e._$tooltip[0]
  7147.                         })
  7148.                     }
  7149.                     if (e.__options.timer > 0) {
  7150.                         var m = setTimeout(function() {
  7151.                             e._close()
  7152.                         }, e.__options.timer + g);
  7153.                         e.__timeouts.close.push(m)
  7154.                     }
  7155.                 }
  7156.             }
  7157.             return e
  7158.         },
  7159.         _openShortly: function(a) {
  7160.             var b = this
  7161.               , c = !0;
  7162.             if ("stable" != b.__state && "appearing" != b.__state && !b.__timeouts.open && (b._trigger({
  7163.                 type: "start",
  7164.                 event: a,
  7165.                 stop: function() {
  7166.                     c = !1
  7167.                 }
  7168.             }),
  7169.             c)) {
  7170.                 var d = 0 == a.type.indexOf("touch") ? b.__options.delayTouch : b.__options.delay;
  7171.                 d[0] ? b.__timeouts.open = setTimeout(function() {
  7172.                     b.__timeouts.open = null,
  7173.                     b.__pointerIsOverOrigin && b._touchIsMeaningfulEvent(a) ? (b._trigger("startend"),
  7174.                     b._open(a)) : b._trigger("startcancel")
  7175.                 }, d[0]) : (b._trigger("startend"),
  7176.                 b._open(a))
  7177.             }
  7178.             return b
  7179.         },
  7180.         _optionsExtract: function(b, c) {
  7181.             var d = this
  7182.               , e = a.extend(!0, {}, c)
  7183.               , f = d.__options[b];
  7184.             return f || (f = {},
  7185.             a.each(c, function(a, b) {
  7186.                 var c = d.__options[a];
  7187.                 void 0 !== c && (f[a] = c)
  7188.             })),
  7189.             a.each(e, function(b, c) {
  7190.                 void 0 !== f[b] && ("object" != typeof c || c instanceof Array || null == c || "object" != typeof f[b] || f[b]instanceof Array || null == f[b] ? e[b] = f[b] : a.extend(e[b], f[b]))
  7191.             }),
  7192.             e
  7193.         },
  7194.         _plug: function(b) {
  7195.             var c = a.tooltipster._plugin(b);
  7196.             if (!c)
  7197.                 throw new Error('The "' + b + '" plugin is not defined');
  7198.             return c.instance && a.tooltipster.__bridge(c.instance, this, c.name),
  7199.             this
  7200.         },
  7201.         _touchIsEmulatedEvent: function(a) {
  7202.             for (var b = !1, c = (new Date).getTime(), d = this.__touchEvents.length - 1; d >= 0; d--) {
  7203.                 var e = this.__touchEvents[d];
  7204.                 if (!(c - e.time < 500))
  7205.                     break;
  7206.                 e.target === a.target && (b = !0)
  7207.             }
  7208.             return b
  7209.         },
  7210.         _touchIsMeaningfulEvent: function(a) {
  7211.             return this._touchIsTouchEvent(a) && !this._touchSwiped(a.target) || !this._touchIsTouchEvent(a) && !this._touchIsEmulatedEvent(a)
  7212.         },
  7213.         _touchIsTouchEvent: function(a) {
  7214.             return 0 == a.type.indexOf("touch")
  7215.         },
  7216.         _touchRecordEvent: function(a) {
  7217.             return this._touchIsTouchEvent(a) && (a.time = (new Date).getTime(),
  7218.             this.__touchEvents.push(a)),
  7219.             this
  7220.         },
  7221.         _touchSwiped: function(a) {
  7222.             for (var b = !1, c = this.__touchEvents.length - 1; c >= 0; c--) {
  7223.                 var d = this.__touchEvents[c];
  7224.                 if ("touchmove" == d.type) {
  7225.                     b = !0;
  7226.                     break
  7227.                 }
  7228.                 if ("touchstart" == d.type && a === d.target)
  7229.                     break
  7230.             }
  7231.             return b
  7232.         },
  7233.         _trigger: function() {
  7234.             var b = Array.prototype.slice.apply(arguments);
  7235.             return "string" == typeof b[0] && (b[0] = {
  7236.                 type: b[0]
  7237.             }),
  7238.             b[0].instance = this,
  7239.             b[0].origin = this._$origin ? this._$origin[0] : null,
  7240.             b[0].tooltip = this._$tooltip ? this._$tooltip[0] : null,
  7241.             this.__$emitterPrivate.trigger.apply(this.__$emitterPrivate, b),
  7242.             a.tooltipster._trigger.apply(a.tooltipster, b),
  7243.             this.__$emitterPublic.trigger.apply(this.__$emitterPublic, b),
  7244.             this
  7245.         },
  7246.         _unplug: function(b) {
  7247.             var c = this;
  7248.             if (c[b]) {
  7249.                 var d = a.tooltipster._plugin(b);
  7250.                 d.instance && a.each(d.instance, function(a, d) {
  7251.                     c[a] && c[a].bridged === c[b] && delete c[a]
  7252.                 }),
  7253.                 c[b].__destroy && c[b].__destroy(),
  7254.                 delete c[b]
  7255.             }
  7256.             return c
  7257.         },
  7258.         close: function(a) {
  7259.             return this.__destroyed ? this.__destroyError() : this._close(null, a),
  7260.             this
  7261.         },
  7262.         content: function(a) {
  7263.             var b = this;
  7264.             if (void 0 === a)
  7265.                 return b.__Content;
  7266.             if (b.__destroyed)
  7267.                 b.__destroyError();
  7268.             else if (b.__contentSet(a),
  7269.             null !== b.__Content) {
  7270.                 if ("closed" !== b.__state && (b.__contentInsert(),
  7271.                 b.reposition(),
  7272.                 b.__options.updateAnimation))
  7273.                     if (h.hasTransitions) {
  7274.                         var c = b.__options.updateAnimation;
  7275.                         b._$tooltip.addClass("tooltipster-update-" + c),
  7276.                         setTimeout(function() {
  7277.                             "closed" != b.__state && b._$tooltip.removeClass("tooltipster-update-" + c)
  7278.                         }, 1e3)
  7279.                     } else
  7280.                         b._$tooltip.fadeTo(200, .5, function() {
  7281.                             "closed" != b.__state && b._$tooltip.fadeTo(200, 1)
  7282.                         })
  7283.             } else
  7284.                 b._close();
  7285.             return b
  7286.         },
  7287.         destroy: function() {
  7288.             var b = this;
  7289.             if (b.__destroyed)
  7290.                 b.__destroyError();
  7291.             else {
  7292.                 "closed" != b.__state ? b.option("animationDuration", 0)._close(null, null, !0) : b.__timeoutsClear(),
  7293.                 b._trigger("destroy"),
  7294.                 b.__destroyed = !0,
  7295.                 b._$origin.removeData(b.__namespace).off("." + b.__namespace + "-triggerOpen"),
  7296.                 a(h.window.document.body).off("." + b.__namespace + "-triggerOpen");
  7297.                 var c = b._$origin.data("tooltipster-ns");
  7298.                 if (c)
  7299.                     if (1 === c.length) {
  7300.                         var d = null;
  7301.                         "previous" == b.__options.restoration ? d = b._$origin.data("tooltipster-initialTitle") : "current" == b.__options.restoration && (d = "string" == typeof b.__Content ? b.__Content : a("<div></div>").append(b.__Content).html()),
  7302.                         d && b._$origin.attr("title", d),
  7303.                         b._$origin.removeClass("tooltipstered"),
  7304.                         b._$origin.removeData("tooltipster-ns").removeData("tooltipster-initialTitle")
  7305.                     } else
  7306.                         c = a.grep(c, function(a, c) {
  7307.                             return a !== b.__namespace
  7308.                         }),
  7309.                         b._$origin.data("tooltipster-ns", c);
  7310.                 b._trigger("destroyed"),
  7311.                 b._off(),
  7312.                 b.off(),
  7313.                 b.__Content = null,
  7314.                 b.__$emitterPrivate = null,
  7315.                 b.__$emitterPublic = null,
  7316.                 b.__options.parent = null,
  7317.                 b._$origin = null,
  7318.                 b._$tooltip = null,
  7319.                 a.tooltipster.__instancesLatestArr = a.grep(a.tooltipster.__instancesLatestArr, function(a, c) {
  7320.                     return b !== a
  7321.                 }),
  7322.                 clearInterval(b.__garbageCollector)
  7323.             }
  7324.             return b
  7325.         },
  7326.         disable: function() {
  7327.             return this.__destroyed ? (this.__destroyError(),
  7328.             this) : (this._close(),
  7329.             this.__enabled = !1,
  7330.             this)
  7331.         },
  7332.         elementOrigin: function() {
  7333.             return this.__destroyed ? void this.__destroyError() : this._$origin[0]
  7334.         },
  7335.         elementTooltip: function() {
  7336.             return this._$tooltip ? this._$tooltip[0] : null
  7337.         },
  7338.         enable: function() {
  7339.             return this.__enabled = !0,
  7340.             this
  7341.         },
  7342.         hide: function(a) {
  7343.             return this.close(a)
  7344.         },
  7345.         instance: function() {
  7346.             return this
  7347.         },
  7348.         off: function() {
  7349.             return this.__destroyed || this.__$emitterPublic.off.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  7350.             this
  7351.         },
  7352.         on: function() {
  7353.             return this.__destroyed ? this.__destroyError() : this.__$emitterPublic.on.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  7354.             this
  7355.         },
  7356.         one: function() {
  7357.             return this.__destroyed ? this.__destroyError() : this.__$emitterPublic.one.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  7358.             this
  7359.         },
  7360.         open: function(a) {
  7361.             return this.__destroyed ? this.__destroyError() : this._open(null, a),
  7362.             this
  7363.         },
  7364.         option: function(b, c) {
  7365.             return void 0 === c ? this.__options[b] : (this.__destroyed ? this.__destroyError() : (this.__options[b] = c,
  7366.             this.__optionsFormat(),
  7367.             a.inArray(b, ["trigger", "triggerClose", "triggerOpen"]) >= 0 && this.__prepareOrigin(),
  7368.             "selfDestruction" === b && this.__prepareGC()),
  7369.             this)
  7370.         },
  7371.         reposition: function(a, b) {
  7372.             var c = this;
  7373.             return c.__destroyed ? c.__destroyError() : "closed" != c.__state && d(c._$origin) && (b || d(c._$tooltip)) && (b || c._$tooltip.detach(),
  7374.             c.__Geometry = c.__geometry(),
  7375.             c._trigger({
  7376.                 type: "reposition",
  7377.                 event: a,
  7378.                 helper: {
  7379.                     geo: c.__Geometry
  7380.                 }
  7381.             })),
  7382.             c
  7383.         },
  7384.         show: function(a) {
  7385.             return this.open(a)
  7386.         },
  7387.         status: function() {
  7388.             return {
  7389.                 destroyed: this.__destroyed,
  7390.                 enabled: this.__enabled,
  7391.                 open: "closed" !== this.__state,
  7392.                 state: this.__state
  7393.             }
  7394.         },
  7395.         triggerHandler: function() {
  7396.             return this.__destroyed ? this.__destroyError() : this.__$emitterPublic.triggerHandler.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments)),
  7397.             this
  7398.         }
  7399.     },
  7400.     a.fn.tooltipster = function() {
  7401.         var b = Array.prototype.slice.apply(arguments)
  7402.           , c = "You are using a single HTML element as content for several tooltips. You probably want to set the contentCloning option to TRUE.";
  7403.         if (0 === this.length)
  7404.             return this;
  7405.         if ("string" == typeof b[0]) {
  7406.             var d = "#*$~&";
  7407.             return this.each(function() {
  7408.                 var e = a(this).data("tooltipster-ns")
  7409.                   , f = e ? a(this).data(e[0]) : null;
  7410.                 if (!f)
  7411.                     throw new Error("You called Tooltipster's \"" + b[0] + '" method on an uninitialized element');
  7412.                 if ("function" != typeof f[b[0]])
  7413.                     throw new Error('Unknown method "' + b[0] + '"');
  7414.                 this.length > 1 && "content" == b[0] && (b[1]instanceof a || "object" == typeof b[1] && null != b[1] && b[1].tagName) && !f.__options.contentCloning && f.__options.debug && console.log(c);
  7415.                 var g = f[b[0]](b[1], b[2]);
  7416.                 return g !== f || "instance" === b[0] ? (d = g,
  7417.                 !1) : void 0
  7418.             }),
  7419.             "#*$~&" !== d ? d : this
  7420.         }
  7421.         a.tooltipster.__instancesLatestArr = [];
  7422.         var e = b[0] && void 0 !== b[0].multiple
  7423.           , g = e && b[0].multiple || !e && f.multiple
  7424.           , h = b[0] && void 0 !== b[0].content
  7425.           , i = h && b[0].content || !h && f.content
  7426.           , j = b[0] && void 0 !== b[0].contentCloning
  7427.           , k = j && b[0].contentCloning || !j && f.contentCloning
  7428.           , l = b[0] && void 0 !== b[0].debug
  7429.           , m = l && b[0].debug || !l && f.debug;
  7430.         return this.length > 1 && (i instanceof a || "object" == typeof i && null != i && i.tagName) && !k && m && console.log(c),
  7431.         this.each(function() {
  7432.             var c = !1
  7433.               , d = a(this)
  7434.               , e = d.data("tooltipster-ns")
  7435.               , f = null;
  7436.             e ? g ? c = !0 : m && (console.log("Tooltipster: one or more tooltips are already attached to the element below. Ignoring."),
  7437.             console.log(this)) : c = !0,
  7438.             c && (f = new a.Tooltipster(this,b[0]),
  7439.             e || (e = []),
  7440.             e.push(f.__namespace),
  7441.             d.data("tooltipster-ns", e),
  7442.             d.data(f.__namespace, f),
  7443.             f.__options.functionInit && f.__options.functionInit.call(f, f, {
  7444.                 origin: this
  7445.             }),
  7446.             f._trigger("init")),
  7447.             a.tooltipster.__instancesLatestArr.push(f)
  7448.         }),
  7449.         this
  7450.     }
  7451.     ,
  7452.     b.prototype = {
  7453.         __init: function(b) {
  7454.             this.__$tooltip = b,
  7455.             this.__$tooltip.css({
  7456.                 left: 0,
  7457.                 overflow: "hidden",
  7458.                 position: "absolute",
  7459.                 top: 0
  7460.             }).find(".tooltipster-content").css("overflow", "auto"),
  7461.             this.$container = a('<div class="tooltipster-ruler"></div>').append(this.__$tooltip).appendTo(h.window.document.body)
  7462.         },
  7463.         __forceRedraw: function() {
  7464.             var a = this.__$tooltip.parent();
  7465.             this.__$tooltip.detach(),
  7466.             this.__$tooltip.appendTo(a)
  7467.         },
  7468.         constrain: function(a, b) {
  7469.             return this.constraints = {
  7470.                 width: a,
  7471.                 height: b
  7472.             },
  7473.             this.__$tooltip.css({
  7474.                 display: "block",
  7475.                 height: "",
  7476.                 overflow: "auto",
  7477.                 width: a
  7478.             }),
  7479.             this
  7480.         },
  7481.         destroy: function() {
  7482.             this.__$tooltip.detach().find(".tooltipster-content").css({
  7483.                 display: "",
  7484.                 overflow: ""
  7485.             }),
  7486.             this.$container.remove()
  7487.         },
  7488.         free: function() {
  7489.             return this.constraints = null,
  7490.             this.__$tooltip.css({
  7491.                 display: "",
  7492.                 height: "",
  7493.                 overflow: "visible",
  7494.                 width: ""
  7495.             }),
  7496.             this
  7497.         },
  7498.         measure: function() {
  7499.             this.__forceRedraw();
  7500.             var a = this.__$tooltip[0].getBoundingClientRect()
  7501.               , b = {
  7502.                 size: {
  7503.                     height: a.height || a.bottom - a.top,
  7504.                     width: a.width || a.right - a.left
  7505.                 }
  7506.             };
  7507.             if (this.constraints) {
  7508.                 var c = this.__$tooltip.find(".tooltipster-content")
  7509.                   , d = this.__$tooltip.outerHeight()
  7510.                   , e = c[0].getBoundingClientRect()
  7511.                   , f = {
  7512.                     height: d <= this.constraints.height,
  7513.                     width: a.width <= this.constraints.width && e.width >= c[0].scrollWidth - 1
  7514.                 };
  7515.                 b.fits = f.height && f.width
  7516.             }
  7517.             return h.IE && h.IE <= 11 && b.size.width !== h.window.document.documentElement.clientWidth && (b.size.width = Math.ceil(b.size.width) + 1),
  7518.             b
  7519.         }
  7520.     };
  7521.     var j = navigator.userAgent.toLowerCase();
  7522.     -1 != j.indexOf("msie") ? h.IE = parseInt(j.split("msie")[1]) : -1 !== j.toLowerCase().indexOf("trident") && -1 !== j.indexOf(" rv:11") ? h.IE = 11 : -1 != j.toLowerCase().indexOf("edge/") && (h.IE = parseInt(j.toLowerCase().split("edge/")[1]));
  7523.     var k = "tooltipster.sideTip";
  7524.     return a.tooltipster._plugin({
  7525.         name: k,
  7526.         instance: {
  7527.             __defaults: function() {
  7528.                 return {
  7529.                     arrow: !0,
  7530.                     distance: 6,
  7531.                     functionPosition: null,
  7532.                     maxWidth: null,
  7533.                     minIntersection: 16,
  7534.                     minWidth: 0,
  7535.                     position: null,
  7536.                     side: "top",
  7537.                     viewportAware: !0
  7538.                 }
  7539.             },
  7540.             __init: function(a) {
  7541.                 var b = this;
  7542.                 b.__instance = a,
  7543.                 b.__namespace = "tooltipster-sideTip-" + Math.round(1e6 * Math.random()),
  7544.                 b.__previousState = "closed",
  7545.                 b.__options,
  7546.                 b.__optionsFormat(),
  7547.                 b.__instance._on("state." + b.__namespace, function(a) {
  7548.                     "closed" == a.state ? b.__close() : "appearing" == a.state && "closed" == b.__previousState && b.__create(),
  7549.                     b.__previousState = a.state
  7550.                 }),
  7551.                 b.__instance._on("options." + b.__namespace, function() {
  7552.                     b.__optionsFormat()
  7553.                 }),
  7554.                 b.__instance._on("reposition." + b.__namespace, function(a) {
  7555.                     b.__reposition(a.event, a.helper)
  7556.                 })
  7557.             },
  7558.             __close: function() {
  7559.                 this.__instance.content()instanceof a && this.__instance.content().detach(),
  7560.                 this.__instance._$tooltip.remove(),
  7561.                 this.__instance._$tooltip = null
  7562.             },
  7563.             __create: function() {
  7564.                 var b = a('<div class="tooltipster-base tooltipster-sidetip"><div class="tooltipster-box"><div class="tooltipster-content"></div></div><div class="tooltipster-arrow"><div class="tooltipster-arrow-uncropped"><div class="tooltipster-arrow-border"></div><div class="tooltipster-arrow-background"></div></div></div></div>');
  7565.                 this.__options.arrow || b.find(".tooltipster-box").css("margin", 0).end().find(".tooltipster-arrow").hide(),
  7566.                 this.__options.minWidth && b.css("min-width", this.__options.minWidth + "px"),
  7567.                 this.__options.maxWidth && b.css("max-width", this.__options.maxWidth + "px"),
  7568.                 this.__instance._$tooltip = b,
  7569.                 this.__instance._trigger("created")
  7570.             },
  7571.             __destroy: function() {
  7572.                 this.__instance._off("." + self.__namespace)
  7573.             },
  7574.             __optionsFormat: function() {
  7575.                 var b = this;
  7576.                 if (b.__options = b.__instance._optionsExtract(k, b.__defaults()),
  7577.                 b.__options.position && (b.__options.side = b.__options.position),
  7578.                 "object" != typeof b.__options.distance && (b.__options.distance = [b.__options.distance]),
  7579.                 b.__options.distance.length < 4 && (void 0 === b.__options.distance[1] && (b.__options.distance[1] = b.__options.distance[0]),
  7580.                 void 0 === b.__options.distance[2] && (b.__options.distance[2] = b.__options.distance[0]),
  7581.                 void 0 === b.__options.distance[3] && (b.__options.distance[3] = b.__options.distance[1]),
  7582.                 b.__options.distance = {
  7583.                     top: b.__options.distance[0],
  7584.                     right: b.__options.distance[1],
  7585.                     bottom: b.__options.distance[2],
  7586.                     left: b.__options.distance[3]
  7587.                 }),
  7588.                 "string" == typeof b.__options.side) {
  7589.                     var c = {
  7590.                         top: "bottom",
  7591.                         right: "left",
  7592.                         bottom: "top",
  7593.                         left: "right"
  7594.                     };
  7595.                     b.__options.side = [b.__options.side, c[b.__options.side]],
  7596.                     "left" == b.__options.side[0] || "right" == b.__options.side[0] ? b.__options.side.push("top", "bottom") : b.__options.side.push("right", "left")
  7597.                 }
  7598.                 6 === a.tooltipster._env.IE && b.__options.arrow !== !0 && (b.__options.arrow = !1)
  7599.             },
  7600.             __reposition: function(b, c) {
  7601.                 var d, e = this, f = e.__targetFind(c), g = [];
  7602.                 e.__instance._$tooltip.detach();
  7603.                 var h = e.__instance._$tooltip.clone()
  7604.                   , i = a.tooltipster._getRuler(h)
  7605.                   , j = !1
  7606.                   , k = e.__instance.option("animation");
  7607.                 switch (k && h.removeClass("tooltipster-" + k),
  7608.                 a.each(["window", "document"], function(d, k) {
  7609.                     var l = null;
  7610.                     if (e.__instance._trigger({
  7611.                         container: k,
  7612.                         helper: c,
  7613.                         satisfied: j,
  7614.                         takeTest: function(a) {
  7615.                             l = a
  7616.                         },
  7617.                         results: g,
  7618.                         type: "positionTest"
  7619.                     }),
  7620.                     1 == l || 0 != l && 0 == j && ("window" != k || e.__options.viewportAware))
  7621.                         for (var d = 0; d < e.__options.side.length; d++) {
  7622.                             var m = {
  7623.                                 horizontal: 0,
  7624.                                 vertical: 0
  7625.                             }
  7626.                               , n = e.__options.side[d];
  7627.                             "top" == n || "bottom" == n ? m.vertical = e.__options.distance[n] : m.horizontal = e.__options.distance[n],
  7628.                             e.__sideChange(h, n),
  7629.                             a.each(["natural", "constrained"], function(a, d) {
  7630.                                 if (l = null,
  7631.                                 e.__instance._trigger({
  7632.                                     container: k,
  7633.                                     event: b,
  7634.                                     helper: c,
  7635.                                     mode: d,
  7636.                                     results: g,
  7637.                                     satisfied: j,
  7638.                                     side: n,
  7639.                                     takeTest: function(a) {
  7640.                                         l = a
  7641.                                     },
  7642.                                     type: "positionTest"
  7643.                                 }),
  7644.                                 1 == l || 0 != l && 0 == j) {
  7645.                                     var h = {
  7646.                                         container: k,
  7647.                                         distance: m,
  7648.                                         fits: null,
  7649.                                         mode: d,
  7650.                                         outerSize: null,
  7651.                                         side: n,
  7652.                                         size: null,
  7653.                                         target: f[n],
  7654.                                         whole: null
  7655.                                     }
  7656.                                       , o = "natural" == d ? i.free() : i.constrain(c.geo.available[k][n].width - m.horizontal, c.geo.available[k][n].height - m.vertical)
  7657.                                       , p = o.measure();
  7658.                                     if (h.size = p.size,
  7659.                                     h.outerSize = {
  7660.                                         height: p.size.height + m.vertical,
  7661.                                         width: p.size.width + m.horizontal
  7662.                                     },
  7663.                                     "natural" == d ? c.geo.available[k][n].width >= h.outerSize.width && c.geo.available[k][n].height >= h.outerSize.height ? h.fits = !0 : h.fits = !1 : h.fits = p.fits,
  7664.                                     "window" == k && (h.fits ? "top" == n || "bottom" == n ? h.whole = c.geo.origin.windowOffset.right >= e.__options.minIntersection && c.geo.window.size.width - c.geo.origin.windowOffset.left >= e.__options.minIntersection : h.whole = c.geo.origin.windowOffset.bottom >= e.__options.minIntersection && c.geo.window.size.height - c.geo.origin.windowOffset.top >= e.__options.minIntersection : h.whole = !1),
  7665.                                     g.push(h),
  7666.                                     h.whole)
  7667.                                         j = !0;
  7668.                                     else if ("natural" == h.mode && (h.fits || h.size.width <= c.geo.available[k][n].width))
  7669.                                         return !1
  7670.                                 }
  7671.                             })
  7672.                         }
  7673.                 }),
  7674.                 e.__instance._trigger({
  7675.                     edit: function(a) {
  7676.                         g = a
  7677.                     },
  7678.                     event: b,
  7679.                     helper: c,
  7680.                     results: g,
  7681.                     type: "positionTested"
  7682.                 }),
  7683.                 g.sort(function(a, b) {
  7684.                     if (a.whole && !b.whole)
  7685.                         return -1;
  7686.                     if (!a.whole && b.whole)
  7687.                         return 1;
  7688.                     if (a.whole && b.whole) {
  7689.                         var c = e.__options.side.indexOf(a.side)
  7690.                           , d = e.__options.side.indexOf(b.side);
  7691.                         return d > c ? -1 : c > d ? 1 : "natural" == a.mode ? -1 : 1
  7692.                     }
  7693.                     if (a.fits && !b.fits)
  7694.                         return -1;
  7695.                     if (!a.fits && b.fits)
  7696.                         return 1;
  7697.                     if (a.fits && b.fits) {
  7698.                         var c = e.__options.side.indexOf(a.side)
  7699.                           , d = e.__options.side.indexOf(b.side);
  7700.                         return d > c ? -1 : c > d ? 1 : "natural" == a.mode ? -1 : 1
  7701.                     }
  7702.                     return "document" == a.container && "bottom" == a.side && "natural" == a.mode ? -1 : 1
  7703.                 }),
  7704.                 d = g[0],
  7705.                 d.coord = {},
  7706.                 d.side) {
  7707.                 case "left":
  7708.                 case "right":
  7709.                     d.coord.top = Math.floor(d.target - d.size.height / 2);
  7710.                     break;
  7711.                 case "bottom":
  7712.                 case "top":
  7713.                     d.coord.left = Math.floor(d.target - d.size.width / 2)
  7714.                 }
  7715.                 switch (d.side) {
  7716.                 case "left":
  7717.                     d.coord.left = c.geo.origin.windowOffset.left - d.outerSize.width;
  7718.                     break;
  7719.                 case "right":
  7720.                     d.coord.left = c.geo.origin.windowOffset.right + d.distance.horizontal;
  7721.                     break;
  7722.                 case "top":
  7723.                     d.coord.top = c.geo.origin.windowOffset.top - d.outerSize.height;
  7724.                     break;
  7725.                 case "bottom":
  7726.                     d.coord.top = c.geo.origin.windowOffset.bottom + d.distance.vertical
  7727.                 }
  7728.                 "window" == d.container ? "top" == d.side || "bottom" == d.side ? d.coord.left < 0 ? c.geo.origin.windowOffset.right - this.__options.minIntersection >= 0 ? d.coord.left = 0 : d.coord.left = c.geo.origin.windowOffset.right - this.__options.minIntersection - 1 : d.coord.left > c.geo.window.size.width - d.size.width && (c.geo.origin.windowOffset.left + this.__options.minIntersection <= c.geo.window.size.width ? d.coord.left = c.geo.window.size.width - d.size.width : d.coord.left = c.geo.origin.windowOffset.left + this.__options.minIntersection + 1 - d.size.width) : d.coord.top < 0 ? c.geo.origin.windowOffset.bottom - this.__options.minIntersection >= 0 ? d.coord.top = 0 : d.coord.top = c.geo.origin.windowOffset.bottom - this.__options.minIntersection - 1 : d.coord.top > c.geo.window.size.height - d.size.height && (c.geo.origin.windowOffset.top + this.__options.minIntersection <= c.geo.window.size.height ? d.coord.top = c.geo.window.size.height - d.size.height : d.coord.top = c.geo.origin.windowOffset.top + this.__options.minIntersection + 1 - d.size.height) : (d.coord.left > c.geo.window.size.width - d.size.width && (d.coord.left = c.geo.window.size.width - d.size.width),
  7729.                 d.coord.left < 0 && (d.coord.left = 0)),
  7730.                 e.__sideChange(h, d.side),
  7731.                 c.tooltipClone = h[0],
  7732.                 c.tooltipParent = e.__instance.option("parent").parent[0],
  7733.                 c.mode = d.mode,
  7734.                 c.whole = d.whole,
  7735.                 c.origin = e.__instance._$origin[0],
  7736.                 c.tooltip = e.__instance._$tooltip[0],
  7737.                 delete d.container,
  7738.                 delete d.fits,
  7739.                 delete d.mode,
  7740.                 delete d.outerSize,
  7741.                 delete d.whole,
  7742.                 d.distance = d.distance.horizontal || d.distance.vertical;
  7743.                 var l = a.extend(!0, {}, d);
  7744.                 if (e.__instance._trigger({
  7745.                     edit: function(a) {
  7746.                         d = a
  7747.                     },
  7748.                     event: b,
  7749.                     helper: c,
  7750.                     position: l,
  7751.                     type: "position"
  7752.                 }),
  7753.                 e.__options.functionPosition) {
  7754.                     var m = e.__options.functionPosition.call(e, e.__instance, c, l);
  7755.                     m && (d = m)
  7756.                 }
  7757.                 i.destroy();
  7758.                 var n, o;
  7759.                 "top" == d.side || "bottom" == d.side ? (n = {
  7760.                     prop: "left",
  7761.                     val: d.target - d.coord.left
  7762.                 },
  7763.                 o = d.size.width - this.__options.minIntersection) : (n = {
  7764.                     prop: "top",
  7765.                     val: d.target - d.coord.top
  7766.                 },
  7767.                 o = d.size.height - this.__options.minIntersection),
  7768.                 n.val < this.__options.minIntersection ? n.val = this.__options.minIntersection : n.val > o && (n.val = o);
  7769.                 var p;
  7770.                 p = c.geo.origin.fixedLineage ? c.geo.origin.windowOffset : {
  7771.                     left: c.geo.origin.windowOffset.left + c.geo.window.scroll.left,
  7772.                     top: c.geo.origin.windowOffset.top + c.geo.window.scroll.top
  7773.                 },
  7774.                 d.coord = {
  7775.                     left: p.left + (d.coord.left - c.geo.origin.windowOffset.left),
  7776.                     top: p.top + (d.coord.top - c.geo.origin.windowOffset.top)
  7777.                 },
  7778.                 e.__sideChange(e.__instance._$tooltip, d.side),
  7779.                 c.geo.origin.fixedLineage ? e.__instance._$tooltip.css("position", "fixed") : e.__instance._$tooltip.css("position", ""),
  7780.                 e.__instance._$tooltip.css({
  7781.                     left: d.coord.left,
  7782.                     top: d.coord.top,
  7783.                     height: d.size.height,
  7784.                     width: d.size.width
  7785.                 }).find(".tooltipster-arrow").css({
  7786.                     left: "",
  7787.                     top: ""
  7788.                 }).css(n.prop, n.val),
  7789.                 e.__instance._$tooltip.appendTo(e.__instance.option("parent")),
  7790.                 e.__instance._trigger({
  7791.                     type: "repositioned",
  7792.                     event: b,
  7793.                     position: d
  7794.                 })
  7795.             },
  7796.             __sideChange: function(a, b) {
  7797.                 a.removeClass("tooltipster-bottom").removeClass("tooltipster-left").removeClass("tooltipster-right").removeClass("tooltipster-top").addClass("tooltipster-" + b)
  7798.             },
  7799.             __targetFind: function(a) {
  7800.                 var b = {}
  7801.                   , c = this.__instance._$origin[0].getClientRects();
  7802.                 if (c.length > 1) {
  7803.                     var d = this.__instance._$origin.css("opacity");
  7804.                     1 == d && (this.__instance._$origin.css("opacity", .99),
  7805.                     c = this.__instance._$origin[0].getClientRects(),
  7806.                     this.__instance._$origin.css("opacity", 1))
  7807.                 }
  7808.                 if (c.length < 2)
  7809.                     b.top = Math.floor(a.geo.origin.windowOffset.left + a.geo.origin.size.width / 2),
  7810.                     b.bottom = b.top,
  7811.                     b.left = Math.floor(a.geo.origin.windowOffset.top + a.geo.origin.size.height / 2),
  7812.                     b.right = b.left;
  7813.                 else {
  7814.                     var e = c[0];
  7815.                     b.top = Math.floor(e.left + (e.right - e.left) / 2),
  7816.                     e = c.length > 2 ? c[Math.ceil(c.length / 2) - 1] : c[0],
  7817.                     b.right = Math.floor(e.top + (e.bottom - e.top) / 2),
  7818.                     e = c[c.length - 1],
  7819.                     b.bottom = Math.floor(e.left + (e.right - e.left) / 2),
  7820.                     e = c.length > 2 ? c[Math.ceil((c.length + 1) / 2) - 1] : c[c.length - 1],
  7821.                     b.left = Math.floor(e.top + (e.bottom - e.top) / 2)
  7822.                 }
  7823.                 return b
  7824.             }
  7825.         }
  7826.     }),
  7827.     a
  7828. });
  7829. ;$(function() {
  7830.     window.FORTUNE_WHEEL_CONFIG['container'] = $('.fortunewheel-container');
  7831.     var config = {
  7832.         'email': $('#id_email'),
  7833.         'button': $('#id_button'),
  7834.         'form': $('#id_form'),
  7835.         'message': $('.roulette-iframe-right-message'),
  7836.         'fortunewheel': new FortuneWheel(window.FORTUNE_WHEEL_CONFIG),
  7837.         'close': $('.roulette-iframe-close a'),
  7838.         'prize_container': $('.roulette-iframe-right-prize'),
  7839.         'form_container': $('.roulette-iframe-right-signup'),
  7840.         'played_button': $('.roulette-iframe-right-prize-button button'),
  7841.     }
  7842.     var applied_config = $.extend({}, config, window.ROULETTE_CONFIG);
  7843.     var roulette = new IframeRoulette(applied_config);
  7844.     window.roulette = roulette;
  7845. });
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!