PageSourceSearch

https://www.21.by/pub/img/jquery.js

js 21.by collected 2026-09-27 21:43:44 UTC 116,040 bytes, 3,214 lines download raw bytes

1(function() {
2    var l = this,
3        g, x = l.jQuery,
4        o = l.$,
5        n = l.jQuery = l.$ = function(D, E) {
6            return new n.fn.init(D, E)
7        },
8        C = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
9        f = /^.[^:#\[\.,]*$/;
10    n.fn = n.prototype = {
11        init: function(D, G) {
12            D = D || document;
13            if (D.nodeType) {
14                this[0] = D;
15                this.length = 1;
16                this.context = D;
17                return this
18            }
19            if (typeof D === "string") {
20                var F = C.exec(D);
21                if (F && (F[1] || !G)) {
22                    if (F[1]) {
23                        D = n.clean([F[1]], G)
24                    } else {
25                        var H = document.getElementById(F[3]);
26                        if (H) {
27                            if (H.id != F[3]) {
28                                return n().find(D)
29                            }
30                            var E = n(H);
31                            E.context = document;
32                            E.selector = D;
33                            return E
34                        }
35                        D = []
36                    }
37                } else {
38                    return n(G).find(D)
39                }
40            } else {
41                if (n.isFunction(D)) {
42                    return n(document).ready(D)
43                }
44            }
45            if (D.selector && D.context) {
46                this.selector = D.selector;
47                this.context = D.context
48            }
49            return this.setArray(n.makeArray(D))
50        },
51        selector: "",
52        jquery: "1.3",
53        size: function() {
54            return this.length
55        },
56        get: function(D) {
57            return D === g ? n.makeArray(this) : this[D]
58        },
59        pushStack: function(E, G, D) {
60            var F = n(E);
61            F.prevObject = this;
62            F.context = this.context;
63            if (G === "find") {
64                F.selector = this.selector + (this.selector ? " " : "") + D
65            } else {
66                if (G) {
67                    F.selector = this.selector + "." + G + "(" + D + ")"
68                }
69            }
70            return F
71        },
72        setArray: function(D) {
73            this.length = 0;
74            Array.prototype.push.apply(this, D);
75            return this
76        },
77        each: function(E, D) {
78            return n.each(this, E, D)
79        },
80        index: function(D) {
81            return n.inArray(D && D.jquery ? D[0] : D, this)
82        },
83        attr: function(E, G, F) {
84            var D = E;
85            if (typeof E === "string") {
86                if (G === g) {
87                    return this[0] && n[F || "attr"](this[0], E)
88                } else {
89                    D = {};
90                    D[E] = G
91                }
92            }
93            return this.each(function(H) {
94                for (E in D) {
95                    n.attr(F ? this.style : this, E, n.prop(this, D[E], F, H, E))
96                }
97            })
98        },
99        css: function(D, E) {
100            if ((D == "width" || D == "height") && parseFloat(E) < 0) {
101                E = g
102            }
103            return this.attr(D, E, "curCSS")
104        },
105        text: function(E) {
106            if (typeof E !== "object" && E != null) {
107                return this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(E))
108            }
109            var D = "";
110            n.each(E || this, function() {
111                n.each(this.childNodes, function() {
112                    if (this.nodeType != 8) {
113                        D += this.nodeType != 1 ? this.nodeValue : n.fn.text([this])
114                    }
115                })
116            });
117            return D
118        },
119        wrapAll: function(D) {
120            if (this[0]) {
121                var E = n(D, this[0].ownerDocument).clone();
122                if (this[0].parentNode) {
123                    E.insertBefore(this[0])
124                }
125                E.map(function() {
126                    var F = this;
127                    while (F.firstChild) {
128                        F = F.firstChild
129                    }
130                    return F
131                }).append(this)
132            }
133            return this
134        },
135        wrapInner: function(D) {
136            return this.each(function() {
137                n(this).contents().wrapAll(D)
138            })
139        },
140        wrap: function(D) {
141            return this.each(function() {
142                n(this).wrapAll(D)
143            })
144        },
145        append: function() {
146            return this.domManip(arguments, true, function(D) {
147                if (this.nodeType == 1) {
148                    this.appendChild(D)
149                }
150            })
151        },
152        prepend: function() {
153            return this.domManip(arguments, true, function(D) {
154                if (this.nodeType == 1) {
155                    this.insertBefore(D, this.firstChild)
156                }
157            })
158        },
159        before: function() {
160            return this.domManip(arguments, false, function(D) {
161                this.parentNode.insertBefore(D, this)
162            })
163        },
164        after: function() {
165            return this.domManip(arguments, false, function(D) {
166                this.parentNode.insertBefore(D, this.nextSibling)
167            })
168        },
169        end: function() {
170            return this.prevObject || n([])
171        },
172        push: [].push,
173        find: function(D) {
174            if (this.length === 1 && !/,/.test(D)) {
175                var F = this.pushStack([], "find", D);
176                F.length = 0;
177                n.find(D, this[0], F);
178                return F
179            } else {
180                var E = n.map(this, function(G) {
181                    return n.find(D, G)
182                });
183                return this.pushStack(/[^+>] [^+>]/.test(D) ? n.unique(E) : E, "find", D)
184            }
185        },
186        clone: function(E) {
187            var D = this.map(function() {
188                if (!n.support.noCloneEvent && !n.isXMLDoc(this)) {
189                    var H = this.cloneNode(true),
190                        G = document.createElement("div");
191                    G.appendChild(H);
192                    return n.clean([G.innerHTML])[0]
193                } else {
194                    return this.cloneNode(true)
195                }
196            });
197            var F = D.find("*").andSelf().each(function() {
198                if (this[h] !== g) {
199                    this[h] = null
200                }
201            });
202            if (E === true) {
203                this.find("*").andSelf().each(function(H) {
204                    if (this.nodeType == 3) {
205                        return
206                    }
207                    var G = n.data(this, "events");
208                    for (var J in G) {
209                        for (var I in G[J]) {
210                            n.event.add(F[H], J, G[J][I], G[J][I].data)
211                        }
212                    }
213                })
214            }
215            return D
216        },
217        filter: function(D) {
218            return this.pushStack(n.isFunction(D) && n.grep(this, function(F, E) {
219                return D.call(F, E)
220            }) || n.multiFilter(D, n.grep(this, function(E) {
221                return E.nodeType === 1
222            })), "filter", D)
223        },
224        closest: function(D) {
225            var E = n.expr.match.POS.test(D) ? n(D) : null;
226            return this.map(function() {
227                var F = this;
228                while (F && F.ownerDocument) {
229                    if (E ? E.index(F) > -1 : n(F).is(D)) {
230                        return F
231                    }
232                    F = F.parentNode
233                }
234            })
235        },
236        not: function(D) {
237            if (typeof D === "string") {
238                if (f.test(D)) {
239                    return this.pushStack(n.multiFilter(D, this, true), "not", D)
240                } else {
241                    D = n.multiFilter(D, this)
242                }
243            }
244            var E = D.length && D[D.length - 1] !== g && !D.nodeType;
245            return this.filter(function() {
246                return E ? n.inArray(this, D) < 0 : this != D
247            })
248        },
249        add: function(D) {
250            return this.pushStack(n.unique(n.merge(this.get(), typeof D === "string" ? n(D) : n.makeArray(D))))
251        },
252        is: function(D) {
253            return !!D && n.multiFilter(D, this).length > 0
254        },
255        hasClass: function(D) {
256            return !!D && this.is("." + D)
257        },
258        val: function(J) {
259            if (J === g) {
260                var D = this[0];
261                if (D) {
262                    if (n.nodeName(D, "option")) {
263                        return (D.attributes.value || {}).specified ? D.value : D.text
264                    }
265                    if (n.nodeName(D, "select")) {
266                        var H = D.selectedIndex,
267                            K = [],
268                            L = D.options,
269                            G = D.type == "select-one";
270                        if (H < 0) {
271                            return null
272                        }
273                        for (var E = G ? H : 0, I = G ? H + 1 : L.length; E < I; E++) {
274                            var F = L[E];
275                            if (F.selected) {
276                                J = n(F).val();
277                                if (G) {
278                                    return J
279                                }
280                                K.push(J)
281                            }
282                        }
283                        return K
284                    }
285                    return (D.value || "").replace(/\r/g, "")
286                }
287                return g
288            }
289            if (typeof J === "number") {
290                J += ""
291            }
292            return this.each(function() {
293                if (this.nodeType != 1) {
294                    return
295                }
296                if (n.isArray(J) && /radio|checkbox/.test(this.type)) {
297                    this.checked = (n.inArray(this.value, J) >= 0 || n.inArray(this.name, J) >= 0)
298                } else {
299                    if (n.nodeName(this, "select")) {
300                        var M = n.makeArray(J);
301                        n("option", this).each(function() {
302                            this.selected = (n.inArray(this.value, M) >= 0 || n.inArray(this.text, M) >= 0)
303                        });
304                        if (!M.length) {
305                            this.selectedIndex = -1
306                        }
307                    } else {
308                        this.value = J
309                    }
310                }
311            })
312        },
313        html: function(D) {
314            return D === g ? (this[0] ? this[0].innerHTML : null) : this.empty().append(D)
315        },
316        replaceWith: function(D) {
317            return this.after(D).remove()
318        },
319        eq: function(D) {
320            return this.slice(D, +D + 1)
321        },
322        slice: function() {
323            return this.pushStack(Array.prototype.slice.apply(this, arguments), "slice", Array.prototype.slice.call(arguments).join(","))
324        },
325        map: function(D) {
326            return this.pushStack(n.map(this, function(F, E) {
327                return D.call(F, E, F)
328            }))
329        },
330        andSelf: function() {
331            return this.add(this.prevObject)
332        },
333        domManip: function(J, M, L) {
334            if (this[0]) {
335                var I = (this[0].ownerDocument || this[0]).createDocumentFragment(),
336                    F = n.clean(J, (this[0].ownerDocument || this[0]), I),
337                    H = I.firstChild,
338                    D = this.length > 1 ? I.cloneNode(true) : I;
339                if (H) {
340                    for (var G = 0, E = this.length; G < E; G++) {
341                        L.call(K(this[G], H), G > 0 ? D.cloneNode(true) : I)
342                    }
343                }
344                if (F) {
345                    n.each(F, y)
346                }
347            }
348            return this;
349
350            function K(N, O) {
351                return M && n.nodeName(N, "table") && n.nodeName(O, "tr") ? (N.getElementsByTagName("tbody")[0] || N.appendChild(N.ownerDocument.createElement("tbody"))) : N
352            }
353        }
354    };
355    n.fn.init.prototype = n.fn;
356
357    function y(D, E) {
358        if (E.src) {
359            n.ajax({
360                url: E.src,
361                async: false,
362                dataType: "script"
363            })
364        } else {
365            n.globalEval(E.text || E.textContent || E.innerHTML || "")
366        }
367        if (E.parentNode) {
368            E.parentNode.removeChild(E)
369        }
370    }
371
372    function e() {
373        return +new Date
374    }
375    n.extend = n.fn.extend = function() {
376        var I = arguments[0] || {},
377            G = 1,
378            H = arguments.length,
379            D = false,
380            F;
381        if (typeof I === "boolean") {
382            D = I;
383            I = arguments[1] || {};
384            G = 2
385        }
386        if (typeof I !== "object" && !n.isFunction(I)) {
387            I = {}
388        }
389        if (H == G) {
390            I = this;
391            --G
392        }
393        for (; G < H; G++) {
394            if ((F = arguments[G]) != null) {
395                for (var E in F) {
396                    var J = I[E],
397                        K = F[E];
398                    if (I === K) {
399                        continue
400                    }
401                    if (D && K && typeof K === "object" && !K.nodeType) {
402                        I[E] = n.extend(D, J || (K.length != null ? [] : {}), K)
403                    } else {
404                        if (K !== g) {
405                            I[E] = K
406                        }
407                    }
408                }
409            }
410        }
411        return I
412    };
413    var b = /z-?index|font-?weight|opacity|zoom|line-?height/i,
414        p = document.defaultView || {},
415        r = Object.prototype.toString;
416    n.extend({
417        noConflict: function(D) {
418            l.$ = o;
419            if (D) {
420                l.jQuery = x
421            }
422            return n
423        },
424        isFunction: function(D) {
425            return r.call(D) === "[object Function]"
426        },
427        isArray: function(D) {
428            return r.call(D) === "[object Array]"
429        },
430        isXMLDoc: function(D) {
431            return D.documentElement && !D.body || D.tagName && D.ownerDocument && !D.ownerDocument.body
432        },
433        globalEval: function(F) {
434            F = n.trim(F);
435            if (F) {
436                var E = document.getElementsByTagName("head")[0] || document.documentElement,
437                    D = document.createElement("script");
438                D.type = "text/javascript";
439                if (n.support.scriptEval) {
440                    D.appendChild(document.createTextNode(F))
441                } else {
442                    D.text = F
443                }
444                E.insertBefore(D, E.firstChild);
445                E.removeChild(D)
446            }
447        },
448        nodeName: function(E, D) {
449            return E.nodeName && E.nodeName.toUpperCase() == D.toUpperCase()
450        },
451        each: function(F, J, E) {
452            var D, G = 0,
453                H = F.length;
454            if (E) {
455                if (H === g) {
456                    for (D in F) {
457                        if (J.apply(F[D], E) === false) {
458                            break
459                        }
460                    }
461                } else {
462                    for (; G < H;) {
463                        if (J.apply(F[G++], E) === false) {
464                            break
465                        }
466                    }
467                }
468            } else {
469                if (H === g) {
470                    for (D in F) {
471                        if (J.call(F[D], D, F[D]) === false) {
472                            break
473                        }
474                    }
475                } else {
476                    for (var I = F[0]; G < H && J.call(I, G, I) !== false; I = F[++G]) {}
477                }
478            }
479            return F
480        },
481        prop: function(G, H, F, E, D) {
482            if (n.isFunction(H)) {
483                H = H.call(G, E)
484            }
485            return typeof H === "number" && F == "curCSS" && !b.test(D) ? H + "px" : H
486        },
487        className: {
488            add: function(D, E) {
489                n.each((E || "").split(/\s+/), function(F, G) {
490                    if (D.nodeType == 1 && !n.className.has(D.className, G)) {
491                        D.className += (D.className ? " " : "") + G
492                    }
493                })
494            },
495            remove: function(D, E) {
496                if (D.nodeType == 1) {
497                    D.className = E !== g ? n.grep(D.className.split(/\s+/), function(F) {
498                        return !n.className.has(E, F)
499                    }).join(" ") : ""
500                }
501            },
502            has: function(E, D) {
503                return n.inArray(D, (E.className || E).toString().split(/\s+/)) > -1
504            }
505        },
506        swap: function(G, F, H) {
507            var D = {};
508            for (var E in F) {
509                D[E] = G.style[E];
510                G.style[E] = F[E]
511            }
512            H.call(G);
513            for (var E in F) {
514                G.style[E] = D[E]
515            }
516        },
517        css: function(F, D, H) {
518            if (D == "width" || D == "height") {
519                var J, E = {
520                        position: "absolute",
521                        visibility: "hidden",
522                        display: "block"
523                    },
524                    I = D == "width" ? ["Left", "Right"] : ["Top", "Bottom"];
525
526                function G() {
527                    J = D == "width" ? F.offsetWidth : F.offsetHeight;
528                    var L = 0,
529                        K = 0;
530                    n.each(I, function() {
531                        L += parseFloat(n.curCSS(F, "padding" + this, true)) || 0;
532                        K += parseFloat(n.curCSS(F, "border" + this + "Width", true)) || 0
533                    });
534                    J -= Math.round(L + K)
535                }
536                if (n(F).is(":visible")) {
537                    G()
538                } else {
539                    n.swap(F, E, G)
540                }
541                return Math.max(0, J)
542            }
543            return n.curCSS(F, D, H)
544        },
545        curCSS: function(H, E, F) {
546            var K, D = H.style;
547            if (E == "opacity" && !n.support.opacity) {
548                K = n.attr(D, "opacity");
549                return K == "" ? "1" : K
550            }
551            if (E.match(/float/i)) {
552                E = v
553            }
554            if (!F && D && D[E]) {
555                K = D[E]
556            } else {
557                if (p.getComputedStyle) {
558                    if (E.match(/float/i)) {
559                        E = "float"
560                    }
561                    E = E.replace(/([A-Z])/g, "-$1").toLowerCase();
562                    var L = p.getComputedStyle(H, null);
563                    if (L) {
564                        K = L.getPropertyValue(E)
565                    }
566                    if (E == "opacity" && K == "") {
567                        K = "1"
568                    }
569                } else {
570                    if (H.currentStyle) {
571                        var I = E.replace(/\-(\w)/g, function(M, N) {
572                            return N.toUpperCase()
573                        });
574                        K = H.currentStyle[E] || H.currentStyle[I];
575                        if (!/^\d+(px)?$/i.test(K) && /^\d/.test(K)) {
576                            var G = D.left,
577                                J = H.runtimeStyle.left;
578                            H.runtimeStyle.left = H.currentStyle.left;
579                            D.left = K || 0;
580                            K = D.pixelLeft + "px";
581                            D.left = G;
582                            H.runtimeStyle.left = J
583                        }
584                    }
585                }
586            }
587            return K
588        },
589        clean: function(E, J, H) {
590            J = J || document;
591            if (typeof J.createElement === "undefined") {
592                J = J.ownerDocument || J[0] && J[0].ownerDocument || document
593            }
594            if (!H && E.length === 1 && typeof E[0] === "string") {
595                var G = /^<(\w+)\s*\/?>$/.exec(E[0]);
596                if (G) {
597                    return [J.createElement(G[1])]
598                }
599            }
600            var F = [],
601                D = [],
602                K = J.createElement("div");
603            n.each(E, function(O, Q) {
604                if (typeof Q === "number") {
605                    Q += ""
606                }
607                if (!Q) {
608                    return
609                }
610                if (typeof Q === "string") {
611                    Q = Q.replace(/(<(\w+)[^>]*?)\/>/g, function(S, T, R) {
612                        return R.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ? S : T + "></" + R + ">"
613                    });
614                    var N = n.trim(Q).toLowerCase();
615                    var P = !N.indexOf("<opt") && [1, "<select multiple='multiple'>", "</select>"] || !N.indexOf("<leg") && [1, "<fieldset>", "</fieldset>"] || N.match(/^<(thead|tbody|tfoot|colg|cap)/) && [1, "<table>", "</table>"] || !N.indexOf("<tr") && [2, "<table><tbody>", "</tbody></table>"] || (!N.indexOf("<td") || !N.indexOf("<th")) && [3, "<table><tbody><tr>", "</tr></tbody></table>"] || !N.indexOf("<col") && [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"] || !n.support.htmlSerialize && [1, "div<div>", "</div>"] || [0, "", ""];
616                    K.innerHTML = P[1] + Q + P[2];
617                    while (P[0] --) {
618                        K = K.lastChild
619                    }
620                    if (!n.support.tbody) {
621                        var M = !N.indexOf("<table") && N.indexOf("<tbody") < 0 ? K.firstChild && K.firstChild.childNodes : P[1] == "<table>" && N.indexOf("<tbody") < 0 ? K.childNodes : [];
622                        for (var L = M.length - 1; L >= 0; --L) {
623                            if (n.nodeName(M[L], "tbody") && !M[L].childNodes.length) {
624                                M[L].parentNode.removeChild(M[L])
625                            }
626                        }
627                    }
628                    if (!n.support.leadingWhitespace && /^\s/.test(Q)) {
629                        K.insertBefore(J.createTextNode(Q.match(/^\s*/)[0]), K.firstChild)
630                    }
631                    Q = n.makeArray(K.childNodes)
632                }
633                if (Q.nodeType) {
634                    F.push(Q)
635                } else {
636                    F = n.merge(F, Q)
637                }
638            });
639            if (H) {
640                for (var I = 0; F[I]; I++) {
641                    if (n.nodeName(F[I], "script") && (!F[I].type || F[I].type.toLowerCase() === "text/javascript")) {
642                        D.push(F[I].parentNode ? F[I].parentNode.removeChild(F[I]) : F[I])
643                    } else {
644                        if (F[I].nodeType === 1) {
645                            F.splice.apply(F, [I + 1, 0].concat(n.makeArray(F[I].getElementsByTagName("script"))))
646                        }
647                        H.appendChild(F[I])
648                    }
649                }
650                return D
651            }
652            return F
653        },
654        attr: function(I, F, J) {
655            if (!I || I.nodeType == 3 || I.nodeType == 8) {
656                return g
657            }
658            var G = !n.isXMLDoc(I),
659                K = J !== g;
660            F = G && n.props[F] || F;
661            if (I.tagName) {
662                var E = /href|src|style/.test(F);
663                if (F == "selected" && I.parentNode) {
664                    I.parentNode.selectedIndex
665                }
666                if (F in I && G && !E) {
667                    if (K) {
668                        if (F == "type" && n.nodeName(I, "input") && I.parentNode) {
669                            throw "type property can't be changed"
670                        }
671                        I[F] = J
672                    }
673                    if (n.nodeName(I, "form") && I.getAttributeNode(F)) {
674                        return I.getAttributeNode(F).nodeValue
675                    }
676                    if (F == "tabIndex") {
677                        var H = I.getAttributeNode("tabIndex");
678                        return H && H.specified ? H.value : I.nodeName.match(/^(a|area|button|input|object|select|textarea)$/i) ? 0 : g
679                    }
680                    return I[F]
681                }
682                if (!n.support.style && G && F == "style") {
683                    return n.attr(I.style, "cssText", J)
684                }
685                if (K) {
686                    I.setAttribute(F, "" + J)
687                }
688                var D = !n.support.hrefNormalized && G && E ? I.getAttribute(F, 2) : I.getAttribute(F);
689                return D === null ? g : D
690            }
691            if (!n.support.opacity && F == "opacity") {
692                if (K) {
693                    I.zoom = 1;
694                    I.filter = (I.filter || "").replace(/alpha\([^)]*\)/, "") + (parseInt(J) + "" == "NaN" ? "" : "alpha(opacity=" + J * 100 + ")")
695                }
696                return I.filter && I.filter.indexOf("opacity=") >= 0 ? (parseFloat(I.filter.match(/opacity=([^)]*)/)[1]) / 100) + "" : ""
697            }
698            F = F.replace(/-([a-z])/ig, function(L, M) {
699                return M.toUpperCase()
700            });
701            if (K) {
702                I[F] = J
703            }
704            return I[F]
705        },
706        trim: function(D) {
707            return (D || "").replace(/^\s+|\s+$/g, "")
708        },
709        makeArray: function(F) {
710            var D = [];
711            if (F != null) {
712                var E = F.length;
713                if (E == null || typeof F === "string" || n.isFunction(F) || F.setInterval) {
714                    D[0] = F
715                } else {
716                    while (E) {
717                        D[--E] = F[E]
718                    }
719                }
720            }
721            return D
722        },
723        inArray: function(F, G) {
724            for (var D = 0, E = G.length; D < E; D++) {
725                if (G[D] === F) {
726                    return D
727                }
728            }
729            return -1
730        },
731        merge: function(G, D) {
732            var E = 0,
733                F, H = G.length;
734            if (!n.support.getAll) {
735                while ((F = D[E++]) != null) {
736                    if (F.nodeType != 8) {
737                        G[H++] = F
738                    }
739                }
740            } else {
741                while ((F = D[E++]) != null) {
742                    G[H++] = F
743                }
744            }
745            return G
746        },
747        unique: function(J) {
748            var E = [],
749                D = {};
750            try {
751                for (var F = 0, G = J.length; F < G; F++) {
752                    var I = n.data(J[F]);
753                    if (!D[I]) {
754                        D[I] = true;
755                        E.push(J[F])
756                    }
757                }
758            } catch (H) {
759                E = J
760            }
761            return E
762        },
763        grep: function(E, I, D) {
764            var F = [];
765            for (var G = 0, H = E.length; G < H; G++) {
766                if (!D != !I(E[G], G)) {
767                    F.push(E[G])
768                }
769            }
770            return F
771        },
772        map: function(D, I) {
773            var E = [];
774            for (var F = 0, G = D.length; F < G; F++) {
775                var H = I(D[F], F);
776                if (H != null) {
777                    E[E.length] = H
778                }
779            }
780            return E.concat.apply([], E)
781        }
782    });
783    var B = navigator.userAgent.toLowerCase();
784    n.browser = {
785        version: (B.match(/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/) || [0, "0"])[1],
786        safari: /webkit/.test(B),
787        opera: /opera/.test(B),
788        msie: /msie/.test(B) && !/opera/.test(B),
789        mozilla: /mozilla/.test(B) && !/(compatible|webkit)/.test(B)
790    };
791    n.each({
792        parent: function(D) {
793            return D.parentNode
794        },
795        parents: function(D) {
796            return n.dir(D, "parentNode")
797        },
798        next: function(D) {
799            return n.nth(D, 2, "nextSibling")
800        },
801        prev: function(D) {
802            return n.nth(D, 2, "previousSibling")
803        },
804        nextAll: function(D) {
805            return n.dir(D, "nextSibling")
806        },
807        prevAll: function(D) {
808            return n.dir(D, "previousSibling")
809        },
810        siblings: function(D) {
811            return n.sibling(D.parentNode.firstChild, D)
812        },
813        children: function(D) {
814            return n.sibling(D.firstChild)
815        },
816        contents: function(D) {
817            return n.nodeName(D, "iframe") ? D.contentDocument || D.contentWindow.document : n.makeArray(D.childNodes)
818        }
819    }, function(D, E) {
820        n.fn[D] = function(F) {
821            var G = n.map(this, E);
822            if (F && typeof F == "string") {
823                G = n.multiFilter(F, G)
824            }
825            return this.pushStack(n.unique(G), D, F)
826        }
827    });
828    n.each({
829        appendTo: "append",
830        prependTo: "prepend",
831        insertBefore: "before",
832        insertAfter: "after",
833        replaceAll: "replaceWith"
834    }, function(D, E) {
835        n.fn[D] = function() {
836            var F = arguments;
837            return this.each(function() {
838                for (var G = 0, H = F.length; G < H; G++) {
839                    n(F[G])[E](this)
840                }
841            })
842        }
843    });
844    n.each({
845        removeAttr: function(D) {
846            n.attr(this, D, "");
847            if (this.nodeType == 1) {
848                this.removeAttribute(D)
849            }
850        },
851        addClass: function(D) {
852            n.className.add(this, D)
853        },
854        removeClass: function(D) {
855            n.className.remove(this, D)
856        },
857        toggleClass: function(E, D) {
858            if (typeof D !== "boolean") {
859                D = !n.className.has(this, E)
860            }
861            n.className[D ? "add" : "remove"](this, E)
862        },
863        remove: function(D) {
864            if (!D || n.filter(D, [this]).length) {
865                n("*", this).add([this]).each(function() {
866                    n.event.remove(this);
867                    n.removeData(this)
868                });
869                if (this.parentNode) {
870                    this.parentNode.removeChild(this)
871                }
872            }
873        },
874        empty: function() {
875            n(">*", this).remove();
876            while (this.firstChild) {
877                this.removeChild(this.firstChild)
878            }
879        }
880    }, function(D, E) {
881        n.fn[D] = function() {
882            return this.each(E, arguments)
883        }
884    });
885
886    function j(D, E) {
887        return D[0] && parseInt(n.curCSS(D[0], E, true), 10) || 0
888    }
889    var h = "jQuery" + e(),
890        u = 0,
891        z = {};
892    n.extend({
893        cache: {},
894        data: function(E, D, F) {
895            E = E == l ? z : E;
896            var G = E[h];
897            if (!G) {
898                G = E[h] = ++u
899            }
900            if (D && !n.cache[G]) {
901                n.cache[G] = {}
902            }
903            if (F !== g) {
904                n.cache[G][D] = F
905            }
906            return D ? n.cache[G][D] : G
907        },
908        removeData: function(E, D) {
909            E = E == l ? z : E;
910            var G = E[h];
911            if (D) {
912                if (n.cache[G]) {
913                    delete n.cache[G][D];
914                    D = "";
915                    for (D in n.cache[G]) {
916                        break
917                    }
918                    if (!D) {
919                        n.removeData(E)
920                    }
921                }
922            } else {
923                try {
924                    delete E[h]
925                } catch (F) {
926                    if (E.removeAttribute) {
927                        E.removeAttribute(h)
928                    }
929                }
930                delete n.cache[G]
931            }
932        },
933        queue: function(E, D, G) {
934            if (E) {
935                D = (D || "fx") + "queue";
936                var F = n.data(E, D);
937                if (!F || n.isArray(G)) {
938                    F = n.data(E, D, n.makeArray(G))
939                } else {
940                    if (G) {
941                        F.push(G)
942                    }
943                }
944            }
945            return F
946        },
947        dequeue: function(G, F) {
948            var D = n.queue(G, F),
949                E = D.shift();
950            if (!F || F === "fx") {
951                E = D[0]
952            }
953            if (E !== g) {
954                E.call(G)
955            }
956        }
957    });
958    n.fn.extend({
959        data: function(D, F) {
960            var G = D.split(".");
961            G[1] = G[1] ? "." + G[1] : "";
962            if (F === g) {
963                var E = this.triggerHandler("getData" + G[1] + "!", [G[0]]);
964                if (E === g && this.length) {
965                    E = n.data(this[0], D)
966                }
967                return E === g && G[1] ? this.data(G[0]) : E
968            } else {
969                return this.trigger("setData" + G[1] + "!", [G[0], F]).each(function() {
970                    n.data(this, D, F)
971                })
972            }
973        },
974        removeData: function(D) {
975            return this.each(function() {
976                n.removeData(this, D)
977            })
978        },
979        queue: function(D, E) {
980            if (typeof D !== "string") {
981                E = D;
982                D = "fx"
983            }
984            if (E === g) {
985                return n.queue(this[0], D)
986            }
987            return this.each(function() {
988                var F = n.queue(this, D, E);
989                if (D == "fx" && F.length == 1) {
990                    F[0].call(this)
991                }
992            })
993        },
994        dequeue: function(D) {
995            return this.each(function() {
996                n.dequeue(this, D)
997            })
998        }
999    });
1000    (function() {
1001        var N = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|[^[\]]+)+\]|\\.|[^ >+~,(\[]+)+|[>+~])(\s*,\s*)?/g,
1002            I = 0,
1003            F = Object.prototype.toString;
1004        var E = function(a, S, b, V) {
1005            b = b || [];
1006            S = S || document;
1007            if (S.nodeType !== 1 && S.nodeType !== 9) {
1008                return []
1009            }
1010            if (!a || typeof a !== "string") {
1011                return b
1012            }
1013            var c = [],
1014                ac, Y, ah, ag, Z, R, Q = true;
1015            N.lastIndex = 0;
1016            while ((ac = N.exec(a)) !== null) {
1017                c.push(ac[1]);
1018                if (ac[2]) {
1019                    R = RegExp.rightContext;
1020                    break
1021                }
1022            }
1023            if (c.length > 1 && G.match.POS.exec(a)) {
1024                if (c.length === 2 && G.relative[c[0]]) {
1025                    var U = "",
1026                        X;
1027                    while ((X = G.match.POS.exec(a))) {
1028                        U += X[0];
1029                        a = a.replace(G.match.POS, "")
1030                    }
1031                    Y = E.filter(U, E(/\s$/.test(a) ? a + "*" : a, S))
1032                } else {
1033                    Y = G.relative[c[0]] ? [S] : E(c.shift(), S);
1034                    while (c.length) {
1035                        var P = [];
1036                        a = c.shift();
1037                        if (G.relative[a]) {
1038                            a += c.shift()
1039                        }
1040                        for (var d = 0, ad = Y.length; d < ad; d++) {
1041                            E(a, Y[d], P)
1042                        }
1043                        Y = P
1044                    }
1045                }
1046            } else {
1047                var e = V ? {
1048                    expr: c.pop(),
1049                    set: D(V)
1050                } : E.find(c.pop(), c.length === 1 && S.parentNode ? S.parentNode : S);
1051                Y = E.filter(e.expr, e.set);
1052                if (c.length > 0) {
1053                    ah = D(Y)
1054                } else {
1055                    Q = false
1056                }
1057                while (c.length) {
1058                    var T = c.pop(),
1059                        W = T;
1060                    if (!G.relative[T]) {
1061                        T = ""
1062                    } else {
1063                        W = c.pop()
1064                    }
1065                    if (W == null) {
1066                        W = S
1067                    }
1068                    G.relative[T](ah, W, M(S))
1069                }
1070            }
1071            if (!ah) {
1072                ah = Y
1073            }
1074            if (!ah) {
1075                throw "Syntax error, unrecognized expression: " + (T || a)
1076            }
1077            if (F.call(ah) === "[object Array]") {
1078                if (!Q) {
1079                    b.push.apply(b, ah)
1080                } else {
1081                    if (S.nodeType === 1) {
1082                        for (var d = 0; ah[d] != null; d++) {
1083                            if (ah[d] && (ah[d] === true || ah[d].nodeType === 1 && H(S, ah[d]))) {
1084                                b.push(Y[d])
1085                            }
1086                        }
1087                    } else {
1088                        for (var d = 0; ah[d] != null; d++) {
1089                            if (ah[d] && ah[d].nodeType === 1) {
1090                                b.push(Y[d])
1091                            }
1092                        }
1093                    }
1094                }
1095            } else {
1096                D(ah, b)
1097            }
1098            if (R) {
1099                E(R, S, b, V)
1100            }
1101            return b
1102        };
1103        E.matches = function(P, Q) {
1104            return E(P, null, null, Q)
1105        };
1106        E.find = function(V, S) {
1107            var W, Q;
1108            if (!V) {
1109                return []
1110            }
1111            for (var R = 0, P = G.order.length; R < P; R++) {
1112                var T = G.order[R],
1113                    Q;
1114                if ((Q = G.match[T].exec(V))) {
1115                    var U = RegExp.leftContext;
1116                    if (U.substr(U.length - 1) !== "\\") {
1117                        Q[1] = (Q[1] || "").replace(/\\/g, "");
1118                        W = G.find[T](Q, S);
1119                        if (W != null) {
1120                            V = V.replace(G.match[T], "");
1121                            break
1122                        }
1123                    }
1124                }
1125            }
1126            if (!W) {
1127                W = S.getElementsByTagName("*")
1128            }
1129            return {
1130                set: W,
1131                expr: V
1132            }
1133        };
1134        E.filter = function(S, a, b, T) {
1135            var Q = S,
1136                Y = [],
1137                ah = a,
1138                V, ab;
1139            while (S && a.length) {
1140                for (var U in G.filter) {
1141                    if ((V = G.match[U].exec(S)) != null) {
1142                        var Z = G.filter[U],
1143                            R = null,
1144                            X = 0,
1145                            aa, ag;
1146                        ab = false;
1147                        if (ah == Y) {
1148                            Y = []
1149                        }
1150                        if (G.preFilter[U]) {
1151                            V = G.preFilter[U](V, ah, b, Y, T);
1152                            if (!V) {
1153                                ab = aa = true
1154                            } else {
1155                                if (V === true) {
1156                                    continue
1157                                } else {
1158                                    if (V[0] === true) {
1159                                        R = [];
1160                                        var W = null,
1161                                            af;
1162                                        for (var c = 0;
1163                                            (af = ah[c]) !== g; c++) {
1164                                            if (af && W !== af) {
1165                                                R.push(af);
1166                                                W = af
1167                                            }
1168                                        }
1169                                    }
1170                                }
1171                            }
1172                        }
1173                        if (V) {
1174                            for (var c = 0;
1175                                (ag = ah[c]) !== g; c++) {
1176                                if (ag) {
1177                                    if (R && ag != R[X]) {
1178                                        X++
1179                                    }
1180                                    aa = Z(ag, V, X, R);
1181                                    var P = T ^ !!aa;
1182                                    if (b && aa != null) {
1183                                        if (P) {
1184                                            ab = true
1185                                        } else {
1186                                            ah[c] = false
1187                                        }
1188                                    } else {
1189                                        if (P) {
1190                                            Y.push(ag);
1191                                            ab = true
1192                                        }
1193                                    }
1194                                }
1195                            }
1196                        }
1197                        if (aa !== g) {
1198                            if (!b) {
1199                                ah = Y
1200                            }
1201                            S = S.replace(G.match[U], "");
1202                            if (!ab) {
1203                                return []
1204                            }
1205                            break
1206                        }
1207                    }
1208                }
1209                S = S.replace(/\s*,\s*/, "");
1210                if (S == Q) {
1211                    if (ab == null) {
1212                        throw "Syntax error, unrecognized expression: " + S
1213                    } else {
1214                        break
1215                    }
1216                }
1217                Q = S
1218            }
1219            return ah
1220        };
1221        var G = E.selectors = {
1222            order: ["ID", "NAME", "TAG"],
1223            match: {
1224                ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1225                CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1226                NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
1227                ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
1228                TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
1229                CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
1230                POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
1231                PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
1232            },
1233            attrMap: {
1234                "class": "className",
1235                "for": "htmlFor"
1236            },
1237            attrHandle: {
1238                href: function(P) {
1239                    return P.getAttribute("href")
1240                }
1241            },
1242            relative: {
1243                "+": function(T, Q) {
1244                    for (var R = 0, P = T.length; R < P; R++) {
1245                        var S = T[R];
1246                        if (S) {
1247                            var U = S.previousSibling;
1248                            while (U && U.nodeType !== 1) {
1249                                U = U.previousSibling
1250                            }
1251                            T[R] = typeof Q === "string" ? U || false : U === Q
1252                        }
1253                    }
1254                    if (typeof Q === "string") {
1255                        E.filter(Q, T, true)
1256                    }
1257                },
1258                ">": function(U, Q, V) {
1259                    if (typeof Q === "string" && !/\W/.test(Q)) {
1260                        Q = V ? Q : Q.toUpperCase();
1261                        for (var R = 0, P = U.length; R < P; R++) {
1262                            var T = U[R];
1263                            if (T) {
1264                                var S = T.parentNode;
1265                                U[R] = S.nodeName === Q ? S : false
1266                            }
1267                        }
1268                    } else {
1269                        for (var R = 0, P = U.length; R < P; R++) {
1270                            var T = U[R];
1271                            if (T) {
1272                                U[R] = typeof Q === "string" ? T.parentNode : T.parentNode === Q
1273                            }
1274                        }
1275                        if (typeof Q === "string") {
1276                            E.filter(Q, U, true)
1277                        }
1278                    }
1279                },
1280                "": function(S, Q, U) {
1281                    var R = "done" + (I++),
1282                        P = O;
1283                    if (!Q.match(/\W/)) {
1284                        var T = Q = U ? Q : Q.toUpperCase();
1285                        P = L
1286                    }
1287                    P("parentNode", Q, R, S, T, U)
1288                },
1289                "~": function(S, Q, U) {
1290                    var R = "done" + (I++),
1291                        P = O;
1292                    if (typeof Q === "string" && !Q.match(/\W/)) {
1293                        var T = Q = U ? Q : Q.toUpperCase();
1294                        P = L
1295                    }
1296                    P("previousSibling", Q, R, S, T, U)
1297                }
1298            },
1299            find: {
1300                ID: function(Q, R) {
1301                    if (R.getElementById) {
1302                        var P = R.getElementById(Q[1]);
1303                        return P ? [P] : []
1304                    }
1305                },
1306                NAME: function(P, Q) {
1307                    return Q.getElementsByName ? Q.getElementsByName(P[1]) : null
1308                },
1309                TAG: function(P, Q) {
1310                    return Q.getElementsByTagName(P[1])
1311                }
1312            },
1313            preFilter: {
1314                CLASS: function(S, Q, R, P, U) {
1315                    S = " " + S[1].replace(/\\/g, "") + " ";
1316                    for (var T = 0; Q[T]; T++) {
1317                        if (U ^ (" " + Q[T].className + " ").indexOf(S) >= 0) {
1318                            if (!R) {
1319                                P.push(Q[T])
1320                            }
1321                        } else {
1322                            if (R) {
1323                                Q[T] = false
1324                            }
1325                        }
1326                    }
1327                    return false
1328                },
1329                ID: function(P) {
1330                    return P[1].replace(/\\/g, "")
1331                },
1332                TAG: function(Q, P) {
1333                    for (var R = 0; !P[R]; R++) {}
1334                    return M(P[R]) ? Q[1] : Q[1].toUpperCase()
1335                },
1336                CHILD: function(P) {
1337                    if (P[1] == "nth") {
1338                        var Q = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(P[2] == "even" && "2n" || P[2] == "odd" && "2n+1" || !/\D/.test(P[2]) && "0n+" + P[2] || P[2]);
1339                        P[2] = (Q[1] + (Q[2] || 1)) - 0;
1340                        P[3] = Q[3] - 0
1341                    }
1342                    P[0] = "done" + (I++);
1343                    return P
1344                },
1345                ATTR: function(Q) {
1346                    var P = Q[1];
1347                    if (G.attrMap[P]) {
1348                        Q[1] = G.attrMap[P]
1349                    }
1350                    if (Q[2] === "~=") {
1351                        Q[4] = " " + Q[4] + " "
1352                    }
1353                    return Q
1354                },
1355                PSEUDO: function(T, Q, R, P, U) {
1356                    if (T[1] === "not") {
1357                        if (T[3].match(N).length > 1) {
1358                            T[3] = E(T[3], null, null, Q)
1359                        } else {
1360                            var S = E.filter(T[3], Q, R, true ^ U);
1361                            if (!R) {
1362                                P.push.apply(P, S)
1363                            }
1364                            return false
1365                        }
1366                    } else {
1367                        if (G.match.POS.test(T[0])) {
1368                            return true
1369                        }
1370                    }
1371                    return T
1372                },
1373                POS: function(P) {
1374                    P.unshift(true);
1375                    return P
1376                }
1377            },
1378            filters: {
1379                enabled: function(P) {
1380                    return P.disabled === false && P.type !== "hidden"
1381                },
1382                disabled: function(P) {
1383                    return P.disabled === true
1384                },
1385                checked: function(P) {
1386                    return P.checked === true
1387                },
1388                selected: function(P) {
1389                    P.parentNode.selectedIndex;
1390                    return P.selected === true
1391                },
1392                parent: function(P) {
1393                    return !!P.firstChild
1394                },
1395                empty: function(P) {
1396                    return !P.firstChild
1397                },
1398                has: function(R, Q, P) {
1399                    return !!E(P[3], R).length
1400                },
1401                header: function(P) {
1402                    return /h\d/i.test(P.nodeName)
1403                },
1404                text: function(P) {
1405                    return "text" === P.type
1406                },
1407                radio: function(P) {
1408                    return "radio" === P.type
1409                },
1410                checkbox: function(P) {
1411                    return "checkbox" === P.type
1412                },
1413                file: function(P) {
1414                    return "file" === P.type
1415                },
1416                password: function(P) {
1417                    return "password" === P.type
1418                },
1419                submit: function(P) {
1420                    return "submit" === P.type
1421                },
1422                image: function(P) {
1423                    return "image" === P.type
1424                },
1425                reset: function(P) {
1426                    return "reset" === P.type
1427                },
1428                button: function(P) {
1429                    return "button" === P.type || P.nodeName.toUpperCase() === "BUTTON"
1430                },
1431                input: function(P) {
1432                    return /input|select|textarea|button/i.test(P.nodeName)
1433                }
1434            },
1435            setFilters: {
1436                first: function(Q, P) {
1437                    return P === 0
1438                },
1439                last: function(R, Q, P, S) {
1440                    return Q === S.length - 1
1441                },
1442                even: function(Q, P) {
1443                    return P % 2 === 0
1444                },
1445                odd: function(Q, P) {
1446                    return P % 2 === 1
1447                },
1448                lt: function(R, Q, P) {
1449                    return Q < P[3] - 0
1450                },
1451                gt: function(R, Q, P) {
1452                    return Q > P[3] - 0
1453                },
1454                nth: function(R, Q, P) {
1455                    return P[3] - 0 == Q
1456                },
1457                eq: function(R, Q, P) {
1458                    return P[3] - 0 == Q
1459                }
1460            },
1461            filter: {
1462                CHILD: function(P, S) {
1463                    var V = S[1],
1464                        W = P.parentNode;
1465                    var U = "child" + W.childNodes.length;
1466                    if (W && (!W[U] || !P.nodeIndex)) {
1467                        var T = 1;
1468                        for (var Q = W.firstChild; Q; Q = Q.nextSibling) {
1469                            if (Q.nodeType == 1) {
1470                                Q.nodeIndex = T++
1471                            }
1472                        }
1473                        W[U] = T - 1
1474                    }
1475                    if (V == "first") {
1476                        return P.nodeIndex == 1
1477                    } else {
1478                        if (V == "last") {
1479                            return P.nodeIndex == W[U]
1480                        } else {
1481                            if (V == "only") {
1482                                return W[U] == 1
1483                            } else {
1484                                if (V == "nth") {
1485                                    var Y = false,
1486                                        R = S[2],
1487                                        X = S[3];
1488                                    if (R == 1 && X == 0) {
1489                                        return true
1490                                    }
1491                                    if (R == 0) {
1492                                        if (P.nodeIndex == X) {
1493                                            Y = true
1494                                        }
1495                                    } else {
1496                                        if ((P.nodeIndex - X) % R == 0 && (P.no
1496deIndex - X) / R >= 0) {
1497                                            Y = true
1498                                        }
1499                                    }
1500                                    return Y
1501                                }
1502                            }
1503                        }
1504                    }
1505                },
1506                PSEUDO: function(V, R, S, W) {
1507                    var Q = R[1],
1508                        T = G.filters[Q];
1509                    if (T) {
1510                        return T(V, S, R, W)
1511                    } else {
1512                        if (Q === "contains") {
1513                            return (V.textContent || V.innerText || "").indexOf(R[3]) >= 0
1514                        } else {
1515                            if (Q === "not") {
1516                                var U = R[3];
1517                                for (var S = 0, P = U.length; S < P; S++) {
1518                                    if (U[S] === V) {
1519                                        return false
1520                                    }
1521                                }
1522                                return true
1523                            }
1524                        }
1525                    }
1526                },
1527                ID: function(Q, P) {
1528                    return Q.nodeType === 1 && Q.getAttribute("id") === P
1529                },
1530                TAG: function(Q, P) {
1531                    return (P === "*" && Q.nodeType === 1) || Q.nodeName === P
1532                },
1533                CLASS: function(Q, P) {
1534                    return P.test(Q.className)
1535                },
1536                ATTR: function(T, R) {
1537                    var P = G.attrHandle[R[1]] ? G.attrHandle[R[1]](T) : T[R[1]] || T.getAttribute(R[1]),
1538                        U = P + "",
1539                        S = R[2],
1540                        Q = R[4];
1541                    return P == null ? false : S === "=" ? U === Q : S === "*=" ? U.indexOf(Q) >= 0 : S === "~=" ? (" " + U + " ").indexOf(Q) >= 0 : !R[4] ? P : S === "!=" ? U != Q : S === "^=" ? U.indexOf(Q) === 0 : S === "$=" ? U.substr(U.length - Q.length) === Q : S === "|=" ? U === Q || U.substr(0, Q.length + 1) === Q + "-" : false
1542                },
1543                POS: function(T, Q, R, U) {
1544                    var P = Q[2],
1545                        S = G.setFilters[P];
1546                    if (S) {
1547                        return S(T, R, Q, U)
1548                    }
1549                }
1550            }
1551        };
1552        for (var K in G.match) {
1553            G.match[K] = RegExp(G.match[K].source + /(?![^\[]*\])(?![^\(]*\))/.source)
1554        }
1555        var D = function(Q, P) {
1556            Q = Array.prototype.slice.call(Q);
1557            if (P) {
1558                P.push.apply(P, Q);
1559                return P
1560            }
1561            return Q
1562        };
1563        try {
1564            Array.prototype.slice.call(document.documentElement.childNodes)
1565        } catch (J) {
1566            D = function(T, S) {
1567                var Q = S || [];
1568                if (F.call(T) === "[object Array]") {
1569                    Array.prototype.push.apply(Q, T)
1570                } else {
1571                    if (typeof T.length === "number") {
1572                        for (var R = 0, P = T.length; R < P; R++) {
1573                            Q.push(T[R])
1574                        }
1575                    } else {
1576                        for (var R = 0; T[R]; R++) {
1577                            Q.push(T[R])
1578                        }
1579                    }
1580                }
1581                return Q
1582            }
1583        }(function() {
1584            var Q = document.createElement("form"),
1585                R = "script" + (new Date).getTime();
1586            Q.innerHTML = "<input name='" + R + "'/>";
1587            var P = document.documentElement;
1588            P.insertBefore(Q, P.firstChild);
1589            if (!!document.getElementById(R)) {
1590                G.find.ID = function(T, U) {
1591                    if (U.getElementById) {
1592                        var S = U.getElementById(T[1]);
1593                        return S ? S.id === T[1] || S.getAttributeNode && S.getAttributeNode("id").nodeValue === T[1] ? [S] : g : []
1594                    }
1595                };
1596                G.filter.ID = function(U, S) {
1597                    var T = U.getAttributeNode && U.getAttributeNode("id");
1598                    return U.nodeType === 1 && T && T.nodeValue === S
1599                }
1600            }
1601            P.removeChild(Q)
1602        })();
1603        (function() {
1604            var P = document.createElement("div");
1605            P.appendChild(document.createComment(""));
1606            if (P.getElementsByTagName("*").length > 0) {
1607                G.find.TAG = function(Q, U) {
1608                    var T = U.getElementsByTagName(Q[1]);
1609                    if (Q[1] === "*") {
1610                        var S = [];
1611                        for (var R = 0; T[R]; R++) {
1612                            if (T[R].nodeType === 1) {
1613                                S.push(T[R])
1614                            }
1615                        }
1616                        T = S
1617                    }
1618                    return T
1619                }
1620            }
1621            P.innerHTML = "<a href='#'></a>";
1622            if (P.firstChild.getAttribute("href") !== "#") {
1623                G.attrHandle.href = function(Q) {
1624                    return Q.getAttribute("href", 2)
1625                }
1626            }
1627        })();
1628        if (document.querySelectorAll) {
1629            (function() {
1630                var P = E;
1631                E = function(T, S, Q, R) {
1632                    S = S || document;
1633                    if (!R && S.nodeType === 9) {
1634                        try {
1635                            return D(S.querySelectorAll(T), Q)
1636                        } catch (U) {}
1637                    }
1638                    return P(T, S, Q, R)
1639                };
1640                E.find = P.find;
1641                E.filter = P.filter;
1642                E.selectors = P.selectors;
1643                E.matches = P.matches
1644            })()
1645        }
1646        if (document.documentElement.getElementsByClassName) {
1647            G.order.splice(1, 0, "CLASS");
1648            G.find.CLASS = function(P, Q) {
1649                return Q.getElementsByClassName(P[1])
1650            }
1651        }
1652
1653        function L(Q, W, V, Z, X, Y) {
1654            for (var T = 0, R = Z.length; T < R; T++) {
1655                var P = Z[T];
1656                if (P) {
1657                    P = P[Q];
1658                    var U = false;
1659                    while (P && P.nodeType) {
1660                        var S = P[V];
1661                        if (S) {
1662                            U = Z[S];
1663                            break
1664                        }
1665                        if (P.nodeType === 1 && !Y) {
1666                            P[V] = T
1667                        }
1668                        if (P.nodeName === W) {
1669                            U = P;
1670                            break
1671                        }
1672                        P = P[Q]
1673                    }
1674                    Z[T] = U
1675                }
1676            }
1677        }
1678
1679        function O(Q, V, U, Y, W, X) {
1680            for (var S = 0, R = Y.length; S < R; S++) {
1681                var P = Y[S];
1682                if (P) {
1683                    P = P[Q];
1684                    var T = false;
1685                    while (P && P.nodeType) {
1686                        if (P[U]) {
1687                            T = Y[P[U]];
1688                            break
1689                        }
1690                        if (P.nodeType === 1) {
1691                            if (!X) {
1692                                P[U] = S
1693                            }
1694                            if (typeof V !== "string") {
1695                                if (P === V) {
1696                                    T = true;
1697                                    break
1698                                }
1699                            } else {
1700                                if (E.filter(V, [P]).length > 0) {
1701                                    T = P;
1702                                    break
1703                                }
1704                            }
1705                        }
1706                        P = P[Q]
1707                    }
1708                    Y[S] = T
1709                }
1710            }
1711        }
1712        var H = document.compareDocumentPosition ? function(Q, P) {
1713            return Q.compareDocumentPosition(P) & 16
1714        } : function(Q, P) {
1715            return Q !== P && (Q.contains ? Q.contains(P) : true)
1716        };
1717        var M = function(P) {
1718            return P.documentElement && !P.body || P.tagName && P.ownerDocument && !P.ownerDocument.body
1719        };
1720        n.find = E;
1721        n.filter = E.filter;
1722        n.expr = E.selectors;
1723        n.expr[":"] = n.expr.filters;
1724        E.selectors.filters.hidden = function(P) {
1725            return "hidden" === P.type || n.css(P, "display") === "none" || n.css(P, "visibility") === "hidden"
1726        };
1727        E.selectors.filters.visible = function(P) {
1728            return "hidden" !== P.type && n.css(P, "display") !== "none" && n.css(P, "visibility") !== "hidden"
1729        };
1730        E.selectors.filters.animated = function(P) {
1731            return n.grep(n.timers, function(Q) {
1732                return P === Q.elem
1733            }).length
1734        };
1735        n.multiFilter = function(R, P, Q) {
1736            if (Q) {
1737                R = ":not(" + R + ")"
1738            }
1739            return E.matches(R, P)
1740        };
1741        n.dir = function(R, Q) {
1742            var P = [],
1743                S = R[Q];
1744            while (S && S != document) {
1745                if (S.nodeType == 1) {
1746                    P.push(S)
1747                }
1748                S = S[Q]
1749            }
1750            return P
1751        };
1752        n.nth = function(T, P, R, S) {
1753            P = P || 1;
1754            var Q = 0;
1755            for (; T; T = T[R]) {
1756                if (T.nodeType == 1 && ++Q == P) {
1757                    break
1758                }
1759            }
1760            return T
1761        };
1762        n.sibling = function(R, Q) {
1763            var P = [];
1764            for (; R; R = R.nextSibling) {
1765                if (R.nodeType == 1 && R != Q) {
1766                    P.push(R)
1767                }
1768            }
1769            return P
1770        };
1771        return;
1772        l.Sizzle = E
1773    })();
1774    n.event = {
1775        add: function(H, E, G, J) {
1776            if (H.nodeType == 3 || H.nodeType == 8) {
1777                return
1778            }
1779            if (H.setInterval && H != l) {
1780                H = l
1781            }
1782            if (!G.guid) {
1783                G.guid = this.guid++
1784            }
1785            if (J !== g) {
1786                var F = G;
1787                G = this.proxy(F);
1788                G.data = J
1789            }
1790            var D = n.data(H, "events") || n.data(H, "events", {}),
1791                I = n.data(H, "handle") || n.data(H, "handle", function() {
1792                    return typeof n !== "undefined" && !n.event.triggered ? n.event.handle.apply(arguments.callee.elem, arguments) : g
1793                });
1794            I.elem = H;
1795            n.each(E.split(/\s+/), function(L, M) {
1796                var N = M.split(".");
1797                M = N.shift();
1798                G.type = N.slice().sort().join(".");
1799                var K = D[M];
1800                if (n.event.specialAll[M]) {
1801                    n.event.specialAll[M].setup.call(H, J, N)
1802                }
1803                if (!K) {
1804                    K = D[M] = {};
1805                    if (!n.event.special[M] || n.event.special[M].setup.call(H, J, N) === false) {
1806                        if (H.addEventListener) {
1807                            H.addEventListener(M, I, false)
1808                        } else {
1809                            if (H.attachEvent) {
1810                                H.attachEvent("on" + M, I)
1811                            }
1812                        }
1813                    }
1814                }
1815                K[G.guid] = G;
1816                n.event.global[M] = true
1817            });
1818            H = null
1819        },
1820        guid: 1,
1821        global: {},
1822        remove: function(J, G, I) {
1823            if (J.nodeType == 3 || J.nodeType == 8) {
1824                return
1825            }
1826            var F = n.data(J, "events"),
1827                E, D;
1828            if (F) {
1829                if (G === g || (typeof G === "string" && G.charAt(0) == ".")) {
1830                    for (var H in F) {
1831                        this.remove(J, H + (G || ""))
1832                    }
1833                } else {
1834                    if (G.type) {
1835                        I = G.handler;
1836                        G = G.type
1837                    }
1838                    n.each(G.split(/\s+/), function(L, N) {
1839                        var P = N.split(".");
1840                        N = P.shift();
1841                        var M = RegExp("(^|\\.)" + P.slice().sort().join(".*\\.") + "(\\.|$)");
1842                        if (F[N]) {
1843                            if (I) {
1844                                delete F[N][I.guid]
1845                            } else {
1846                                for (var O in F[N]) {
1847                                    if (M.test(F[N][O].type)) {
1848                                        delete F[N][O]
1849                                    }
1850                                }
1851                            }
1852                            if (n.event.specialAll[N]) {
1853                                n.event.specialAll[N].teardown.call(J, P)
1854                            }
1855                            for (E in F[N]) {
1856                                break
1857                            }
1858                            if (!E) {
1859                                if (!n.event.special[N] || n.event.special[N].teardown.call(J, P) === false) {
1860                                    if (J.removeEventListener) {
1861                                        J.removeEventListener(N, n.data(J, "handle"), false)
1862                                    } else {
1863                                        if (J.detachEvent) {
1864                                            J.detachEvent("on" + N, n.data(J, "handle"))
1865                                        }
1866                                    }
1867                                }
1868                                E = null;
1869                                delete F[N]
1870                            }
1871                        }
1872                    })
1873                }
1874                for (E in F) {
1875                    break
1876                }
1877                if (!E) {
1878                    var K = n.data(J, "handle");
1879                    if (K) {
1880                        K.elem = null
1881                    }
1882                    n.removeData(J, "events");
1883                    n.removeData(J, "handle")
1884                }
1885            }
1886        },
1887        trigger: function(H, J, G, D) {
1888            var F = H.type || H;
1889            if (!D) {
1890                H = typeof H === "object" ? H[h] ? H : n.extend(n.Event(F), H) : n.Event(F);
1891                if (F.indexOf("!") >= 0) {
1892                    H.type = F = F.slice(0, -1);
1893                    H.exclusive = true
1894                }
1895                if (!G) {
1896                    H.stopPropagation();
1897                    if (this.global[F]) {
1898                        n.each(n.cache, function() {
1899                            if (this.events && this.events[F]) {
1900                                n.event.trigger(H, J, this.handle.elem)
1901                            }
1902                        })
1903                    }
1904                }
1905                if (!G || G.nodeType == 3 || G.nodeType == 8) {
1906                    return g
1907                }
1908                H.result = g;
1909                H.target = G;
1910                J = n.makeArray(J);
1911                J.unshift(H)
1912            }
1913            H.currentTarget = G;
1914            var I = n.data(G, "handle");
1915            if (I) {
1916                I.apply(G, J)
1917            }
1918            if ((!G[F] || (n.nodeName(G, "a") && F == "click")) && G["on" + F] && G["on" + F].apply(G, J) === false) {
1919                H.result = false
1920            }
1921            if (!D && G[F] && !H.isDefaultPrevented() && !(n.nodeName(G, "a") && F == "click")) {
1922                this.triggered = true;
1923                try {
1924                    G[F]()
1925                } catch (K) {}
1926            }
1927            this.triggered = false;
1928            if (!H.isPropagationStopped()) {
1929                var E = G.parentNode || G.ownerDocument;
1930                if (E) {
1931                    n.event.trigger(H, J, E, true)
1932                }
1933            }
1934        },
1935        handle: function(J) {
1936            var I, D;
1937            J = arguments[0] = n.event.fix(J || l.event);
1938            var K = J.type.split(".");
1939            J.type = K.shift();
1940            I = !K.length && !J.exclusive;
1941            var H = RegExp("(^|\\.)" + K.slice().sort().join(".*\\.") + "(\\.|$)");
1942            D = (n.data(this, "events") || {})[J.type];
1943            for (var F in D) {
1944                var G = D[F];
1945                if (I || H.test(G.type)) {
1946                    J.handler = G;
1947                    J.data = G.data;
1948                    var E = G.apply(this, arguments);
1949                    if (E !== g) {
1950                        J.result = E;
1951                        if (E === false) {
1952                            J.preventDefault();
1953                            J.stopPropagation()
1954                        }
1955                    }
1956                    if (J.isImmediatePropagationStopped()) {
1957                        break
1958                    }
1959                }
1960            }
1961        },
1962        props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
1963        fix: function(G) {
1964            if (G[h]) {
1965                return G
1966            }
1967            var E = G;
1968            G = n.Event(E);
1969            for (var F = this.props.length, I; F;) {
1970                I = this.props[--F];
1971                G[I] = E[I]
1972            }
1973            if (!G.target) {
1974                G.target = G.srcElement || document
1975            }
1976            if (G.target.nodeType == 3) {
1977                G.target = G.target.parentNode
1978            }
1979            if (!G.relatedTarget && G.fromElement) {
1980                G.relatedTarget = G.fromElement == G.target ? G.toElement : G.fromElement
1981            }
1982            if (G.pageX == null && G.clientX != null) {
1983                var H = document.documentElement,
1984                    D = document.body;
1985                G.pageX = G.clientX + (H && H.scrollLeft || D && D.scrollLeft || 0) - (H.clientLeft || 0);
1986                G.pageY = G.clientY + (H && H.scrollTop || D && D.scrollTop || 0) - (H.clientTop || 0)
1987            }
1988            if (!G.which && ((G.charCode || G.charCode === 0) ? G.charCode : G.keyCode)) {
1989                G.which = G.charCode || G.keyCode
1990            }
1991            if (!G.metaKey && G.ctrlKey) {
1992                G.metaKey = G.ctrlKey
1993            }
1994            if (!G.which && G.button) {
1995                G.which = (G.button & 1 ? 1 : (G.button & 2 ? 3 : (G.button & 4 ? 2 : 0)))
1996            }
1997            return G
1998        },
1999        proxy: function(E, D) {
2000            D = D || function() {
2001                return E.apply(this, arguments)
2002            };
2003            D.guid = E.guid = E.guid || D.guid || this.guid++;
2004            return D
2005        },
2006        special: {
2007            ready: {
2008                setup: A,
2009                teardown: function() {}
2010            }
2011        },
2012        specialAll: {
2013            live: {
2014                setup: function(D, E) {
2015                    n.event.add(this, E[0], c)
2016                },
2017                teardown: function(F) {
2018                    if (F.length) {
2019                        var D = 0,
2020                            E = RegExp("(^|\\.)" + F[0] + "(\\.|$)");
2021                        n.each((n.data(this, "events").live || {}), function() {
2022                            if (E.test(this.type)) {
2023                                D++
2024                            }
2025                        });
2026                        if (D < 1) {
2027                            n.event.remove(this, F[0], c)
2028                        }
2029                    }
2030                }
2031            }
2032        }
2033    };
2034    n.Event = function(D) {
2035        if (!this.preventDefault) {
2036            return new n.Event(D)
2037        }
2038        if (D && D.type) {
2039            this.originalEvent = D;
2040            this.type = D.type;
2041            this.timeStamp = D.timeStamp
2042        } else {
2043            this.type = D
2044        }
2045        if (!this.timeStamp) {
2046            this.timeStamp = e()
2047        }
2048        this[h] = true
2049    };
2050
2051    function k() {
2052        return false
2053    }
2054
2055    function t() {
2056        return true
2057    }
2058    n.Event.prototype = {
2059        preventDefault: function() {
2060            this.isDefaultPrevented = t;
2061            var D = this.originalEvent;
2062            if (!D) {
2063                return
2064            }
2065            if (D.preventDefault) {
2066                D.preventDefault()
2067            }
2068            D.returnValue = false
2069        },
2070        stopPropagation: function() {
2071            this.isPropagationStopped = t;
2072            var D = this.originalEvent;
2073            if (!D) {
2074                return
2075            }
2076            if (D.stopPropagation) {
2077                D.stopPropagation()
2078            }
2079            D.cancelBubble = true
2080        },
2081        stopImmediatePropagation: function() {
2082            this.isImmediatePropagationStopped = t;
2083            this.stopPropagation()
2084        },
2085        isDefaultPrevented: k,
2086        isPropagationStopped: k,
2087        isImmediatePropagationStopped: k
2088    };
2089    var a = function(E) {
2090        var D = E.relatedTarget;
2091        while (D && D != this) {
2092            try {
2093                D = D.parentNode
2094            } catch (F) {
2095                D = this
2096            }
2097        }
2098        if (D != this) {
2099            E.type = E.data;
2100            n.event.handle.apply(this, arguments)
2101        }
2102    };
2103    n.each({
2104        mouseover: "mouseenter",
2105        mouseout: "mouseleave"
2106    }, function(E, D) {
2107        n.event.special[D] = {
2108            setup: function() {
2109                n.event.add(this, E, a, D)
2110            },
2111            teardown: function() {
2112                n.event.remove(this, E, a)
2113            }
2114        }
2115    });
2116    n.fn.extend({
2117        bind: function(E, F, D) {
2118            return E == "unload" ? this.one(E, F, D) : this.each(function() {
2119                n.event.add(this, E, D || F, D && F)
2120            })
2121        },
2122        one: function(F, G, E) {
2123            var D = n.event.proxy(E || G, function(H) {
2124                n(this).unbind(H, D);
2125                return (E || G).apply(this, arguments)
2126            });
2127            return this.each(function() {
2128                n.event.add(this, F, D, E && G)
2129            })
2130        },
2131        unbind: function(E, D) {
2132            return this.each(function() {
2133                n.event.remove(this, E, D)
2134            })
2135        },
2136        trigger: function(D, E) {
2137            return this.each(function() {
2138                n.event.trigger(D, E, this)
2139            })
2140        },
2141        triggerHandler: function(D, F) {
2142            if (this[0]) {
2143                var E = n.Event(D);
2144                E.preventDefault();
2145                E.stopPropagation();
2146                n.event.trigger(E, F, this[0]);
2147                return E.result
2148            }
2149        },
2150        toggle: function(F) {
2151            var D = arguments,
2152                E = 1;
2153            while (E < D.length) {
2154                n.event.proxy(F, D[E++])
2155            }
2156            return this.click(n.event.proxy(F, function(G) {
2157                this.lastToggle = (this.lastToggle || 0) % E;
2158                G.preventDefault();
2159                return D[this.lastToggle++].apply(this, arguments) || false
2160            }))
2161        },
2162        hover: function(D, E) {
2163            return this.mouseenter(D).mouseleave(E)
2164        },
2165        ready: function(D) {
2166            A();
2167            if (n.isReady) {
2168                D.call(document, n)
2169            } else {
2170                n.readyList.push(D)
2171            }
2172            return this
2173        },
2174        live: function(F, E) {
2175            var D = n.event.proxy(E);
2176            D.guid += this.selector + F;
2177            n(document).bind(i(F, this.selector), this.selector, D);
2178            return this
2179        },
2180        die: function(E, D) {
2181            n(document).unbind(i(E, this.selector), D ? {
2182                guid: D.guid + this.selector + E
2183            } : null);
2184            return this
2185        }
2186    });
2187
2188    function c(G) {
2189        var D = RegExp("(^|\\.)" + G.type + "(\\.|$)"),
2190            F = true,
2191            E = [];
2192        n.each(n.data(this, "events").live || [], function(H, I) {
2193            if (D.test(I.type)) {
2194                var J = n(G.target).closest(I.data)[0];
2195                if (J) {
2196                    E.push({
2197                        elem: J,
2198                        fn: I
2199                    })
2200                }
2201            }
2202        });
2203        n.each(E, function() {
2204            if (!G.isImmediatePropagationStopped() && this.fn.call(this.elem, G, this.fn.data) === false) {
2205                F = false
2206            }
2207        });
2208        return F
2209    }
2210
2211    function i(E, D) {
2212        return ["live", E, D.replace(/\./g, "`").replace(/ /g, "|")].join(".")
2213    }
2214    n.extend({
2215        isReady: false,
2216        readyList: [],
2217        ready: function() {
2218            if (!n.isReady) {
2219                n.isReady = true;
2220                if (n.readyList) {
2221                    n.each(n.readyList, function() {
2222                        this.call(document, n)
2223                    });
2224                    n.readyList = null
2225                }
2226                n(document).triggerHandler("ready")
2227            }
2228        }
2229    });
2230    var w = false;
2231
2232    function A() {
2233        if (w) {
2234            return
2235        }
2236        w = true;
2237        if (document.addEventListener) {
2238            document.addEventListener("DOMContentLoaded", function() {
2239                document.removeEventListener("DOMContentLoaded", arguments.callee, false);
2240                n.ready()
2241            }, false)
2242        } else {
2243            if (document.attachEvent) {
2244                document.attachEvent("onreadystatechange", function() {
2245                    if (document.readyState === "complete") {
2246                        document.detachEvent("onreadystatechange", arguments.callee);
2247                        n.ready()
2248                    }
2249                });
2250                if (document.documentElement.doScroll && !l.frameElement) {
2251                    (function() {
2252                        if (n.isReady) {
2253                            return
2254                        }
2255                        try {
2256                            document.documentElement.doScroll("left")
2257                        } catch (D) {
2258                            setTimeout(arguments.callee, 0);
2259                            return
2260                        }
2261                        n.ready()
2262                    })()
2263                }
2264            }
2265        }
2266        n.event.add(l, "load", n.ready)
2267    }
2268    n.each(("blur,focus,load,resize,scroll,unload,click,dblclick,mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave,change,select,submit,keydown,keypress,keyup,error").split(","), function(E, D) {
2269        n.fn[D] = function(F) {
2270            return F ? this.bind(D, F) : this.trigger(D)
2271        }
2272    });
2273    n(l).bind("unload", function() {
2274        for (var D in n.cache) {
2275            if (D != 1 && n.cache[D].handle) {
2276                n.event.remove(n.cache[D].handle.elem)
2277            }
2278        }
2279    });
2280    (function() {
2281        n.support = {};
2282        var E = document.documentElement,
2283            F = document.createElement("script"),
2284            J = document.createElement("div"),
2285            I = "script" + (new Date).getTime();
2286        J.style.display = "none";
2287        J.innerHTML = '   <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param/></object>';
2288        var G = J.getElementsByTagName("*"),
2289            D = J.getElementsByTagName("a")[0];
2290        if (!G || !G.length || !D) {
2291            return
2292        }
2293        n.support = {
2294            leadingWhitespace: J.firstChild.nodeType == 3,
2295            tbody: !J.getElementsByTagName("tbody").length,
2296            objectAll: !!J.getElementsByTagName("object")[0].getElementsByTagName("*").length,
2297            htmlSerialize: !!J.getElementsByTagName("link").length,
2298            style: /red/.test(D.getAttribute("style")),
2299            hrefNormalized: D.getAttribute("href") === "/a",
2300            opacity: D.style.opacity === "0.5",
2301            cssFloat: !!D.style.cssFloat,
2302            scriptEval: false,
2303            noCloneEvent: true,
2304            boxModel: null
2305        };
2306        F.type = "text/javascript";
2307        try {
2308            F.appendChild(document.createTextNode("window." + I + "=1;"))
2309        } catch (H) {}
2310        E.insertBefore(F, E.firstChild);
2311        if (l[I]) {
2312            n.support.scriptEval = true;
2313            delete l[I]
2314        }
2315        E.removeChild(F);
2316        if (J.attachEvent && J.fireEvent) {
2317            J.attachEvent("onclick", function() {
2318                n.support.noCloneEvent = false;
2319                J.detachEvent("onclick", arguments.callee)
2320            });
2321            J.cloneNode(true).fireEvent("onclick")
2322        }
2323        n(function() {
2324            var K = document.createElement("div");
2325            K.style.width = "1px";
2326            K.style.paddingLeft = "1px";
2327            document.body.appendChild(K);
2328            n.boxModel = n.support.boxModel = K.offsetWidth === 2;
2329            document.body.removeChild(K)
2330        })
2331    })();
2332    var v = n.support.cssFloat ? "cssFloat" : "styleFloat";
2333    n.props = {
2334        "for": "htmlFor",
2335        "class": "className",
2336        "float": v,
2337        cssFloat: v,
2338        styleFloat: v,
2339        readonly: "readOnly",
2340        maxlength: "maxLength",
2341        cellspacing: "cellSpacing",
2342        rowspan: "rowSpan",
2343        tabindex: "tabIndex"
2344    };
2345    n.fn.extend({
2346        _load: n.fn.load,
2347        load: function(F, I, J) {
2348            if (typeof F !== "string") {
2349                return this._load(F)
2350            }
2351            var H = F.indexOf(" ");
2352            if (H >= 0) {
2353                var D = F.slice(H, F.length);
2354                F = F.slice(0, H)
2355            }
2356            var G = "GET";
2357            if (I) {
2358                if (n.isFunction(I)) {
2359                    J = I;
2360                    I = null
2361                } else {
2362                    if (typeof I === "object") {
2363                        I = n.param(I);
2364                        G = "POST"
2365                    }
2366                }
2367            }
2368            var E = this;
2369            n.ajax({
2370                url: F,
2371                type: G,
2372                dataType: "html",
2373                data: I,
2374                complete: function(L, K) {
2375                    if (K == "success" || K == "notmodified") {
2376                        E.html(D ? n("<div/>").append(L.responseText.replace(/<script(.|\s)*?\/script>/g, "")).find(D) : L.responseText)
2377                    }
2378                    if (J) {
2379                        E.each(J, [L.responseText, K, L])
2380                    }
2381                }
2382            });
2383            return this
2384        },
2385        serialize: function() {
2386            return n.param(this.serializeArray())
2387        },
2388        serializeArray: function() {
2389            return this.map(function() {
2390                return this.elements ? n.makeArray(this.elements) : this
2391            }).filter(function() {
2392                return this.name && !this.disabled && (this.checked || /select|textarea/i.test(this.nodeName) || /text|hidden|password/i.test(this.type))
2393            }).map(function(D, E) {
2394                var F = n(this).val();
2395                return F == null ? null : n.isArray(F) ? n.map(F, function(H, G) {
2396                    return {
2397                        name: E.name,
2398                        value: H
2399                    }
2400                }) : {
2401                    name: E.name,
2402                    value: F
2403                }
2404            }).get()
2405        }
2406    });
2407    n.each("ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(D, E) {
2408        n.fn[E] = function(F) {
2409            return this.bind(E, F)
2410        }
2411    });
2412    var q = e();
2413    n.extend({
2414        get: function(D, F, G, E) {
2415            if (n.isFunction(F)) {
2416                G = F;
2417                F = null
2418            }
2419            return n.ajax({
2420                type: "GET",
2421                url: D,
2422                data: F,
2423                success: G,
2424                dataType: E
2425            })
2426        },
2427        getScript: function(D, E) {
2428            return n.get(D, null, E, "script")
2429        },
2430        getJSON: function(D, E, F) {
2431            return n.get(D, E, F, "json")
2432        },
2433        post: function(D, F, G, E) {
2434            if (n.isFunction(F)) {
2435                G = F;
2436                F = {}
2437            }
2438            return n.ajax({
2439                type: "POST",
2440                url: D,
2441                data: F,
2442                success: G,
2443                dataType: E
2444            })
2445        },
2446        ajaxSetup: function(D) {
2447            n.extend(n.ajaxSettings, D)
2448        },
2449        ajaxSettings: {
2450            url: location.href,
2451            global: true,
2452            type: "GET",
2453            contentType: "application/x-www-form-urlencoded",
2454            processData: true,
2455            async: true,
2456            xhr: function() {
2457                return l.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest()
2458            },
2459            accepts: {
2460                xml: "application/xml, text/xml",
2461                html: "text/html",
2462                script: "text/javascript, application/javascript",
2463                json: "application/json, text/javascript",
2464                text: "text/plain",
2465                _default: "*/*"
2466            }
2467        },
2468        lastModified: {},
2469        ajax: function(L) {
2470            L = n.extend(true, L, n.extend(true, {}, n.ajaxSettings, L));
2471            var V, E = /=\?(&|$)/g,
2472                Q, U, F = L.type.toUpperCase();
2473            if (L.data && L.processData && typeof L.data !== "string") {
2474                L.data = n.param(L.data)
2475            }
2476            if (L.dataType == "jsonp") {
2477                if (F == "GET") {
2478                    if (!L.url.match(E)) {
2479                        L.url += (L.url.match(/\?/) ? "&" : "?") + (L.jsonp || "callback") + "=?"
2480                    }
2481                } else {
2482                    if (!L.data || !L.data.match(E)) {
2483                        L.data = (L.data ? L.data + "&" : "") + (L.jsonp || "callback") + "=?"
2484                    }
2485                }
2486                L.dataType = "json"
2487            }
2488            if (L.dataType == "json" && (L.data && L.data.match(E) || L.url.match(E))) {
2489                V = "jsonp" + q++;
2490                if (L.data) {
2491                    L.data = (L.data + "").replace(E, "=" + V + "$1")
2492                }
2493                L.url = L.url.replace(E, "=" + V + "$1");
2494                L.dataType = "script";
2495                l[V] = function(W) {
2496                    U = W;
2497                    H();
2498                    K();
2499                    l[V] = g;
2500                    try {
2501                        delete l[V]
2502                    } catch (X) {}
2503                    if (G) {
2504                        G.removeChild(S)
2505                    }
2506                }
2507            }
2508            if (L.dataType == "script" && L.cache == null) {
2509                L.cache = false
2510            }
2511            if (L.cache === false && F == "GET") {
2512                var D = e();
2513                var T = L.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + D + "$2");
2514                L.url = T + ((T == L.url) ? (L.url.match(/\?/) ? "&" : "?") + "_=" + D : "")
2515            }
2516            if (L.data && F == "GET") {
2517                L.url += (L.url.match(/\?/) ? "&" : "?") + L.data;
2518                L.data = null
2519            }
2520            if (L.global && !n.active++) {
2521                n.event.trigger("ajaxStart")
2522            }
2523            var P = /^(\w+:)?\/\/([^\/?#]+)/.exec(L.url);
2524            if (L.dataType == "script" && F == "GET" && P && (P[1] && P[1] != location.protocol || P[2] != location.host)) {
2525                var G = document.getElementsByTagName("head")[0];
2526                var S = document.createElement("script");
2527                S.src = L.url;
2528                if (L.scriptCharset) {
2529                    S.charset = L.scriptCharset
2530                }
2531                if (!V) {
2532                    var N = false;
2533                    S.onload = S.onreadystatechange = function() {
2534                        if (!N && (!this.readyState || this.readyState == "loaded" || this.readyState == "complete")) {
2535                            N = true;
2536                            H();
2537                            K();
2538                            G.removeChild(S)
2539                        }
2540                    }
2541                }
2542                G.appendChild(S);
2543                return g
2544            }
2545            var J = false;
2546            var I = L.xhr();
2547            if (L.username) {
2548                I.open(F, L.url, L.async, L.username, L.password)
2549            } else {
2550                I.open(F, L.url, L.async)
2551            }
2552            try {
2553                if (L.data) {
2554                    I.setRequestHeader("Content-Type", L.contentType)
2555                }
2556                if (L.ifModified) {
2557                    I.setRequestHeader("If-Modified-Since", n.lastModified[L.url] || "Thu, 01 Jan 1970 00:00:00 GMT")
2558                }
2559                I.setRequestHeader("X-Requested-With", "XMLHttpRequest");
2560                I.setRequestHeader("Accept", L.dataType && L.accepts[L.dataType] ? L.accepts[L.dataType] + ", */*" : L.accepts._default)
2561            } catch (R) {}
2562            if (L.beforeSend && L.beforeSend(I, L) === false) {
2563                if (L.global && !--n.active) {
2564                    n.event.trigger("ajaxStop")
2565                }
2566                I.abort();
2567                return false
2568            }
2569            if (L.global) {
2570                n.event.trigger("ajaxSend", [I, L])
2571            }
2572            var M = function(W) {
2573                if (I.readyState == 0) {
2574                    if (O) {
2575                        clearInterval(O);
2576                        O = null;
2577                        if (L.global && !--n.active) {
2578                            n.event.trigger("ajaxStop")
2579                        }
2580                    }
2581                } else {
2582                    if (!J && I && (I.readyState == 4 || W == "timeout")) {
2583                        J = true;
2584                        if (O) {
2585                            clearInterval(O);
2586                            O = null
2587                        }
2588                        Q = W == "timeout" ? "timeout" : !n.httpSuccess(I) ? "error" : L.ifModified && n.httpNotModified(I, L.url) ? "notmodified" : "success";
2589                        if (Q == "success") {
2590                            try {
2591                                U = n.httpData(I, L.dataType, L)
2592                            } catch (Y) {
2593                                Q = "parsererror"
2594                            }
2595                        }
2596                        if (Q == "success") {
2597                            var X;
2598                            try {
2599                                X = I.getResponseHeader("Last-Modified")
2600                            } catch (Y) {}
2601                            if (L.ifModified && X) {
2602                                n.lastModified[L.url] = X
2603                            }
2604                            if (!V) {
2605                                H()
2606                            }
2607                        } else {
2608                            n.handleError(L, I, Q)
2609                        }
2610                        K();
2611                        if (L.async) {
2612                            I = null
2613                        }
2614                    }
2615                }
2616            };
2617            if (L.async) {
2618                var O = setInterval(M, 13);
2619                if (L.timeout > 0) {
2620                    setTimeout(function() {
2621                        if (I) {
2622                            if (!J) {
2623                                M("timeout")
2624                            }
2625                            if (I) {
2626                                I.abort()
2627                            }
2628                        }
2629                    }, L.timeout)
2630                }
2631            }
2632            try {
2633                I.send(L.data)
2634            } catch (R) {
2635                n.handleError(L, I, null, R)
2636            }
2637            if (!L.async) {
2638                M()
2639            }
2640
2641            function H() {
2642                if (L.success) {
2643                    L.success(U, Q)
2644                }
2645                if (L.global) {
2646                    n.event.trigger("ajaxSuccess", [I, L])
2647                }
2648            }
2649
2650            function K() {
2651                if (L.complete) {
2652                    L.complete(I, Q)
2653                }
2654                if (L.global) {
2655                    n.event.trigger("ajaxComplete", [I, L])
2656                }
2657                if (L.global && !--n.active) {
2658                    n.event.trigger("ajaxStop")
2659                }
2660            }
2661            return I
2662        },
2663        handleError: function(E, G, D, F) {
2664            if (E.error) {
2665                E.error(G, D, F)
2666            }
2667            if (E.global) {
2668                n.event.trigger("ajaxError", [G, E, F])
2669            }
2670        },
2671        active: 0,
2672        httpSuccess: function(E) {
2673            try {
2674                return !E.status && location.protocol == "file:" || (E.status >= 200 && E.status < 300) || E.status == 304 || E.status == 1223
2675            } catch (D) {}
2676            return false
2677        },
2678        httpNotModified: function(F, D) {
2679            try {
2680                var G = F.getResponseHeader("Last-Modified");
2681                return F.status == 304 || G == n.lastModified[D]
2682            } catch (E) {}
2683            return false
2684        },
2685        httpData: function(I, G, F) {
2686            var E = I.getResponseHeader("content-type"),
2687                D = G == "xml" || !G && E && E.indexOf("xml") >= 0,
2688                H = D ? I.responseXML : I.responseText;
2689            if (D && H.documentElement.tagName == "parsererror") {
2690                throw "parsererror"
2691            }
2692            if (F && F.dataFilter) {
2693                H = F.dataFilter(H, G)
2694            }
2695            if (typeof H === "string") {
2696                if (G == "script") {
2697                    n.globalEval(H)
2698                }
2699                if (G == "json") {
2700                    H = l["eval"]("(" + H + ")")
2701                }
2702            }
2703            return H
2704        },
2705        param: function(D) {
2706            var F = [];
2707
2708            function G(H, I) {
2709                F[F.length] = encodeURIComponent(H) + "=" + encodeURIComponent(I)
2710            }
2711            if (n.isArray(D) || D.jquery) {
2712                n.each(D, function() {
2713                    G(this.name, this.value)
2714                })
2715            } else {
2716                for (var E in D) {
2717                    if (n.isArray(D[E])) {
2718                        n.each(D[E], function() {
2719                            G(E, this)
2720                        })
2721                    } else {
2722                        G(E, n.isFunction(D[E]) ? D[E]() : D[E])
2723                    }
2724                }
2725            }
2726            return F.join("&").replace(/%20/g, "+")
2727        }
2728    });
2729    var m = {},
2730        d = [
2731            ["height", "marginTop", "marginBottom", "paddingTop", "paddingBottom"],
2732            ["width", "marginLeft", "marginRight", "paddingLeft", "paddingRight"],
2733            ["opacity"]
2734        ];
2735
2736    function s(E, D) {
2737        var F = {};
2738        n.each(d.concat.apply([], d.slice(0, D)), function() {
2739            F[this] = E
2740        });
2741        return F
2742    }
2743    n.fn.extend({
2744        show: function(I, K) {
2745            if (I) {
2746                return this.animate(s("show", 3), I, K)
2747            } else {
2748                for (var G = 0, E = this.length; G < E; G++) {
2749                    var D = n.data(this[G], "olddisplay");
2750                    this[G].style.display = D || "";
2751                    if (n.css(this[G], "display") === "none") {
2752                        var F = this[G].tagName,
2753                            J;
2754                        if (m[F]) {
2755                            J = m[F]
2756                        } else {
2757                            var H = n("<" + F + " />").appendTo("body");
2758                            J = H.css("display");
2759                            if (J === "none") {
2760                                J = "block"
2761                            }
2762                            H.remove();
2763                            m[F] = J
2764                        }
2765                        this[G].style.display = n.data(this[G], "olddisplay", J)
2766                    }
2767                }
2768                return this
2769            }
2770        },
2771        hide: function(G, H) {
2772            if (G) {
2773                return this.animate(s("hide", 3), G, H)
2774            } else {
2775                for (var F = 0, E = this.length; F < E; F++) {
2776                    var D = n.data(this[F], "olddisplay");
2777                    if (!D && D !== "none") {
2778                        n.data(this[F], "olddisplay", n.css(this[F], "display"))
2779                    }
2780                    this[F].style.display = "none"
2781                }
2782                return this
2783            }
2784        },
2785        _toggle: n.fn.toggle,
2786        toggle: function(F, E) {
2787            var D = typeof F === "boolean";
2788            return n.isFunction(F) && n.isFunction(E) ? this._toggle.apply(this, arguments) : F == null || D ? this.each(function() {
2789                var G = D ? F : n(this).is(":hidden");
2790                n(this)[G ? "show" : "hide"]()
2791            }) : this.animate(s("toggle", 3), F, E)
2792        },
2793        fadeTo: function(D, F, E) {
2794            return this.animate({
2795                opacity: F
2796            }, D, E)
2797        },
2798        animate: function(H, E, G, F) {
2799            var D = n.speed(E, G, F);
2800            return this[D.queue === false ? "each" : "queue"](function() {
2801                var J = n.extend({}, D),
2802                    L, K = this.nodeType == 1 && n(this).is(":hidden"),
2803                    I = this;
2804                for (L in H) {
2805                    if (H[L] == "hide" && K || H[L] == "show" && !K) {
2806                        return J.complete.call(this)
2807                    }
2808                    if ((L == "height" || L == "width") && this.style) {
2809                        J.display = n.css(this, "display");
2810                        J.overflow = this.style.overflow
2811                    }
2812                }
2813                if (J.overflow != null) {
2814                    this.style.overflow = "hidden"
2815                }
2816                J.curAnim = n.extend({}, H);
2817                n.each(H, function(N, R) {
2818                    var Q = new n.fx(I, J, N);
2819                    if (/toggle|show|hide/.test(R)) {
2820                        Q[R == "toggle" ? K ? "show" : "hide" : R
2820](H)
2821                    } else {
2822                        var P = R.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
2823                            S = Q.cur(true) || 0;
2824                        if (P) {
2825                            var M = parseFloat(P[2]),
2826                                O = P[3] || "px";
2827                            if (O != "px") {
2828                                I.style[N] = (M || 1) + O;
2829                                S = ((M || 1) / Q.cur(true)) * S;
2830                                I.style[N] = S + O
2831                            }
2832                            if (P[1]) {
2833                                M = ((P[1] == "-=" ? -1 : 1) * M) + S
2834                            }
2835                            Q.custom(S, M, O)
2836                        } else {
2837                            Q.custom(S, R, "")
2838                        }
2839                    }
2840                });
2841                return true
2842            })
2843        },
2844        stop: function(E, D) {
2845            var F = n.timers;
2846            if (E) {
2847                this.queue([])
2848            }
2849            this.each(function() {
2850                for (var G = F.length - 1; G >= 0; G--) {
2851                    if (F[G].elem == this) {
2852                        if (D) {
2853                            F[G](true)
2854                        }
2855                        F.splice(G, 1)
2856                    }
2857                }
2858            });
2859            if (!D) {
2860                this.dequeue()
2861            }
2862            return this
2863        }
2864    });
2865    n.each({
2866        slideDown: s("show", 1),
2867        slideUp: s("hide", 1),
2868        slideToggle: s("toggle", 1),
2869        fadeIn: {
2870            opacity: "show"
2871        },
2872        fadeOut: {
2873            opacity: "hide"
2874        }
2875    }, function(D, E) {
2876        n.fn[D] = function(F, G) {
2877            return this.animate(E, F, G)
2878        }
2879    });
2880    n.extend({
2881        speed: function(F, G, E) {
2882            var D = typeof F === "object" ? F : {
2883                complete: E || !E && G || n.isFunction(F) && F,
2884                duration: F,
2885                easing: E && G || G && !n.isFunction(G) && G
2886            };
2887            D.duration = n.fx.off ? 0 : typeof D.duration === "number" ? D.duration : n.fx.speeds[D.duration] || n.fx.speeds._default;
2888            D.old = D.complete;
2889            D.complete = function() {
2890                if (D.queue !== false) {
2891                    n(this).dequeue()
2892                }
2893                if (n.isFunction(D.old)) {
2894                    D.old.call(this)
2895                }
2896            };
2897            return D
2898        },
2899        easing: {
2900            linear: function(F, G, D, E) {
2901                return D + E * F
2902            },
2903            swing: function(F, G, D, E) {
2904                return ((-Math.cos(F * Math.PI) / 2) + 0.5) * E + D
2905            }
2906        },
2907        timers: [],
2908        timerId: null,
2909        fx: function(E, D, F) {
2910            this.options = D;
2911            this.elem = E;
2912            this.prop = F;
2913            if (!D.orig) {
2914                D.orig = {}
2915            }
2916        }
2917    });
2918    n.fx.prototype = {
2919        update: function() {
2920            if (this.options.step) {
2921                this.options.step.call(this.elem, this.now, this)
2922            }(n.fx.step[this.prop] || n.fx.step._default)(this);
2923            if ((this.prop == "height" || this.prop == "width") && this.elem.style) {
2924                this.elem.style.display = "block"
2925            }
2926        },
2927        cur: function(E) {
2928            if (this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null)) {
2929                return this.elem[this.prop]
2930            }
2931            var D = parseFloat(n.css(this.elem, this.prop, E));
2932            return D && D > -10000 ? D : parseFloat(n.curCSS(this.elem, this.prop)) || 0
2933        },
2934        custom: function(H, G, F) {
2935            this.startTime = e();
2936            this.start = H;
2937            this.end = G;
2938            this.unit = F || this.unit || "px";
2939            this.now = this.start;
2940            this.pos = this.state = 0;
2941            var D = this;
2942
2943            function E(I) {
2944                return D.step(I)
2945            }
2946            E.elem = this.elem;
2947            n.timers.push(E);
2948            if (E() && n.timerId == null) {
2949                n.timerId = setInterval(function() {
2950                    var J = n.timers;
2951                    for (var I = 0; I < J.length; I++) {
2952                        if (!J[I]()) {
2953                            J.splice(I--, 1)
2954                        }
2955                    }
2956                    if (!J.length) {
2957                        clearInterval(n.timerId);
2958                        n.timerId = null
2959                    }
2960                }, 13)
2961            }
2962        },
2963        show: function() {
2964            this.options.orig[this.prop] = n.attr(this.elem.style, this.prop);
2965            this.options.show = true;
2966            this.custom(this.prop == "width" || this.prop == "height" ? 1 : 0, this.cur());
2967            n(this.elem).show()
2968        },
2969        hide: function() {
2970            this.options.orig[this.prop] = n.attr(this.elem.style, this.prop);
2971            this.options.hide = true;
2972            this.custom(this.cur(), 0)
2973        },
2974        step: function(G) {
2975            var F = e();
2976            if (G || F >= this.options.duration + this.startTime) {
2977                this.now = this.end;
2978                this.pos = this.state = 1;
2979                this.update();
2980                this.options.curAnim[this.prop] = true;
2981                var D = true;
2982                for (var E in this.options.curAnim) {
2983                    if (this.options.curAnim[E] !== true) {
2984                        D = false
2985                    }
2986                }
2987                if (D) {
2988                    if (this.options.display != null) {
2989                        this.elem.style.overflow = this.options.overflow;
2990                        this.elem.style.display = this.options.display;
2991                        if (n.css(this.elem, "display") == "none") {
2992                            this.elem.style.display = "block"
2993                        }
2994                    }
2995                    if (this.options.hide) {
2996                        n(this.elem).hide()
2997                    }
2998                    if (this.options.hide || this.options.show) {
2999                        for (var H in this.options.curAnim) {
3000                            n.attr(this.elem.style, H, this.options.orig[H])
3001                        }
3002                    }
3003                }
3004                if (D) {
3005                    this.options.complete.call(this.elem)
3006                }
3007                return false
3008            } else {
3009                var I = F - this.startTime;
3010                this.state = I / this.options.duration;
3011                this.pos = n.easing[this.options.easing || (n.easing.swing ? "swing" : "linear")](this.state, I, 0, 1, this.options.duration);
3012                this.now = this.start + ((this.end - this.start) * this.pos);
3013                this.update()
3014            }
3015            return true
3016        }
3017    };
3018    n.extend(n.fx, {
3019        speeds: {
3020            slow: 600,
3021            fast: 200,
3022            _default: 400
3023        },
3024        step: {
3025            opacity: function(D) {
3026                n.attr(D.elem.style, "opacity", D.now)
3027            },
3028            _default: function(D) {
3029                if (D.elem.style && D.elem.style[D.prop] != null) {
3030                    D.elem.style[D.prop] = D.now + D.unit
3031                } else {
3032                    D.elem[D.prop] = D.now
3033                }
3034            }
3035        }
3036    });
3037    if (document.documentElement.getBoundingClientRect) {
3038        n.fn.offset = function() {
3039            if (!this[0]) {
3040                return {
3041                    top: 0,
3042                    left: 0
3043                }
3044            }
3045            if (this[0] === this[0].ownerDocument.body) {
3046                return n.offset.bodyOffset(this[0])
3047            }
3048            var F = this[0].getBoundingClientRect(),
3049                I = this[0].ownerDocument,
3050                E = I.body,
3051                D = I.documentElement,
3052                K = D.clientTop || E.clientTop || 0,
3053                J = D.clientLeft || E.clientLeft || 0,
3054                H = F.top + (self.pageYOffset || n.boxModel && D.scrollTop || E.scrollTop) - K,
3055                G = F.left + (self.pageXOffset || n.boxModel && D.scrollLeft || E.scrollLeft) - J;
3056            return {
3057                top: H,
3058                left: G
3059            }
3060        }
3061    } else {
3062        n.fn.offset = function() {
3063            if (!this[0]) {
3064                return {
3065                    top: 0,
3066                    left: 0
3067                }
3068            }
3069            if (this[0] === this[0].ownerDocument.body) {
3070                return n.offset.bodyOffset(this[0])
3071            }
3072            n.offset.initialized || n.offset.initialize();
3073            var I = this[0],
3074                F = I.offsetParent,
3075                E = I,
3076                N = I.ownerDocument,
3077                L, G = N.documentElement,
3078                J = N.body,
3079                K = N.defaultView,
3080                D = K.getComputedStyle(I, null),
3081                M = I.offsetTop,
3082                H = I.offsetLeft;
3083            while ((I = I.parentNode) && I !== J && I !== G) {
3084                L = K.getComputedStyle(I, null);
3085                M -= I.scrollTop, H -= I.scrollLeft;
3086                if (I === F) {
3087                    M += I.offsetTop, H += I.offsetLeft;
3088                    if (n.offset.doesNotAddBorder && !(n.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(I.tagName))) {
3089                        M += parseInt(L.borderTopWidth, 10) || 0, H += parseInt(L.borderLeftWidth, 10) || 0
3090                    }
3091                    E = F, F = I.offsetParent
3092                }
3093                if (n.offset.subtractsBorderForOverflowNotVisible && L.overflow !== "visible") {
3094                    M += parseInt(L.borderTopWidth, 10) || 0, H += parseInt(L.borderLeftWidth, 10) || 0
3095                }
3096                D = L
3097            }
3098            if (D.position === "relative" || D.position === "static") {
3099                M += J.offsetTop, H += J.offsetLeft
3100            }
3101            if (D.position === "fixed") {
3102                M += Math.max(G.scrollTop, J.scrollTop), H += Math.max(G.scrollLeft, J.scrollLeft)
3103            }
3104            return {
3105                top: M,
3106                left: H
3107            }
3108        }
3109    }
3110    n.offset = {
3111        initialize: function() {
3112            if (this.initialized) {
3113                return
3114            }
3115            var K = document.body,
3116                E = document.createElement("div"),
3117                G, F, M, H, L, D, I = K.style.marginTop,
3118                J = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"cellpadding="0"cellspacing="0"><tr><td></td></tr></table>';
3119            L = {
3120                position: "absolute",
3121                top: 0,
3122                left: 0,
3123                margin: 0,
3124                border: 0,
3125                width: "1px",
3126                height: "1px",
3127                visibility: "hidden"
3128            };
3129            for (D in L) {
3130                E.style[D] = L[D]
3131            }
3132            E.innerHTML = J;
3133            K.insertBefore(E, K.firstChild);
3134            G = E.firstChild, F = G.firstChild, H = G.nextSibling.firstChild.firstChild;
3135            this.doesNotAddBorder = (F.offsetTop !== 5);
3136            this.doesAddBorderForTableAndCells = (H.offsetTop === 5);
3137            G.style.overflow = "hidden", G.style.position = "relative";
3138            this.subtractsBorderForOverflowNotVisible = (F.offsetTop === -5);
3139            K.style.marginTop = "1px";
3140            this.doesNotIncludeMarginInBodyOffset = (K.offsetTop === 0);
3141            K.style.marginTop = I;
3142            K.removeChild(E);
3143            this.initialized = true
3144        },
3145        bodyOffset: function(D) {
3146            n.offset.initialized || n.offset.initialize();
3147            var F = D.offsetTop,
3148                E = D.offsetLeft;
3149            if (n.offset.doesNotIncludeMarginInBodyOffset) {
3150                F += parseInt(n.curCSS(D, "marginTop", true), 10) || 0, E += parseInt(n.curCSS(D, "marginLeft", true), 10) || 0
3151            }
3152            return {
3153                top: F,
3154                left: E
3155            }
3156        }
3157    };
3158    n.fn.extend({
3159        position: function() {
3160            var H = 0,
3161                G = 0,
3162                E;
3163            if (this[0]) {
3164                var F = this.offsetParent(),
3165                    I = this.offset(),
3166                    D = /^body|html$/i.test(F[0].tagName) ? {
3167                        top: 0,
3168                        left: 0
3169                    } : F.offset();
3170                I.top -= j(this, "marginTop");
3171                I.left -= j(this, "marginLeft");
3172                D.top += j(F, "borderTopWidth");
3173                D.left += j(F, "borderLeftWidth");
3174                E = {
3175                    top: I.top - D.top,
3176                    left: I.left - D.left
3177                }
3178            }
3179            return E
3180        },
3181        offsetParent: function() {
3182            var D = this[0].offsetParent || document.body;
3183            while (D && (!/^body|html$/i.test(D.tagName) && n.css(D, "position") == "static")) {
3184                D = D.offsetParent
3185            }
3186            return n(D)
3187        }
3188    });
3189    n.each(["Left", "Top"], function(E, D) {
3190        var F = "scroll" + D;
3191        n.fn[F] = function(G) {
3192            if (!this[0]) {
3193                return null
3194            }
3195            return G !== g ? this.each(function() {
3196                this == l || this == document ? l.scrollTo(!E ? G : n(l).scrollLeft(), E ? G : n(l).scrollTop()) : this[F] = G
3197            }) : this[0] == l || this[0] == document ? self[E ? "pageYOffset" : "pageXOffset"] || n.boxModel && document.documentElement[F] || document.body[F] : this[0][F]
3198        }
3199    });
3200    n.each(["Height", "Width"], function(G, E) {
3201        var D = G ? "Left" : "Top",
3202            F = G ? "Right" : "Bottom";
3203        n.fn["inner" + E] = function() {
3204            return this[E.toLowerCase()]() + j(this, "padding" + D) + j(this, "padding" + F)
3205        };
3206        n.fn["outer" + E] = function(I) {
3207            return this["inner" + E]() + j(this, "border" + D + "Width") + j(this, "border" + F + "Width") + (I ? j(this, "margin" + D) + j(this, "margin" + F) : 0)
3208        };
3209        var H = E.toLowerCase();
3210        n.fn[H] = function(I) {
3211            return this[0] == l ? document.compatMode == "CSS1Compat" && document.documentElement["client" + E] || document.body["client" + E] : this[0] == document ? Math.max(document.documentElement["client" + E], document.body["scroll" + E], document.documentElement["scroll" + E], document.body["offset" + E], document.documentElement["offset" + E]) : I === g ? (this.length ? n.css(this[0], H) : null) : this.css(H, typeof I === "string" ? I : I + "px")
3212        }
3213    })
3214})();

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.