https://whiskyadvocate.com/files/_cache/5616ff85340054b95713ce254312e70c.js

1function parse_str(str, array) {
2  //       discuss at: http://phpjs.org/functions/parse_str/
3  //      original by: Cagri Ekin
4  //      improved by: Michael White (http://getsprink.com)
5  //      improved by: Jack
6  //      improved by: Brett Zamir (http://brett-zamir.me)
7  //      bugfixed by: Onno Marsman
8  //      bugfixed by: Brett Zamir (http://brett-zamir.me)
9  //      bugfixed by: stag019
10  //      bugfixed by: Brett Zamir (http://brett-zamir.me)
11  //      bugfixed by: MIO_KODUKI (http://mio-koduki.blogspot.com/)
12  // reimplemented by: stag019
13  //         input by: Dreamer
14  //         input by: Zaide (http://zaidesthings.com/)
15  //         input by: David Pesta (http://davidpesta.com/)
16  //         input by: jeicquest
17  //             note: When no argument is specified, will put variables in global scope.
18  //             note: When a particular argument has been passed, and the returned value is different parse_str of PHP. For example, a=b=c&d====c
19  //             test: skip
20  //        example 1: var arr = {};
21  //        example 1: parse_str('first=foo&second=bar', arr);
22  //        example 1: $result = arr
23  //        returns 1: { first: 'foo', second: 'bar' }
24  //        example 2: var arr = {};
25  //        example 2: parse_str('str_a=Jack+and+Jill+didn%27t+see+the+well.', arr);
26  //        example 2: $result = arr
27  //        returns 2: { str_a: "Jack and Jill didn't see the well." }
28  //        example 3: var abc = {3:'a'};
29  //        example 3: parse_str('abc[a][b]["c"]=def&abc[q]=t+5');
30  //        returns 3: {"3":"a","a":{"b":{"c":"def"}},"q":"t 5"}
31
32  var strArr = String(str)
33    .replace(/^&/, '')
34    .replace(/&$/, '')
35    .split('&'),
36    sal = strArr.length,
37    i, j, ct, p, lastObj, obj, lastIter, undef, chr, tmp, key, value,
38    postLeftBracketPos, keys, keysLen,
39    fixStr = function(str) {
40      return decodeURIComponent(str.replace(/\+/g, '%20'));
41    };
42
43  if (!array) {
44    array = this.window;
45  }
46
47  for (i = 0; i < sal; i++) {
48    tmp = strArr[i].split('=');
49    key = fixStr(tmp[0]);
50    value = (tmp.length < 2) ? '' : fixStr(tmp[1]);
51
52    while (key.charAt(0) === ' ') {
53      key = key.slice(1);
54    }
55    if (key.indexOf('\x00') > -1) {
56      key = key.slice(0, key.indexOf('\x00'));
57    }
58    if (key && key.charAt(0) !== '[') {
59      keys = [];
60      postLeftBracketPos = 0;
61      for (j = 0; j < key.length; j++) {
62        if (key.charAt(j) === '[' && !postLeftBracketPos) {
63          postLeftBracketPos = j + 1;
64        } else if (key.charAt(j) === ']') {
65          if (postLeftBracketPos) {
66            if (!keys.length) {
67              keys.push(key.slice(0, postLeftBracketPos - 1));
68            }
69            keys.push(key.substr(postLeftBracketPos, j - postLeftBracketPos));
70            postLeftBracketPos = 0;
71            if (key.charAt(j + 1) !== '[') {
72              break;
73            }
74          }
75        }
76      }
77      if (!keys.length) {
78        keys = [key];
79      }
80      for (j = 0; j < keys[0].length; j++) {
81        chr = keys[0].charAt(j);
82        if (chr === ' ' || chr === '.' || chr === '[') {
83          keys[0] = keys[0].substr(0, j) + '_' + keys[0].substr(j + 1);
84        }
85        if (chr === '[') {
86          break;
87        }
88      }
89
90      obj = array;
91      for (j = 0, keysLen = keys.length; j < keysLen; j++) {
92        key = keys[j].replace(/^['"]/, '')
93          .replace(/['"]$/, '');
94        lastIter = j !== keys.length - 1;
95        lastObj = obj;
96        if ((key !== '' && key !== ' ') || j === 0) {
97          if (obj[key] === undef) {
98            obj[key] = {};
99          }
100          obj = obj[key];
101        } else { // To insert new dimension
102          ct = -1;
103          for (p in obj) {
104            if (obj.hasOwnProperty(p)) {
105              if (+p > ct && p.match(/^\d+$/g)) {
106                ct = +p;
107              }
108            }
109          }
110          key = ct + 1;
111        }
112      }
113      lastObj[key] = value;
114    }
115  }
116}
117
118function http_build_query(formdata, numeric_prefix, arg_separator) {
119  //  discuss at: http://phpjs.org/functions/http_build_query/
120  // original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
121  // improved by: Legaev Andrey
122  // improved by: Michael White (http://getsprink.com)
123  // improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
124  // improved by: Brett Zamir (http://brett-zamir.me)
125  //  revised by: stag019
126  //    input by: Dreamer
127  // bugfixed by: Brett Zamir (http://brett-zamir.me)
128  // bugfixed by: MIO_KODUKI (http://mio-koduki.blogspot.com/)
129  //        note: If the value is null, key and value are skipped in the http_build_query of PHP while in phpjs they are not.
130  //  depends on: urlencode
131  //   example 1: http_build_query({foo: 'bar', php: 'hypertext processor', baz: 'boom', cow: 'milk'}, '', '&amp;');
132  //   returns 1: 'foo=bar&amp;php=hypertext+processor&amp;baz=boom&amp;cow=milk'
133  //   example 2: http_build_query({'php': 'hypertext processor', 0: 'foo', 1: 'bar', 2: 'baz', 3: 'boom', 'cow': 'milk'}, 'myvar_');
134  //   returns 2: 'myvar_0=foo&myvar_1=bar&myvar_2=baz&myvar_3=boom&php=hypertext+processor&cow=milk'
135
136  var value, key, tmp = [],
137    that = this;
138
139  var _http_build_query_helper = function(key, val, arg_separator) {
140    var k, tmp = [];
141    if (val === true) {
142      val = '1';
143    } else if (val === false) {
144      val = '0';
145    }
146    if (val != null) {
147      if (typeof val === 'object') {
148        for (k in val) {
149          if (val[k] != null) {
150            tmp.push(_http_build_query_helper(key + '[' + k + ']', val[k], arg_separator));
151          }
152        }
153        return tmp.join(arg_separator);
154      } else if (typeof val !== 'function') {
155        return that.urlencode(key) + '=' + that.urlencode(val);
156      } else {
157        throw new Error('There was an error processing for http_build_query().');
158      }
159    } else {
160      return '';
161    }
162  };
163
164  if (!arg_separator) {
165    arg_separator = '&';
166  }
167  for (key in formdata) {
168    value = formdata[key];
169    if (numeric_prefix && !isNaN(key)) {
170      key = String(numeric_prefix) + key;
171    }
172    var query = _http_build_query_helper(key, value, arg_separator);
173    if (query !== '') {
174      tmp.push(query);
175    }
176  }
177
178  return tmp.join(arg_separator);
179}
180/*
181    http://www.JSON.org/json2.js
182    2008-07-15
183
184    Public Domain.
185
186    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
187
188    See http://www.JSON.org/js.html
189

190    This file creates a global JSON object containing two methods: stringify
191    and parse.
192
193        JSON.stringify(value, replacer, space)
194            value       any JavaScript value, usually an object or array.
195
196            replacer    an optional parameter that determines how object
197                        values are stringified for objects. It can be a
198                        function or an array.
199
200            space       an optional parameter that specifies the indentation
201                        of nested structures. If it is omitted, the text will
202                        be packed without extra whitespace. If it is a number,
203                        it will specify the number of spaces to indent at each
204                        level. If it is a string (such as '\t' or ' '),
205                        it contains the characters used to indent at each level.
206
207            This method produces a JSON text from a JavaScript value.
208
209            When an object value is found, if the object contains a toJSON
210            method, its toJSON method will be called and the result will be
211            stringified. A toJSON method does not serialize: it returns the
212            value represented by the name/value pair that should be serialized,
213            or undefined if nothing should be serialized. The toJSON method
214            will be passed the key associated with the value, and this will be
215            bound to the object holding the key.
216
217            For example, this would serialize Dates as ISO strings.
218
219                Date.prototype.toJSON = function (key) {
220                    function f(n) {
221                        // Format integers to have at least two digits.
222                        return n < 10 ? '0' + n : n;
223                    }
224
225                    return this.getUTCFullYear()   + '-' +
226                         f(this.getUTCMonth() + 1) + '-' +
227                         f(this.getUTCDate())      + 'T' +
228                         f(this.getUTCHours())     + ':' +
229                         f(this.getUTCMinutes())   + ':' +
230                         f(this.getUTCSeconds())   + 'Z';
231                };
232
233            You can provide an optional replacer method. It will be passed the
234            key and value of each member, with this bound to the containing
235            object. The value that is returned from your method will be
236            serialized. If your method returns undefined, then the member will
237            be excluded from the serialization.
238
239            If the replacer parameter is an array, then it will be used to
240            select the members to be serialized. It filters the results such
241            that only members with keys listed in the replacer array are
242            stringified.
243
244            Values that do not have JSON representations, such as undefined or
245            functions, will not be serialized. Such values in objects will be
246            dropped; in arrays they will be replaced with null. You can use
247            a replacer function to replace those with JSON values.
248            JSON.stringify(undefined) returns undefined.
249
250            The optional space parameter produces a stringification of the
251            value that is filled with line breaks and indentation to make it
252            easier to read.
253
254            If the space parameter is a non-empty string, then that string will
255            be used for indentation. If the space parameter is a number, then
256            the indentation will be that many spaces.
257
258            Example:
259
260            text = JSON.stringify(['e', {pluribus: 'unum'}]);
261            // text is '["e",{"pluribus":"unum"}]'
262
263
264            text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
265            // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
266
267            text = JSON.stringify([new Date()], function (key, value) {
268                return this[key] instanceof Date ?
269                    'Date(' + this[key] + ')' : value;
270            });
271            // text is '["Date(---current time---)"]'
272
273
274        JSON.parse(text, reviver)
275            This method parses a JSON text to produce an object or array.
276            It can throw a SyntaxError exception.
277
278            The optional reviver parameter is a function that can filter and
279            transform the results. It receives each of the keys and values,
280            and its return value is used instead of the original value.
281            If it returns what it received, then the structure is not modified.
282            If it returns undefined then the member is deleted.
283
284            Example:
285
286            // Parse the text. Values that look like ISO date strings will
287            // be converted to Date objects.
288
289            myData = JSON.parse(text, function (key, value) {
290                var a;
291                if (typeof value === 'string') {
292                    a =
293/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
294                    if (a) {
295                        return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
296                            +a[5], +a[6]));
297                    }
298                }
299                return value;
300            });
301
302            myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
303                var d;
304                if (typeof value === 'string' &&
305                        value.slice(0, 5) === 'Date(' &&
306                        value.slice(-1) === ')') {
307                    d = new Date(value.slice(5, -1));
308                    if (d) {
309                        return d;
310                    }
311                }
312                return value;
313            });
314
315
316    This is a reference implementation. You are free to copy, modify, or
317    redistribute.
318
319    This code should be minified before deployment.
320    See http://javascript.crockford.com/jsmin.html
321
322    USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
323    NOT CONTROL.
324*/
325
326/*jslint evil: true */
327
328/*global JSON */
329
330/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", call,

331    charCodeAt, getUTCDate, getUTCFullYear, getUTCHours, getUTCMinutes,
332    getUTCMonth, getUTCSeconds, hasOwnProperty, join, lastIndex, length,
333    parse, propertyIsEnumerable, prototype, push, replace, slice, stringify,
334    test, toJSON, toString
335*/
336
337if (!this.JSON) {
338
339// Create a JSON object only if one does not already exist. We create the
340// object in a closure to avoid creating global variables.
341
342    JSON = function () {
343
344        function f(n) {
345            // Format integers to have at least two digits.
346            return n < 10 ? '0' + n : n;
347        }
348
349        Date.prototype.toJSON = function (key) {
350
351            return this.getUTCFullYear()   + '-' +
352                 f(this.getUTCMonth() + 1) + '-' +
353                 f(this.getUTCDate())      + 'T' +
354                 f(this.getUTCHours())     + ':' +
355                 f(this.getUTCMinutes())   + ':' +
356                 f(this.getUTCSeconds())   + 'Z';
357        };
358
359        String.prototype.toJSON =
360        Number.prototype.toJSON =
361        Boolean.prototype.toJSON = function (key) {
362            return this.valueOf();
363        };
364
365        var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
366            escapeable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
367            gap,
368            indent,
369            meta = {    // table of character substitutions
370                '\b': '\\b',
371                '\t': '\\t',
372                '\n': '\\n',
373                '\f': '\\f',
374                '\r': '\\r',
375                '"' : '\\"',
376                '\\': '\\\\'
377            },
378            rep;
379
380
381        function quote(string) {
382
383// If the string contains no control characters, no quote characters, and no
384// backslash characters, then we can safely slap some quotes around it.
385// Otherwise we must also replace the offending characters with safe escape
386// sequences.
387
388            escapeable.lastIndex = 0;
389            return escapeable.test(string) ?
390                '"' + string.replace(escapeable, function (a) {
391                    var c = meta[a];
392                    if (typeof c === 'string') {
393                        return c;
394                    }
395                    return '\\u' + ('0000' +
396                            (+(a.charCodeAt(0))).toString(16)).slice(-4);
397                }) + '"' :
398                '"' + string + '"';
399        }
400
401
402        function str(key, holder) {
403
404// Produce a string from holder[key].
405
406            var i,          // The loop counter.
407                k,          // The member key.
408                v,          // The member value.
409                length,
410                mind = gap,
411                partial,
412                value = holder[key];
413
414// If the value has a toJSON method, call it to obtain a replacement value.
415
416            if (value && typeof value === 'object' &&
417                    typeof value.toJSON === 'function') {
418                value = value.toJSON(key);
419            }
420
421// If we were called with a replacer function, then call the replacer to
422// obtain a replacement value.
423
424            if (typeof rep === 'function') {
425                value = rep.call(holder, key, value);
426            }
427
428// What happens next depends on the value's type.
429
430            switch (typeof value) {
431            case 'string':
432                return quote(value);
433
434            case 'number':
435
436// JSON numbers must be finite. Encode non-finite numbers as null.
437
438                return isFinite(value) ? String(value) : 'null';
439
440            case 'boolean':
441            case 'null':
442
443// If the value is a boolean or null, convert it to a string. Note:
444// typeof null does not produce 'null'. The case is included here in
445// the remote chance that this gets fixed someday.
446
447                return String(value);
448
449// If the type is 'object', we might be dealing with an object or an array or
450// null.
451
452            case 'object':
453
454// Due to a specification blunder in ECMAScript, typeof null is 'object',
455// so watch out for that case.
456
457                if (!value) {
458                    return 'null';

459                }
460
461// Make an array to hold the partial results of stringifying this object value.
462
463                gap += indent;
464                partial = [];
465
466// If the object has a dontEnum length property, we'll treat it as an array.
467
468                if (typeof value.length === 'number' &&
469                        !(value.propertyIsEnumerable('length'))) {
470
471// The object is an array. Stringify every element. Use null as a placeholder
472// for non-JSON values.
473
474                    length = value.length;
475                    for (i = 0; i < length; i += 1) {
476                        partial[i] = str(i, value) || 'null';
477                    }
478
479// Join all of the elements together, separated with commas, and wrap them in
480// brackets.
481
482                    v = partial.length === 0 ? '[]' :
483                        gap ? '[\n' + gap +
484                                partial.join(',\n' + gap) + '\n' +
485                                    mind + ']' :
486                              '[' + partial.join(',') + ']';
487                    gap = mind;
488                    return v;
489                }
490
491// If the replacer is an array, use it to select the members to be stringified.
492
493                if (rep && typeof rep === 'object') {
494                    length = rep.length;
495                    for (i = 0; i < length; i += 1) {
496                        k = rep[i];
497                        if (typeof k === 'string') {
498                            v = str(k, value);
499                            if (v) {
500                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
501                            }
502                        }
503                    }
504                } else {
505
506// Otherwise, iterate through all of the keys in the object.
507
508                    for (k in value) {
509                        if (Object.hasOwnProperty.call(value, k)) {
510                            v = str(k, value);
511                            if (v) {
512                                partial.push(quote(k) + (gap ? ': ' : ':') + v);
513                            }
514                        }
515                    }
516                }
517
518// Join all of the member texts together, separated with commas,
519// and wrap them in braces.
520
521                v = partial.length === 0 ? '{}' :
522                    gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
523                            mind + '}' : '{' + partial.join(',') + '}';
524                gap = mind;
525                return v;
526            }
527        }
528
529// Return the JSON object containing the stringify and parse methods.
530
531        return {
532            stringify: function (value, replacer, space) {
533
534// The stringify method takes a value and an optional replacer, and an optional
535// space parameter, and returns a JSON text. The replacer can be a function
536// that can replace values, or an array of strings that will select the keys.
537// A default replacer method can be provided. Use of the space parameter can
538// produce text that is more easily readable.
539
540                var i;
541                gap = '';
542                indent = '';
543
544// If the space parameter is a number, make an indent string containing that
545// many spaces.
546
547                if (typeof space === 'number') {
548                    for (i = 0; i < space; i += 1) {
549                        indent += ' ';
550                    }
551
552// If the space parameter is a string, it will be used as the indent string.
553
554                } else if (typeof space === 'string') {
555                    indent = space;
556                }
557
558// If there is a replacer, it must be a function or an array.
559// Otherwise, throw an error.
560
561                rep = replacer;
562                if (replacer && typeof replacer !== 'function' &&
563                        (typeof replacer !== 'object' ||
564                         typeof replacer.length !== 'number')) {
565                    throw new Error('JSON.stringify');
566                }
567
568// Make a fake root object containing our value under the key of ''.
569// Return the result of stringifying the value.
570
571                return str('', {'': value});
572            },
573
574
575            parse: function (text, reviver) {
576
577// The parse method takes a text and an optional reviver function, and returns
578// a JavaScript value if the text is a valid JSON text.
579
580                var j;
581
582                function walk(holder, key) {
583
584// The walk method is used to recursively walk the resulting structure so
585// that modifications can be made.
586
587                    var k, v, value = holder[key];
588                    if (value && typeof value === 'object') {
589                        for (k in value) {
590                            if (Object.hasOwnProperty.call(value, k)) {
591                                v = walk(value, k);
592                                if (v !== undefined) {
593                                    value[k] = v;
594                                } else {
595                                    delete value[k];
596                                }
597                            }
598                        }
599                    }
600                    return reviver.call(holder, key, value);
601                }
602
603
604// Parsing happens in four stages. In the first stage, we replace certain
605// Unicode characters with escape sequences. JavaScript handles many characters
606// incorrectly, either silently deleting them, or treating them as line endings.
607
608                cx.lastIndex = 0;
609                if (cx.test(text)) {
610                    text = text.replace(cx, function (a) {

611                        return '\\u' + ('0000' +
612                                (+(a.charCodeAt(0))).toString(16)).slice(-4);
613                    });
614                }
615
616// In the second stage, we run the text against regular expressions that look
617// for non-JSON patterns. We are especially concerned with '()' and 'new'
618// because they can cause invocation, and '=' because it can cause mutation.
619// But just to be safe, we want to reject all unexpected forms.
620
621// We split the second stage into 4 regexp operations in order to work around
622// crippling inefficiencies in IE's and Safari's regexp engines. First we
623// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
624// replace all simple value tokens with ']' characters. Third, we delete all
625// open brackets that follow a colon or comma or that begin the text. Finally,
626// we look to see that the remaining characters are only whitespace or ']' or
627// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
628
629                if (/^[\],:{}\s]*$/.
630test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
631replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
632replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
633
634// In the third stage we use the eval function to compile the text into a
635// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
636// in JavaScript: it can begin a block or an object literal. We wrap the text
637// in parens to eliminate the ambiguity.
638
639                    j = eval('(' + text + ')');
640
641// In the optional fourth stage, we recursively walk the new structure, passing
642// each name/value pair to a reviver function for possible transformation.
643
644                    return typeof reviver === 'function' ?
645                        walk({'': j}, '') : j;
646                }
647
648// If the text is not JSON parseable, then a SyntaxError is thrown.
649
650                throw new SyntaxError('JSON.parse');
651            }
652        };
653    }();
654}
655
656/*!
657 * jQuery JavaScript Library v1.7.1
658 * http://jquery.com/
659 *
660 * Copyright 2011, John Resig
661 * Dual licensed under the MIT or GPL Version 2 licenses.
662 * http://jquery.org/license
663 *
664 * Includes Sizzle.js
665 * http://sizzlejs.com/
666 * Copyright 2011, The Dojo Foundation
667 * Released under the MIT, BSD, and GPL Licenses.
668 *
669 * Date: Mon Nov 21 21:11:03 2011 -0500
670 */
671(function( window, undefined ) {
672
673// Use the correct document accordingly with window argument (sandbox)
674var document = window.document,
675	navigator = window.navigator,
676	location = window.location;
677var jQuery = (function() {
678
679// Define a local copy of jQuery
680var jQuery = function( selector, context ) {
681		// The jQuery object is actually just the init constructor 'enhanced'
682		return new jQuery.fn.init( selector, context, rootjQuery );
683	},
684
685	// Map over jQuery in case of overwrite
686	_jQuery = window.jQuery,
687
688	// Map over the $ in case of overwrite
689	_$ = window.$,
690
691	// A central reference to the root jQuery(document)
692	rootjQuery,
693
694	// A simple way to check for HTML strings or ID strings
695	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
696	quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
697
698	// Check if a string has a non-whitespace character in it
699	rnotwhite = /\S/,
700
701	// Used for trimming whitespace
702	trimLeft = /^\s+/,
703	trimRight = /\s+$/,
704
705	// Match a standalone tag
706	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
707
708	// JSON RegExp
709	rvalidchars = /^[\],:{}\s]*$/,
710	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
711	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
712	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
713
714	// Useragent RegExp
715	rwebkit = /(webkit)[ \/]([\w.]+)/,
716	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
717	rmsie = /(msie) ([\w.]+)/,
718	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
719
720	// Matches dashed string for camelizing
721	rdashAlpha = /-([a-z]|[0-9])/ig,
722	rmsPrefix = /^-ms-/,
723
724	// Used by jQuery.camelCase as callback to replace()
725	fcamelCase = function( all, letter ) {
726		return ( letter + "" ).toUpperCase();
727	},
728
729	// Keep a UserAgent string for use with jQuery.browser
730	userAgent = navigator.userAgent,
731
732	// For matching the engine and version of the browser
733	browserMatch,
734
735	// The deferred used on DOM ready
736	readyList,
737
738	// The ready event handler
739	DOMContentLoaded,
740
741	// Save a reference to some core methods
742	toString = Object.prototype.toString,
743	hasOwn = Object.prototype.hasOwnProperty,
744	push = Array.prototype.push,
745	slice = Array.prototype.slice,
746	trim = String.prototype.trim,
747	indexOf = Array.prototype.indexOf,
748
749	// [[Class]] -> type pairs
750	class2type = {};
751
752jQuery.fn = jQuery.prototype = {
753	constructor: jQuery,
754	init: function( selector, context, rootjQuery ) {
755		var match, elem, ret, doc;
756
757		// Handle $(""), $(null), or $(undefined)
758		if ( !selector ) {
759			return this;
760		}
761
762		// Handle $(DOMElement)
763		if ( selector.nodeType ) {
764			this.context = this[0] = selector;
765			this.length = 1;
766			return this;
767		}
768
769		// The body element only exists once, optimize finding it
770		if ( selector === "body" && !context && document.body ) {
771			this.context = document;
772			this[0] = document.body;
773			this.selector = selector;
774			this.length = 1;
775			return this;
776		}
777
778		// Handle HTML strings
779		if ( typeof selector === "string" ) {
780			// Are we dealing with HTML string or an ID?
781			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
782				// Assume that strings that start and end with <> are HTML and skip the regex check
783				match = [ null, selector, null ];
784
785			} else {
786				match = quickExpr.exec( selector );
787			}
788
789			// Verify a match, and that no context was specified for #id
790			if ( match && (match[1] || !context) ) {
791
792				// HANDLE: $(html) -> $(array)
793				if ( match[1] ) {
794					context = context instanceof jQuery ? context[0] : context;
795					doc = ( context ? context.ownerDocument || context : document );
796

797					// If a single string is passed in and it's a single tag
798					// just do a createElement and skip the rest
799					ret = rsingleTag.exec( selector );
800
801					if ( ret ) {
802						if ( jQuery.isPlainObject( context ) ) {
803							selector = [ document.createElement( ret[1] ) ];
804							jQuery.fn.attr.call( selector, context, true );
805
806						} else {
807							selector = [ doc.createElement( ret[1] ) ];
808						}
809
810					} else {
811						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
812						selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
813					}
814
815					return jQuery.merge( this, selector );
816
817				// HANDLE: $("#id")
818				} else {
819					elem = document.getElementById( match[2] );
820
821					// Check parentNode to catch when Blackberry 4.6 returns
822					// nodes that are no longer in the document #6963
823					if ( elem && elem.parentNode ) {
824						// Handle the case where IE and Opera return items
825						// by name instead of ID
826						if ( elem.id !== match[2] ) {
827							return rootjQuery.find( selector );
828						}
829
830						// Otherwise, we inject the element directly into the jQuery object
831						this.length = 1;
832						this[0] = elem;
833					}
834
835					this.context = document;
836					this.selector = selector;
837					return this;
838				}
839
840			// HANDLE: $(expr, $(...))
841			} else if ( !context || context.jquery ) {
842				return ( context || rootjQuery ).find( selector );
843
844			// HANDLE: $(expr, context)
845			// (which is just equivalent to: $(context).find(expr)
846			} else {
847				return this.constructor( context ).find( selector );
848			}
849
850		// HANDLE: $(function)
851		// Shortcut for document ready
852		} else if ( jQuery.isFunction( selector ) ) {
853			return rootjQuery.ready( selector );
854		}
855
856		if ( selector.selector !== undefined ) {
857			this.selector = selector.selector;
858			this.context = selector.context;
859		}
860
861		return jQuery.makeArray( selector, this );
862	},
863
864	// Start with an empty selector
865	selector: "",
866
867	// The current version of jQuery being used
868	jquery: "1.7.1",
869
870	// The default length of a jQuery object is 0
871	length: 0,
872
873	// The number of elements contained in the matched element set
874	size: function() {
875		return this.length;
876	},
877
878	toArray: function() {
879		return slice.call( this, 0 );
880	},
881
882	// Get the Nth element in the matched element set OR
883	// Get the whole matched element set as a clean array
884	get: function( num ) {
885		return num == null ?
886
887			// Return a 'clean' array
888			this.toArray() :
889
890			// Return just the object
891			( num < 0 ? this[ this.length + num ] : this[ num ] );
892	},
893
894	// Take an array of elements and push it onto the stack
895	// (returning the new matched element set)
896	pushStack: function( elems, name, selector ) {
897		// Build a new jQuery matched element set
898		var ret = this.constructor();
899
900		if ( jQuery.isArray( elems ) ) {
901			push.apply( ret, elems );
902
903		} else {
904			jQuery.merge( ret, elems );
905		}
906
907		// Add the old object onto the stack (as a reference)
908		ret.prevObject = this;
909
910		ret.context = this.context;
911
912		if ( name === "find" ) {
913			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
914		} else if ( name ) {
915			ret.selector = this.selector + "." + name + "(" + selector + ")";
916		}
917
918		// Return the newly-formed element set
919		return ret;
920	},
921
922	// Execute a callback for every element in the matched set.
923	// (You can seed the arguments with an array of args, but this is
924	// only used internally.)
925	each: function( callback, args ) {
926		return jQuery.each( this, callback, args );
927	},
928
929	ready: function( fn ) {
930		// Attach the listeners
931		jQuery.bindReady();
932
933		// Add the callback
934		readyList.add( fn );
935
936		return this;
937	},
938
939	eq: function( i ) {
940		i = +i;
941		return i === -1 ?
942			this.slice( i ) :
943			this.slice( i, i + 1 );
944	},
945
946	first: function() {
947		return this.eq( 0 );
948	},
949
950	last: function() {
951		return this.eq( -1 );
952	},
953
954	slice: function() {
955		return this.pushStack( slice.apply( this, arguments ),
956			"slice", slice.call(arguments).join(",") );
957	},
958
959	map: function( callback ) {
960		return this.pushStack( jQuery.map(this, function( elem, i ) {
961			return callback.call( elem, i, elem );
962		}));
963	},
964
965	end: function() {
966		return this.prevObject || this.constructor(null);
967	},
968
969	// For internal use only.
970	// Behaves like an Array's method, not like a jQuery method.
971	push: push,
972	sort: [].sort,
973	splice: [].splice
974};
975
976// Give the init function the jQuery prototype for later instantiation
977jQuery.fn.init.prototype = jQuery.fn;
978
979jQuery.extend = jQuery.fn.extend = function() {
980	var options, name, src, copy, copyIsArray, clone,
981		target = arguments[0] || {},
982		i = 1,
983		length = arguments.length,
984		deep = false;

985
986	// Handle a deep copy situation
987	if ( typeof target === "boolean" ) {
988		deep = target;
989		target = arguments[1] || {};
990		// skip the boolean and the target
991		i = 2;
992	}
993
994	// Handle case when target is a string or something (possible in deep copy)
995	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
996		target = {};
997	}
998
999	// extend jQuery itself if only one argument is passed
1000	if ( length === i ) {
1001		target = this;
1002		--i;
1003	}
1004
1005	for ( ; i < length; i++ ) {
1006		// Only deal with non-null/undefined values
1007		if ( (options = arguments[ i ]) != null ) {
1008			// Extend the base object
1009			for ( name in options ) {
1010				src = target[ name ];
1011				copy = options[ name ];
1012
1013				// Prevent never-ending loop
1014				if ( target === copy ) {
1015					continue;
1016				}
1017
1018				// Recurse if we're merging plain objects or arrays
1019				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
1020					if ( copyIsArray ) {
1021						copyIsArray = false;
1022						clone = src && jQuery.isArray(src) ? src : [];
1023
1024					} else {
1025						clone = src && jQuery.isPlainObject(src) ? src : {};
1026					}
1027
1028					// Never move original objects, clone them
1029					target[ name ] = jQuery.extend( deep, clone, copy );
1030
1031				// Don't bring in undefined values
1032				} else if ( copy !== undefined ) {
1033					target[ name ] = copy;
1034				}
1035			}
1036		}
1037	}
1038
1039	// Return the modified object
1040	return target;
1041};
1042
1043jQuery.extend({
1044	noConflict: function( deep ) {
1045		if ( window.$ === jQuery ) {
1046			window.$ = _$;
1047		}
1048
1049		if ( deep && window.jQuery === jQuery ) {
1050			window.jQuery = _jQuery;
1051		}
1052
1053		return jQuery;
1054	},
1055
1056	// Is the DOM ready to be used? Set to true once it occurs.
1057	isReady: false,
1058
1059	// A counter to track how many items to wait for before
1060	// the ready event fires. See #6781
1061	readyWait: 1,
1062
1063	// Hold (or release) the ready event
1064	holdReady: function( hold ) {
1065		if ( hold ) {
1066			jQuery.readyWait++;
1067		} else {
1068			jQuery.ready( true );
1069		}
1070	},
1071
1072	// Handle when the DOM is ready
1073	ready: function( wait ) {
1074		// Either a released hold or an DOMready/load event and not yet ready
1075		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
1076			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
1077			if ( !document.body ) {
1078				return setTimeout( jQuery.ready, 1 );
1079			}
1080
1081			// Remember that the DOM is ready
1082			jQuery.isReady = true;
1083
1084			// If a normal DOM Ready event fired, decrement, and wait if need be
1085			if ( wait !== true && --jQuery.readyWait > 0 ) {
1086				return;
1087			}
1088
1089			// If there are functions bound, to execute
1090			readyList.fireWith( document, [ jQuery ] );
1091
1092			// Trigger any bound ready events
1093			if ( jQuery.fn.trigger ) {
1094				jQuery( document ).trigger( "ready" ).off( "ready" );
1095			}
1096		}
1097	},
1098
1099	bindReady: function() {
1100		if ( readyList ) {
1101			return;
1102		}
1103
1104		readyList = jQuery.Callbacks( "once memory" );
1105
1106		// Catch cases where $(document).ready() is called after the
1107		// browser event has already occurred.
1108		if ( document.readyState === "complete" ) {
1109			// Handle it asynchronously to allow scripts the opportunity to delay ready
1110			return setTimeout( jQuery.ready, 1 );
1111		}
1112
1113		// Mozilla, Opera and webkit nightlies currently support this event
1114		if ( document.addEventListener ) {
1115			// Use the handy event callback
1116			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
1117
1118			// A fallback to window.onload, that will always work
1119			window.addEventListener( "load", jQuery.ready, false );
1120
1121		// If IE event model is used
1122		} else if ( document.attachEvent ) {
1123			// ensure firing before onload,
1124			// maybe late but safe also for iframes
1125			document.attachEvent( "onreadystatechange", DOMContentLoaded );
1126
1127			// A fallback to window.onload, that will always work
1128			window.attachEvent( "onload", jQuery.ready );
1129
1130			// If IE and not a frame
1131			// continually check to see if the document is ready
1132			var toplevel = false;
1133
1134			try {
1135				toplevel = window.frameElement == null;
1136			} catch(e) {}
1137
1138			if ( document.documentElement.doScroll && toplevel ) {
1139				doScrollCheck();
1140			}
1141		}
1142	},
1143
1144	// See test/unit/core.js for details concerning isFunction.
1145	// Since version 1.3, DOM methods and functions like alert
1146	// aren't supported. They return false on IE (#2968).
1147	isFunction: function( obj ) {
1148		return jQuery.type(obj) === "function";
1149	},
1150
1151	isArray: Array.isArray || function( obj ) {
1152		return jQuery.type(obj) === "array";
1153	},
1154
1155	// A crude way of determining if an object is a window
1156	isWindow: function( obj ) {
1157		return obj && typeof obj === "object" && "setInterval" in obj;
1158	},
1159
1160	isNumeric: function( obj ) {
1161		return !isNaN( parseFloat(obj) ) && isFinite( obj );
1162	},
1163
1164	type: function( obj ) {
1165		return obj == null ?
1166			String( obj ) :
1167			class2type[ toString.call(obj) ] || "object";
1168	},
1169
1170	isPlainObject: function( obj ) {
1171		// Must be an Object.
1172		// Because of IE, we also have to check the presence of the constructor property.
1173		// Make sure that DOM nodes and window objects don't pass through, as well
1174		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
1175			return false;

1176		}
1177
1178		try {
1179			// Not own constructor property must be Object
1180			if ( obj.constructor &&
1181				!hasOwn.call(obj, "constructor") &&
1182				!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
1183				return false;
1184			}
1185		} catch ( e ) {
1186			// IE8,9 Will throw exceptions on certain host objects #9897
1187			return false;
1188		}
1189
1190		// Own properties are enumerated firstly, so to speed up,
1191		// if last one is own, then all properties are own.
1192
1193		var key;
1194		for ( key in obj ) {}
1195
1196		return key === undefined || hasOwn.call( obj, key );
1197	},
1198
1199	isEmptyObject: function( obj ) {
1200		for ( var name in obj ) {
1201			return false;
1202		}
1203		return true;
1204	},
1205
1206	error: function( msg ) {
1207		throw new Error( msg );
1208	},
1209
1210	parseJSON: function( data ) {
1211		if ( typeof data !== "string" || !data ) {
1212			return null;
1213		}
1214
1215		// Make sure leading/trailing whitespace is removed (IE can't handle it)
1216		data = jQuery.trim( data );
1217
1218		// Attempt to parse using the native JSON parser first
1219		if ( window.JSON && window.JSON.parse ) {
1220			return window.JSON.parse( data );
1221		}
1222
1223		// Make sure the incoming data is actual JSON
1224		// Logic borrowed from http://json.org/json2.js
1225		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
1226			.replace( rvalidtokens, "]" )
1227			.replace( rvalidbraces, "")) ) {
1228
1229			return ( new Function( "return " + data ) )();
1230
1231		}
1232		jQuery.error( "Invalid JSON: " + data );
1233	},
1234
1235	// Cross-browser xml parsing
1236	parseXML: function( data ) {
1237		var xml, tmp;
1238		try {
1239			if ( window.DOMParser ) { // Standard
1240				tmp = new DOMParser();
1241				xml = tmp.parseFromString( data , "text/xml" );
1242			} else { // IE
1243				xml = new ActiveXObject( "Microsoft.XMLDOM" );
1244				xml.async = "false";
1245				xml.loadXML( data );
1246			}
1247		} catch( e ) {
1248			xml = undefined;
1249		}
1250		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
1251			jQuery.error( "Invalid XML: " + data );
1252		}
1253		return xml;
1254	},
1255
1256	noop: function() {},
1257
1258	// Evaluates a script in a global context
1259	// Workarounds based on findings by Jim Driscoll
1260	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
1261	globalEval: function( data ) {
1262		if ( data && rnotwhite.test( data ) ) {
1263			// We use execScript on Internet Explorer
1264			// We use an anonymous function so that context is window
1265			// rather than jQuery in Firefox
1266			( window.execScript || function( data ) {
1267				window[ "eval" ].call( window, data );
1268			} )( data );
1269		}
1270	},
1271
1272	// Convert dashed to camelCase; used by the css and data modules
1273	// Microsoft forgot to hump their vendor prefix (#9572)
1274	camelCase: function( string ) {
1275		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
1276	},
1277

1278	nodeName: function( elem, name ) {
1279		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
1280	},
1281
1282	// args is for internal usage only
1283	each: function( object, callback, args ) {
1284		var name, i = 0,
1285			length = object.length,
1286			isObj = length === undefined || jQuery.isFunction( object );
1287
1288		if ( args ) {
1289			if ( isObj ) {
1290				for ( name in object ) {
1291					if ( callback.apply( object[ name ], args ) === false ) {
1292						break;
1293					}
1294				}
1295			} else {
1296				for ( ; i < length; ) {
1297					if ( callback.apply( object[ i++ ], args ) === false ) {
1298						break;
1299					}
1300				}
1301			}
1302
1303		// A special, fast, case for the most common use of each
1304		} else {
1305			if ( isObj ) {
1306				for ( name in object ) {
1307					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
1308						break;
1309					}
1310				}
1311			} else {
1312				for ( ; i < length; ) {
1313					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
1314						break;
1315					}
1316				}
1317			}
1318		}
1319
1320		return object;
1321	},
1322
1323	// Use native String.trim function wherever possible
1324	trim: trim ?
1325		function( text ) {
1326			return text == null ?
1327				"" :
1328				trim.call( text );
1329		} :
1330
1331		// Otherwise use our own trimming functionality
1332		function( text ) {
1333			return text == null ?
1334				"" :
1335				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
1336		},
1337
1338	// results is for internal usage only
1339	makeArray: function( array, results ) {
1340		var ret = results || [];
1341
1342		if ( array != null ) {
1343			// The window, strings (and functions) also have 'length'
1344			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
1345			var type = jQuery.type( array );
1346
1347			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
1348				push.call( ret, array );
1349			} else {
1350				jQuery.merge( ret, array );
1351			}
1352		}
1353
1354		return ret;
1355	},
1356
1357	inArray: function( elem, array, i ) {
1358		var len;
1359
1360		if ( array ) {
1361			if ( indexOf ) {
1362				return indexOf.call( array, elem, i );
1363			}
1364
1365			len = array.length;
1366			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
1367
1368			for ( ; i < len; i++ ) {
1369				// Skip accessing in sparse arrays
1370				if ( i in array && array[ i ] === elem ) {
1371					return i;
1372				}
1373			}
1374		}
1375
1376		return -1;
1377	},
1378
1379	merge: function( first, second ) {
1380		var i = first.length,
1381			j = 0;
1382
1383		if ( typeof second.length === "number" ) {
1384			for ( var l = second.length; j < l; j++ ) {
1385				first[ i++ ] = second[ j ];
1386			}
1387
1388		} else {
1389			while ( second[j] !== undefined ) {
1390				first[ i++ ] = second[ j++ ];
1391			}
1392		}
1393
1394		first.length = i;
1395
1396		return first;
1397	},
1398
1399	grep: function( elems, callback, inv ) {
1400		var ret = [], retVal;
1401		inv = !!inv;
1402
1403		// Go through the array, only saving the items
1404		// that pass the validator function
1405		for ( var i = 0, length = elems.length; i < length; i++ ) {
1406			retVal = !!callback( elems[ i ], i );
1407			if ( inv !== retVal ) {
1408				ret.push( elems[ i ] );
1409			}
1410		}
1411
1412		return ret;
1413	},
1414
1415	// arg is for internal usage only
1416	map: function( elems, callback, arg ) {
1417		var value, key, ret = [],
1418			i = 0,
1419			length = elems.length,
1420			// jquery objects are treated as arrays
1421			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
1422
1423		// Go through the array, translating each of the items to their
1424		if ( isArray ) {
1425			for ( ; i < length; i++ ) {
1426				value = callback( elems[ i ], i, arg );
1427
1428				if ( value != null ) {
1429					ret[ ret.length ] = value;
1430				}
1431			}
1432
1433		// Go through every key on the object,
1434		} else {
1435			for ( key in elems ) {
1436				value = callback( elems[ key ], key, arg );
1437
1438				if ( value != null ) {
1439					ret[ ret.length ] = value;
1440				}
1441			}
1442		}
1443
1444		// Flatten any nested arrays
1445		return ret.concat.apply( [], ret );
1446	},
1447
1448	// A global GUID counter for objects
1449	guid: 1,
1450
1451	// Bind a function to a context, optionally partially applying any
1452	// arguments.
1453	proxy: function( fn, context ) {
1454		if ( typeof context === "string" ) {
1455			var tmp = fn[ context ];
1456			context = fn;
1457			fn = tmp;
1458		}
1459
1460		// Quick check to determine if target is callable, in the spec
1461		// this throws a TypeError, but we will just return undefined.
1462		if ( !jQuery.isFunction( fn ) ) {
1463			return undefined;
1464		}
1465
1466		// Simulated bind
1467		var args = slice.call( arguments, 2 ),
1468			proxy = function() {
1469				return fn.apply( context, args.concat( slice.call( arguments ) ) );
1470			};
1471
1472		// Set the guid of unique handler to the same of original handler, so it can be removed
1473		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
1474
1475		return proxy;
1476	},
1477
1478	// Mutifunctional method to get and set values to a collection
1479	// The value/s can optionally be executed if it's a function
1480	access: function( elems, key, value, exec, fn, pass ) {
1481		var length = elems.length;
1482
1483		// Setting many attributes
1484		if ( typeof key === "object" ) {
1485			for ( var k in key ) {
1486				jQuery.access( elems, k, key[k], exec, fn, value );
1487			}
1488			return elems;
1489		}
1490
1491		// Setting one attribute
1492		if ( value !== undefined ) {
1493			// Optionally, function values get executed if exec is true
1494			exec = !pass && exec && jQuery.isFunction(value);
1495
1496			for ( var i = 0; i < length; i++ ) {
1497				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
1498			}
1499
1500			return elems;
1501		}
1502
1503		// Getting an attribute
1504		return length ? fn( elems[0], key ) : undefined;
1505	},
1506
1507	now: function() {
1508		return ( new Date() ).getTime();
1509	},
1510
1511	// Use of jQuery.browser is frowned upon.
1512	// More details: http://docs.jquery.com/Utilities/jQuery.browser
1513	uaMatch: function( ua ) {
1514		ua = ua.toLowerCase();
1515
1516		var match = rwebkit.exec( ua ) ||
1517			ropera.exec( ua ) ||
1518			rmsie.exec( ua ) ||
1519			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
1520			[];
1521
1522		return { browser: match[1] || "", version: match[2] || "0" };
1523	},
1524
1525	sub: function() {
1526		function jQuerySub( selector, context ) {
1527			return new jQuerySub.fn.init( selector, context );
1528		}
1529		jQuery.extend( true, jQuerySub, this );
1530		jQuerySub.superclass = this;
1531		jQuerySub.fn = jQuerySub.prototype = this();
1532		jQuerySub.fn.constructor = jQuerySub;
1533		jQuerySub.sub = this.sub;
1534		jQuerySub.fn.init = function init( selector, context ) {
1535			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
1536				context = jQuerySub( context );
1537			}
1538
1539			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
1540		};
1541		jQuerySub.fn.init.prototype = jQuerySub.fn;
1542		var rootjQuerySub = jQuerySub(document);
1543		return jQuerySub;
1544	},
1545
1546	browser: {}
1547});
1548
1549// Populate the class2type map
1550jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
1551	class2type[ "[object " + name + "]" ] = name.toLowerCase();
1552});
1553
1554browserMatch = jQuery.uaMatch( userAgent );
1555if ( browserMatch.browser ) {
1556	jQuery.browser[ browserMatch.browser ] = true;
1557	jQuery.browser.version = browserMatch.version;
1558}
1559
1560// Deprecated, use jQuery.browser.webkit instead
1561if ( jQuery.browser.webkit ) {
1562	jQuery.browser.safari = true;
1563}
1564

1565// IE doesn't match non-breaking spaces with \s
1566if ( rnotwhite.test( "\xA0" ) ) {
1567	trimLeft = /^[\s\xA0]+/;
1568	trimRight = /[\s\xA0]+$/;
1569}
1570
1571// All jQuery objects should point back to these
1572rootjQuery = jQuery(document);
1573
1574// Cleanup functions for the document ready method
1575if ( document.addEventListener ) {
1576	DOMContentLoaded = function() {
1577		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
1578		jQuery.ready();
1579	};
1580
1581} else if ( document.attachEvent ) {
1582	DOMContentLoaded = function() {
1583		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
1584		if ( document.readyState === "complete" ) {
1585			document.detachEvent( "onreadystatechange", DOMContentLoaded );
1586			jQuery.ready();
1587		}
1588	};
1589}
1590
1591// The DOM ready check for Internet Explorer
1592function doScrollCheck() {
1593	if ( jQuery.isReady ) {
1594		return;
1595	}
1596
1597	try {
1598		// If IE is used, use the trick by Diego Perini
1599		// http://javascript.nwbox.com/IEContentLoaded/
1600		document.documentElement.doScroll("left");
1601	} catch(e) {
1602		setTimeout( doScrollCheck, 1 );
1603		return;
1604	}
1605
1606	// and execute any waiting functions
1607	jQuery.ready();
1608}
1609
1610return jQuery;
1611
1612})();
1613
1614
1615// String to Object flags format cache
1616var flagsCache = {};
1617
1618// Convert String-formatted flags into Object-formatted ones and store in cache
1619function createFlags( flags ) {
1620	var object = flagsCache[ flags ] = {},
1621		i, length;
1622	flags = flags.split( /\s+/ );
1623	for ( i = 0, length = flags.length; i < length; i++ ) {
1624		object[ flags[i] ] = true;
1625	}
1626	return object;
1627}
1628
1629/*
1630 * Create a callback list using the following parameters:
1631 *
1632 *	flags:	an optional list of space-separated flags that will change how
1633 *			the callback list behaves
1634 *
1635 * By default a callback list will act like an event callback list and can be
1636 * "fired" multiple times.
1637 *
1638 * Possible flags:
1639 *
1640 *	once:			will ensure the callback list can only be fired once (like a Deferred)
1641 *
1642 *	memory:			will keep track of previous values and will call any callback added
1643 *					after the list has been fired right away with the latest "memorized"
1644 *					values (like a Deferred)
1645 *
1646 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
1647 *
1648 *	stopOnFalse:	interrupt callings when a callback returns false
1649 *
1650 */
1651jQuery.Callbacks = function( flags ) {
1652
1653	// Convert flags from String-formatted to Object-formatted
1654	// (we check in cache first)
1655	flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
1656
1657	var // Actual callback list
1658		list = [],
1659		// Stack of fire calls for repeatable lists
1660		stack = [],
1661		// Last fire value (for non-forgettable lists)
1662		memory,
1663		// Flag to know if list is currently firing
1664		firing,
1665		// First callback to fire (used internally by add and fireWith)
1666		firingStart,
1667		// End of the loop when firing
1668		firingLength,
1669		// Index of currently firing callback (modified by remove if needed)
1670		firingIndex,
1671		// Add one or several callbacks to the list
1672		add = function( args ) {
1673			var i,
1674				length,
1675				elem,
1676				type,
1677				actual;
1678			for ( i = 0, length = args.length; i < length; i++ ) {
1679				elem = args[ i ];
1680				type = jQuery.type( elem );
1681				if ( type === "array" ) {
1682					// Inspect recursively
1683					add( elem );
1684				} else if ( type === "function" ) {
1685					// Add if not in unique mode and callback is not in
1686					if ( !flags.unique || !self.has( elem ) ) {
1687						list.push( elem );
1688					}
1689				}
1690			}
1691		},
1692		// Fire callbacks
1693		fire = function( context, args ) {
1694			args = args || [];
1695			memory = !flags.memory || [ context, args ];
1696			firing = true;
1697			firingIndex = firingStart || 0;
1698			firingStart = 0;
1699			firingLength = list.length;
1700			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1701				if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
1702					memory = true; // Mark as halted
1703					break;
1704				}
1705			}
1706			firing = false;
1707			if ( list ) {
1708				if ( !flags.once ) {
1709					if ( stack && stack.length ) {
1710						memory = stack.shift();
1711						self.fireWith( memory[ 0 ], memory[ 1 ] );
1712					}
1713				} else if ( memory === true ) {
1714					self.disable();
1715				} else {
1716					list = [];
1717				}
1718			}
1719		},
1720		// Actual Callbacks object
1721		self = {
1722			// Add a callback or a collection of callbacks to the list
1723			add: function() {
1724				if ( list ) {
1725					var length = list.length;
1726					add( arguments );
1727					// Do we need to add the callbacks to the
1728					// current firing batch?
1729					if ( firing ) {
1730						firingLength = list.length;
1731					// With memory, if we're not firing then
1732					// we should call right away, unless previous
1733					// firing was halted (stopOnFalse)
1734					} else if ( memory && memory !== true ) {
1735						firingStart = length;
1736						fire( memory[ 0 ], memory[ 1 ] );
1737					}
1738				}
1739				return this;
1740			},
1741			// Remove a callback from the list
1742			remove: function() {
1743				if ( list ) {
1744					var args = arguments,
1745						argIndex = 0,
1746						argLength = args.length;
1747					for ( ; argIndex < argLength ; argIndex++ ) {
1748						for ( var i = 0; i < list.length; i++ ) {
1749							if ( args[ argIndex ] === list[ i ] ) {
1750								// Handle firingIndex and firingLength
1751								if ( firing ) {
1752									if ( i <= firingLength ) {
1753										firingLength--;
1754										if ( i <= firingIndex ) {
1755											firingIndex--;
1756										}
1757									}
1758								}
1759								// Remove the element
1760								list.splice( i--, 1 );
1761								// If we have some unicity property then
1762								// we only need to do this once
1763								if ( flags.unique ) {
1764									break;
1765								}
1766							}
1767						}
1768					}
1769				}
1770				return this;
1771			},
1772			// Control if a given callback is in the list
1773			has: function( fn ) {
1774				if ( list ) {
1775					var i = 0,
1776						length = list.length;
1777					for ( ; i < length; i++ ) {
1778						if ( fn === list[ i ] ) {
1779							return true;
1780						}
1781					}
1782				}
1783				return false;

1784			},
1785			// Remove all callbacks from the list
1786			empty: function() {
1787				list = [];
1788				return this;
1789			},
1790			// Have the list do nothing anymore
1791			disable: function() {
1792				list = stack = memory = undefined;
1793				return this;
1794			},
1795			// Is it disabled?
1796			disabled: function() {
1797				return !list;
1798			},
1799			// Lock the list in its current state
1800			lock: function() {
1801				stack = undefined;
1802				if ( !memory || memory === true ) {
1803					self.disable();
1804				}
1805				return this;
1806			},
1807			// Is it locked?
1808			locked: function() {
1809				return !stack;
1810			},
1811			// Call all callbacks with the given context and arguments
1812			fireWith: function( context, args ) {
1813				if ( stack ) {
1814					if ( firing ) {
1815						if ( !flags.once ) {
1816							stack.push( [ context, args ] );
1817						}
1818					} else if ( !( flags.once && memory ) ) {
1819						fire( context, args );
1820					}
1821				}
1822				return this;
1823			},
1824			// Call all the callbacks with the given arguments
1825			fire: function() {
1826				self.fireWith( this, arguments );
1827				return this;
1828			},
1829			// To know if the callbacks have already been called at least once
1830			fired: function() {
1831				return !!memory;
1832			}
1833		};
1834
1835	return self;
1836};
1837
1838
1839
1840
1841var // Static reference to slice
1842	sliceDeferred = [].slice;
1843
1844jQuery.extend({
1845
1846	Deferred: function( func ) {
1847		var doneList = jQuery.Callbacks( "once memory" ),
1848			failList = jQuery.Callbacks( "once memory" ),
1849			progressList = jQuery.Callbacks( "memory" ),
1850			state = "pending",
1851			lists = {
1852				resolve: doneList,
1853				reject: failList,
1854				notify: progressList
1855			},
1856			promise = {
1857				done: doneList.add,
1858				fail: failList.add,
1859				progress: progressList.add,
1860
1861				state: function() {
1862					return state;
1863				},
1864
1865				// Deprecated
1866				isResolved: doneList.fired,
1867				isRejected: failList.fired,
1868
1869				then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
1870					deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
1871					return this;
1872				},
1873				always: function() {
1874					deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
1875					return this;
1876				},
1877				pipe: function( fnDone, fnFail, fnProgress ) {
1878					return jQuery.Deferred(function( newDefer ) {
1879						jQuery.each( {
1880							done: [ fnDone, "resolve" ],
1881							fail: [ fnFail, "reject" ],
1882							progress: [ fnProgress, "notify" ]
1883						}, function( handler, data ) {
1884							var fn = data[ 0 ],
1885								action = data[ 1 ],
1886								returned;
1887							if ( jQuery.isFunction( fn ) ) {
1888								deferred[ handler ](function() {
1889									returned = fn.apply( this, arguments );
1890									if ( returned && jQuery.isFunction( returned.promise ) ) {
1891										returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
1892									} else {
1893										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1894									}
1895								});
1896							} else {
1897								deferred[ handler ]( newDefer[ action ] );
1898							}
1899						});
1900					}).promise();
1901				},
1902				// Get a promise for this deferred
1903				// If obj is provided, the promise aspect is added to the object
1904				promise: function( obj ) {
1905					if ( obj == null ) {
1906						obj = promise;
1907					} else {
1908						for ( var key in promise ) {
1909							obj[ key ] = promise[ key ];
1910						}
1911					}
1912					return obj;
1913				}
1914			},
1915			deferred = promise.promise({}),
1916			key;
1917
1918		for ( key in lists ) {
1919			deferred[ key ] = lists[ key ].fire;
1920			deferred[ key + "With" ] = lists[ key ].fireWith;
1921		}
1922
1923		// Handle state
1924		deferred.done( function() {
1925			state = "resolved";
1926		}, failList.disable, progressList.lock ).fail( function() {
1927			state = "rejected";
1928		}, doneList.disable, progressList.lock );
1929
1930		// Call given func if any
1931		if ( func ) {
1932			func.call( deferred, deferred );
1933		}
1934
1935		// All done!
1936		return deferred;
1937	},
1938
1939	// Deferred helper
1940	when: function( firstParam ) {
1941		var args = sliceDeferred.call( arguments, 0 ),
1942			i = 0,
1943			length = args.length,
1944			pValues = new Array( length ),
1945			count = length,
1946			pCount = length,
1947			deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1948				firstParam :
1949				jQuery.Deferred(),
1950			promise = deferred.promise();
1951		function resolveFunc( i ) {
1952			return function( value ) {
1953				args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1954				if ( !( --count ) ) {
1955					deferred.resolveWith( deferred, args );
1956				}
1957			};
1958		}
1959		function progressFunc( i ) {
1960			return function( value ) {
1961				pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1962				deferred.notifyWith( promise, pValues );
1963			};
1964		}
1965		if ( length > 1 ) {
1966			for ( ; i < length; i++ ) {
1967				if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
1968					args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
1969				} else {
1970					--count;
1971				}
1972			}
1973			if ( !count ) {
1974				deferred.resolveWith( deferred, args );
1975			}
1976		} else if ( deferred !== firstParam ) {
1977			deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1978		}
1979		return promise;
1980	}
1981});
1982
1983
1984
1985
1986jQuery.support = (function() {
1987
1988	var support,
1989		all,
1990		a,
1991		select,
1992		opt,
1993		input,
1994		marginDiv,
1995		fragment,
1996		tds,
1997		events,
1998		eventName,
1999		i,
2000		isSupported,
2001		div = document.createElement( "div" ),
2002		documentElement = document.documentElement;
2003
2004	// Preliminary tests
2005	div.setAttribute("className", "t");
2006	div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a>

2006<input type='checkbox'/>";
2007
2008	all = div.getElementsByTagName( "*" );
2009	a = div.getElementsByTagName( "a" )[ 0 ];
2010
2011	// Can't get basic test support
2012	if ( !all || !all.length || !a ) {
2013		return {};
2014	}
2015
2016	// First batch of supports tests
2017	select = document.createElement( "select" );
2018	opt = select.appendChild( document.createElement("option") );
2019	input = div.getElementsByTagName( "input" )[ 0 ];
2020
2021	support = {
2022		// IE strips leading whitespace when .innerHTML is used
2023		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
2024
2025		// Make sure that tbody elements aren't automatically inserted
2026		// IE will insert them into empty tables
2027		tbody: !div.getElementsByTagName("tbody").length,
2028
2029		// Make sure that link elements get serialized correctly by innerHTML
2030		// This requires a wrapper element in IE
2031		htmlSerialize: !!div.getElementsByTagName("link").length,
2032
2033		// Get the style information from getAttribute
2034		// (IE uses .cssText instead)
2035		style: /top/.test( a.getAttribute("style") ),
2036
2037		// Make sure that URLs aren't manipulated
2038		// (IE normalizes it by default)
2039		hrefNormalized: ( a.getAttribute("href") === "/a" ),
2040
2041		// Make sure that element opacity exists
2042		// (IE uses filter instead)
2043		// Use a regex to work around a WebKit issue. See #5145
2044		opacity: /^0.55/.test( a.style.opacity ),
2045
2046		// Verify style float existence
2047		// (IE uses styleFloat instead of cssFloat)
2048		cssFloat: !!a.style.cssFloat,
2049
2050		// Make sure that if no value is specified for a checkbox
2051		// that it defaults to "on".
2052		// (WebKit defaults to "" instead)
2053		checkOn: ( input.value === "on" ),
2054
2055		// Make sure that a selected-by-default option has a working selected property.
2056		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
2057		optSelected: opt.selected,
2058
2059		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
2060		getSetAttribute: div.className !== "t",
2061
2062		// Tests for enctype support on a form(#6743)
2063		enctype: !!document.createElement("form").enctype,
2064
2065		// Makes sure cloning an html5 element does not cause problems
2066		// Where outerHTML is undefined, this still works
2067		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
2068
2069		// Will be defined later
2070		submitBubbles: true,
2071		changeBubbles: true,
2072		focusinBubbles: false,
2073		deleteExpando: true,
2074		noCloneEvent: true,
2075		inlineBlockNeedsLayout: false,
2076		shrinkWrapBlocks: false,
2077		reliableMarginRight: true
2078	};
2079
2080	// Make sure checked status is properly cloned
2081	input.checked = true;
2082	support.noCloneChecked = input.cloneNode( true ).checked;
2083
2084	// Make sure that the options inside disabled selects aren't marked as disabled
2085	// (WebKit marks them as disabled)
2086	select.disabled = true;
2087	support.optDisabled = !opt.disabled;
2088
2089	// Test to see if it's possible to delete an expando from an element
2090	// Fails in Internet Explorer
2091	try {
2092		delete div.test;
2093	} catch( e ) {
2094		support.deleteExpando = false;
2095	}
2096
2097	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
2098		div.attachEvent( "onclick", function() {
2099			// Cloning a node shouldn't copy over any
2100			// bound event handlers (IE does this)
2101			support.noCloneEvent = false;
2102		});
2103		div.cloneNode( true ).fireEvent( "onclick" );
2104	}
2105
2106	// Check if a radio maintains its value
2107	// after being appended to the DOM
2108	input = document.createElement("input");
2109	input.value = "t";
2110	input.setAttribute("type", "radio");
2111	support.radioValue = input.value === "t";
2112
2113	input.setAttribute("checked", "checked");
2114	div.appendChild( input );
2115	fragment = document.createDocumentFragment();
2116	fragment.appendChild( div.lastChild );
2117
2118	// WebKit doesn't clone checked state correctly in fragments
2119	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
2120
2121	// Check if a disconnected checkbox will retain its checked
2122	// value of true after appended to the DOM (IE6/7)
2123	support.appendChecked = input.checked;
2124
2125	fragment.removeChild( input );
2126	fragment.appendChild( div );
2127
2128	div.innerHTML = "";
2129
2130	// Check if div with explicit width and no margin-right incorrectly
2131	// gets computed margin-right based on width of container. For more
2132	// info see bug #3333
2133	// Fails in WebKit before Feb 2011 nightlies
2134	// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
2135	if ( window.getComputedStyle ) {
2136		marginDiv = document.createElement( "div" );
2137		marginDiv.style.width = "0";
2138		marginDiv.style.marginRight = "0";
2139		div.style.width = "2px";
2140		div.appendChild( marginDiv );
2141		support.reliableMarginRight =
2142			( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
2143	}
2144
2145	// Technique from Juriy Zaytsev
2146	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
2147	// We only care about the case where non-standard event systems
2148	// are used, namely in IE. Short-circuiting here helps us to
2149	// avoid an eval call (in setAttribute) which can cause CSP
2150	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
2151	if ( div.attachEvent ) {
2152		for( i in {
2153			submit: 1,
2154			change: 1,
2155			focusin: 1
2156		}) {
2157			eventName = "on" + i;
2158			isSupported = ( eventName in div );
2159			if ( !isSupported ) {
2160				div.setAttribute( eventName, "return;" );
2161				isSupported = ( typeof div[ eventName ] === "function" );
2162			}
2163			support[ i + "Bubbles" ] = isSupported;
2164		}
2165	}
2166
2167	fragment.removeChild( div );
2168
2169	// Null elements to avoid leaks in IE
2170	fragment = select = opt = marginDiv = div = input = null;
2171
2172	// Run tests that need a body at doc ready
2173	jQuery(function() {
2174		var container, outer, inner, table, td, offsetSupport,
2175			conMarginTop, ptlm, vb, style, html,
2176			body = document.getElementsByTagName("body")[0];
2177
2178		if ( !body ) {
2179			// Return for frameset docs that don't have a body
2180			return;
2181		}
2182
2183		conMarginTop = 1;
2184		ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";
2185		vb = "visibility:hidden;border:0;";
2186		style = "style='" + ptlm + "border:5px solid #000;padding:0;'";
2187		html = "<div " + style + "><div></div></div>" +
2188			"<table " + style + " cellpadding='0' cellspacing='0'>" +
2189			"<tr><td></td></tr></table>";
2190
2191		container = document.createElement("div");
2192		container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
2193		body.insertBefore( container, body.firstChild );
2194
2195		// Construct the test element
2196		div = document.createElement("div");
2197		container.appendChild( div );
2198
2199		// Check if table cells still have offsetWidth/Height when they are set
2200		// to display:none and there are still other visible table cells in a
2201		// table row; if so, offsetWidth/Height are not reliable for use when
2202		// determining if an element has been hidden directly using
2203		// display:none (it is still safe to use offsets if a parent element is
2204		// hidden; don safety goggles and see bug #4512 for more information).
2205		// (only IE 8 fails this test)
2206		div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
2207		tds = div.getElementsByTagName( "td" );
2208		isSupported = ( tds[ 0 ].offsetHeight === 0 );
2209
2210		tds[ 0 ].style.display = "";
2211		tds[ 1 ].style.display = "none";
2212
2213		// Check if empty table cells still have offsetWidth/Height
2214		// (IE <= 8 fail this test)
2215		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
2216
2217		// Figure out if the W3C box model works as expected
2218		div.innerHTML = "";
2219		div.style.width = div.style.paddingLeft = "1px";
2220		jQuery.boxModel = support.boxModel = div.offsetWidth === 2;
2221
2222		if ( typeof div.style.zoom !== "undefined" ) {
2223			// Check if natively block-level elements act like inline-block
2224			// elements when setting their display to 'inline' and giving
2225			// them layout
2226			// (IE < 8 does this)
2227			div.style.display = "inline";
2228			div.style.zoom = 1;
2229			support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
2230
2231			// Check if elements with layout shrink-wrap their children
2232			// (IE 6 does this)
2233			div.style.display = "";
2234			div.innerHTML = "<div style='width:4px;'></div>";
2235			support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
2236		}
2237
2238		div.style.cssText = ptlm + vb;
2239		div.innerHTML = html;
2240
2241		outer = div.firstChild;
2242		inner = outer.firstChild;
2243		td = outer.nextSibling.firstChild.firstChild;
2244
2245		offsetSupport = {
2246			doesNotAddBorder: ( inner.offsetTop !== 5 ),
2247			doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
2248		};
2249
2250		inner.style.position = "fixed";
2251		inner.style.top = "20px";
2252
2253		// safari subtracts parent border width here which is 5px
2254		offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
2255		inner.style.position = inner.style.top = "";
2256
2257		outer.style.overflow = "hidden";
2258		outer.style.position = "relative";
2259
2260		offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
2261		offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
2262
2263		body.removeChild( container );
2264		div  = container = null;
2265
2266		jQuery.extend( support, offsetSupport );
2267	});
2268
2269	return support;
2270})();
2271
2272
2273
2274
2275var rbrace = /^(?:\{.*\}|\[.*\])$/,
2276	rmultiDash = /([A-Z])/g;
2277
2278jQuery.extend({
2279	cache: {},
2280
2281	// Please use with caution
2282	uuid: 0,
2283
2284	// Unique for each copy of jQuery on the page
2285	// Non-digits removed to match rinlinejQuery
2286	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
2287
2288	// The following elements throw uncatchable exceptions if you
2289	// attempt to add expando properties to them.
2290	noData: {
2291		"embed": true,
2292		// Ban all objects except for Flash (which handle expandos)
2293		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
2294		"applet": true
2295	},
2296
2297	hasData: function( elem ) {
2298		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
2299		return !!elem && !isEmptyDataObject( elem );
2300	},
2301
2302	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
2303		if ( !jQuery.acceptData( elem ) ) {
2304			return;
2305		}
2306
2307		var privateCache, thisCache, ret,
2308			internalKey = jQuery.expando,
2309			getByName = typeof name === "string",
2310
2311			// We have to handle DOM nodes and JS objects differently because IE6-7
2312			// can't GC object references properly across the DOM-JS boundary
2313			isNode = elem.nodeType,
2314
2315			// Only DOM nodes need the global jQuery cache; JS object data is
2316			// attached directly to the object so GC can occur automatically
2317			cache = isNode ? jQuery.cache : elem,
2318
2319			// Only defining an ID for JS objects if its cache already exists allows
2320			// the code to shortcut on the same path as a DOM node with no cache
2321			id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
2322			isEvents = name === "events";
2323
2324		// Avoid doing any more work than we need to when trying to get data on an
2325		// object that has no data at all
2326		if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
2327			return;
2328		}
2329
2330		if ( !id ) {
2331			// Only DOM nodes need a new unique ID for each element since their data
2332			// ends up in the global cache
2333			if ( isNode ) {
2334				elem[ internalKey ] = id = ++jQuery.uuid;
2335			} else {
2336				id = internalKey;
2337			}
2338		}
2339
2340		if ( !cache[ id ] ) {
2341			cache[ id ] = {};
2342
2343			// Avoids exposing jQuery metadata on plain JS objects when the object
2344			// is serialized using JSON.stringify
2345			if ( !isNode ) {
2346				cache[ id ].toJSON = jQuery.noop;
2347			}
2348		}
2349

2350		// An object can be passed to jQuery.data instead of a key/value pair; this gets
2351		// shallow copied over onto the existing cache
2352		if ( typeof name === "object" || typeof name === "function" ) {
2353			if ( pvt ) {
2354				cache[ id ] = jQuery.extend( cache[ id ], name );
2355			} else {
2356				cache[ id ].data = jQuery.extend( cache[ id ].data, name );
2357			}
2358		}
2359
2360		privateCache = thisCache = cache[ id ];
2361
2362		// jQuery data() is stored in a separate object inside the object's internal data
2363		// cache in order to avoid key collisions between internal data and user-defined
2364		// data.
2365		if ( !pvt ) {
2366			if ( !thisCache.data ) {
2367				thisCache.data = {};
2368			}
2369
2370			thisCache = thisCache.data;
2371		}
2372
2373		if ( data !== undefined ) {
2374			thisCache[ jQuery.camelCase( name ) ] = data;
2375		}
2376
2377		// Users should not attempt to inspect the internal events object using jQuery.data,
2378		// it is undocumented and subject to change. But does anyone listen? No.
2379		if ( isEvents && !thisCache[ name ] ) {
2380			return privateCache.events;
2381		}
2382
2383		// Check for both converted-to-camel and non-converted data property names
2384		// If a data property was specified
2385		if ( getByName ) {
2386
2387			// First Try to find as-is property data
2388			ret = thisCache[ name ];
2389
2390			// Test for null|undefined property data
2391			if ( ret == null ) {
2392
2393				// Try to find the camelCased property
2394				ret = thisCache[ jQuery.camelCase( name ) ];
2395			}
2396		} else {
2397			ret = thisCache;
2398		}
2399
2400		return ret;
2401	},
2402
2403	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
2404		if ( !jQuery.acceptData( elem ) ) {
2405			return;
2406		}
2407
2408		var thisCache, i, l,
2409
2410			// Reference to internal data cache key
2411			internalKey = jQuery.expando,
2412
2413			isNode = elem.nodeType,
2414
2415			// See jQuery.data for more information
2416			cache = isNode ? jQuery.cache : elem,
2417
2418			// See jQuery.data for more information
2419			id = isNode ? elem[ internalKey ] : internalKey;
2420
2421		// If there is already no cache entry for this object, there is no
2422		// purpose in continuing
2423		if ( !cache[ id ] ) {
2424			return;
2425		}
2426
2427		if ( name ) {
2428
2429			thisCache = pvt ? cache[ id ] : cache[ id ].data;
2430
2431			if ( thisCache ) {
2432
2433				// Support array or space separated string names for data keys
2434				if ( !jQuery.isArray( name ) ) {
2435
2436					// try the string as a key before any manipulation
2437					if ( name in thisCache ) {
2438						name = [ name ];
2439					} else {
2440
2441						// split the camel cased version by spaces unless a key with the spaces exists
2442						name = jQuery.camelCase( name );
2443						if ( name in thisCache ) {
2444							name = [ name ];
2445						} else {
2446							name = name.split( " " );
2447						}
2448					}
2449				}
2450
2451				for ( i = 0, l = name.length; i < l; i++ ) {
2452					delete thisCache[ name[i] ];
2453				}
2454
2455				// If there is no data left in the cache, we want to continue
2456				// and let the cache object itself get destroyed
2457				if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
2458					return;
2459				}
2460			}
2461		}
2462
2463		// See jQuery.data for more information
2464		if ( !pvt ) {
2465			delete cache[ id ].data;
2466
2467			// Don't destroy the parent cache unless the internal data object
2468			// had been the only thing left in it
2469			if ( !isEmptyDataObject(cache[ id ]) ) {
2470				return;
2471			}
2472		}
2473
2474		// Browsers that fail expando deletion also refuse to delete expandos on
2475		// the window, but it will allow it on all other JS objects; other browsers
2476		// don't care
2477		// Ensure that `cache` is not a window object #10080
2478		if ( jQuery.support.deleteExpando || !cache.setInterval ) {
2479			delete cache[ id ];
2480		} else {
2481			cache[ id ] = null;
2482		}
2483
2484		// We destroyed the cache and need to eliminate the expando on the node to avoid
2485		// false lookups in the cache for entries that no longer exist
2486		if ( isNode ) {
2487			// IE does not allow us to delete expando properties from nodes,
2488			// nor does it have a removeAttribute function on Document nodes;
2489			// we must handle all of these cases
2490			if ( jQuery.support.deleteExpando ) {
2491				delete elem[ internalKey ];
2492			} else if ( elem.removeAttribute ) {
2493				elem.removeAttribute( internalKey );
2494			} else {
2495				elem[ internalKey ] = null;
2496			}
2497		}
2498	},
2499
2500	// For internal use only.
2501	_data: function( elem, name, data ) {
2502		return jQuery.data( elem, name, data, true );
2503	},
2504
2505	// A method for determining if a DOM node can handle the data expando
2506	acceptData: function( elem ) {
2507		if ( elem.nodeName ) {
2508			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
2509
2510			if ( match ) {
2511				return !(match === true || elem.getAttribute("classid") !== match);
2512			}
2513		}
2514
2515		return true;
2516	}
2517});
2518
2519jQuery.fn.extend({
2520	data: function( key, value ) {
2521		var parts, attr, name,
2522			data = null;
2523
2524		if ( typeof key === "undefined" ) {
2525			if ( this.length ) {
2526				data = jQuery.data( this[0] );
2527
2528				if ( this[0].nodeType === 1 && !jQuery._data( this[0], "parsedAttrs" ) ) {
2529					attr = this[0].attributes;
2530					for ( var i = 0, l = attr.length; i < l; i++ ) {
2531						name = attr[i].name;
2532

2533						if ( name.indexOf( "data-" ) === 0 ) {
2534							name = jQuery.camelCase( name.substring(5) );
2535
2536							dataAttr( this[0], name, data[ name ] );
2537						}
2538					}
2539					jQuery._data( this[0], "parsedAttrs", true );
2540				}
2541			}
2542
2543			return data;
2544
2545		} else if ( typeof key === "object" ) {
2546			return this.each(function() {
2547				jQuery.data( this, key );
2548			});
2549		}
2550
2551		parts = key.split(".");
2552		parts[1] = parts[1] ? "." + parts[1] : "";
2553
2554		if ( value === undefined ) {
2555			data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
2556
2557			// Try to fetch any internally stored data first
2558			if ( data === undefined && this.length ) {
2559				data = jQuery.data( this[0], key );
2560				data = dataAttr( this[0], key, data );
2561			}
2562
2563			return data === undefined && parts[1] ?
2564				this.data( parts[0] ) :
2565				data;
2566
2567		} else {
2568			return this.each(function() {
2569				var self = jQuery( this ),
2570					args = [ parts[0], value ];
2571
2572				self.triggerHandler( "setData" + parts[1] + "!", args );
2573				jQuery.data( this, key, value );
2574				self.triggerHandler( "changeData" + parts[1] + "!", args );
2575			});
2576		}
2577	},
2578
2579	removeData: function( key ) {
2580		return this.each(function() {
2581			jQuery.removeData( this, key );
2582		});
2583	}
2584});
2585
2586function dataAttr( elem, key, data ) {
2587	// If nothing was found internally, try to fetch any
2588	// data from the HTML5 data-* attribute
2589	if ( data === undefined && elem.nodeType === 1 ) {
2590
2591		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
2592
2593		data = elem.getAttribute( name );
2594
2595		if ( typeof data === "string" ) {
2596			try {
2597				data = data === "true" ? true :
2598				data === "false" ? false :
2599				data === "null" ? null :
2600				jQuery.isNumeric( data ) ? parseFloat( data ) :
2601					rbrace.test( data ) ? jQuery.parseJSON( data ) :
2602					data;
2603			} catch( e ) {}
2604
2605			// Make sure we set the data so it isn't changed later
2606			jQuery.data( elem, key, data );
2607
2608		} else {
2609			data = undefined;
2610		}
2611	}
2612
2613	return data;
2614}
2615
2616// checks a cache object for emptiness
2617function isEmptyDataObject( obj ) {
2618	for ( var name in obj ) {
2619
2620		// if the public data object is empty, the private is still empty
2621		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
2622			continue;
2623		}
2624		if ( name !== "toJSON" ) {
2625			return false;
2626		}
2627	}
2628
2629	return true;
2630}
2631
2632
2633
2634
2635function handleQueueMarkDefer( elem, type, src ) {
2636	var deferDataKey = type + "defer",
2637		queueDataKey = type + "queue",
2638		markDataKey = type + "mark",
2639		defer = jQuery._data( elem, deferDataKey );
2640	if ( defer &&
2641		( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
2642		( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
2643		// Give room for hard-coded callbacks to fire first
2644		// and eventually mark/queue something else on the element
2645		setTimeout( function() {
2646			if ( !jQuery._data( elem, queueDataKey ) &&
2647				!jQuery._data( elem, markDataKey ) ) {
2648				jQuery.removeData( elem, deferDataKey, true );
2649				defer.fire();
2650			}
2651		}, 0 );
2652	}
2653}
2654
2655jQuery.extend({
2656
2657	_mark: function( elem, type ) {
2658		if ( elem ) {
2659			type = ( type || "fx" ) + "mark";
2660			jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
2661		}
2662	},
2663
2664	_unmark: function( force, elem, type ) {
2665		if ( force !== true ) {
2666			type = elem;
2667			elem = force;
2668			force = false;
2669		}
2670		if ( elem ) {
2671			type = type || "fx";
2672			var key = type + "mark",
2673				count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
2674			if ( count ) {
2675				jQuery._data( elem, key, count );
2676			} else {
2677				jQuery.removeData( elem, key, true );
2678				handleQueueMarkDefer( elem, type, "mark" );
2679			}
2680		}
2681	},
2682
2683	queue: function( elem, type, data ) {
2684		var q;
2685		if ( elem ) {
2686			type = ( type || "fx" ) + "queue";
2687			q = jQuery._data( elem, type );
2688
2689			// Speed up dequeue by getting out quickly if this is just a lookup
2690			if ( data ) {
2691				if ( !q || jQuery.isArray(data) ) {
2692					q = jQuery._data( elem, type, jQuery.makeArray(data) );
2693				} else {
2694					q.push( data );
2695				}
2696			}
2697			return q || [];
2698		}
2699	},
2700
2701	dequeue: function( elem, type ) {
2702		type = type || "fx";
2703
2704		var queue = jQuery.queue( elem, type ),
2705			fn = queue.shift(),
2706			hooks = {};
2707
2708		// If the fx queue is dequeued, always remove the progress sentinel
2709		if ( fn === "inprogress" ) {
2710			fn = queue.shift();
2711		}
2712
2713		if ( fn ) {
2714			// Add a progress sentinel to prevent the fx queue from being
2715			// automatically dequeued
2716			if ( type === "fx" ) {
2717				queue.unshift( "inprogress" );
2718			}
2719
2720			jQuery._data( elem, type + ".run", hooks );
2721			fn.call( elem, function() {
2722				jQuery.dequeue( elem, type );
2723			}, hooks );
2724		}
2725
2726		if ( !queue.length ) {
2727			jQuery.removeData( elem, type + "queue " + type + ".run", true );
2728			handleQueueMarkDefer( elem, type, "queue" );
2729		}
2730	}
2731});
2732
2733jQuery.fn.extend({
2734	queue: function( type, data ) {
2735		if ( typeof type !== "string" ) {
2736			data = type;
2737			type = "fx";
2738		}
2739
2740		if ( data === undefined ) {
2741			return jQuery.queue( this[0], type );
2742		}
2743		return this.each(function() {
2744			var queue = jQuery.queue( this, type, data );
2745
2746			if ( type === "fx" && queue[0] !== "inprogress" ) {
2747				jQuery.dequeue( this, type );
2748			}
2749		});
2750	},
2751	dequeue: function( type ) {
2752		return this.each(function() {
2753			jQuery.dequeue( this, type );
2754		});
2755	},
2756	// Based off of the plugin by Clint Helfers, with permission.
2757	// http://blindsignals.com/index.php/2009/07/jquery-delay/
2758	delay: function( time, type ) {
2759		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
2760		type = type || "fx";
2761
2762		return this.queue( type, function( next, hooks ) {
2763			var timeout = setTimeout( next, time );
2764			hooks.stop = function() {
2765				clearTimeout( timeout );
2766			};
2767		});
2768	},
2769	clearQueue: function( type ) {
2770		return this.queue( type || "fx", [] );
2771	},
2772	// Get a promise resolved when queues of a certain type
2773	// are emptied (fx is the type by default)
2774	promise: function( type, object ) {
2775		if ( typeof type !== "string" ) {
2776			object = type;
2777			type = undefined;
2778		}
2779		type = type || "fx";
2780		var defer = jQuery.Deferred(),
2781			elements = this,
2782			i = elements.length,
2783			count = 1,
2784			deferDataKey = type + "defer",
2785			queueDataKey = type + "queue",
2786			markDataKey = type + "mark",
2787			tmp;
2788		function resolve() {
2789			if ( !( --count ) ) {
2790				defer.resolveWith( elements, [ elements ] );
2791			}
2792		}
2793		while( i-- ) {
2794			if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
2795					( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
2796						jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
2797					jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
2798				count++;
2799				tmp.add( resolve );
2800			}
2801		}
2802		resolve();
2803		return defer.promise();
2804	}
2805});
2806
2807
2808
2809
2810var rclass = /[\n\t\r]/g,
2811	rspace = /\s+/,
2812	rreturn = /\r/g,
2813	rtype = /^(?:button|input)$/i,
2814	rfocusable = /^(?:button|input|object|select|textarea)$/i,
2815	rclickable = /^a(?:rea)?$/i,
2816	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2817	getSetAttribute = jQuery.support.getSetAttribute,
2818	nodeHook, boolHook, fixSpecified;
2819
2820jQuery.fn.extend({
2821	attr: function( name, value ) {
2822		return jQuery.access( this, name, value, true, jQuery.attr );
2823	},
2824
2825	removeAttr: function( name ) {
2826		return this.each(function() {
2827			jQuery.removeAttr( this, name );
2828		});
2829	},
2830
2831	prop: function( name, value ) {
2832		return jQuery.access( this, name, value, true, jQuery.prop );
2833	},
2834
2835	removeProp: function( name ) {
2836		name = jQuery.propFix[ name ] || name;
2837		return this.each(function() {
2838			// try/catch handles cases where IE balks (such as removing a property on window)
2839			try {
2840				this[ name ] = undefined;
2841				delete this[ name ];
2842			} catch( e ) {}
2843		});
2844	},
2845
2846	addClass: function( value ) {
2847		var classNames, i, l, elem,
2848			setClass, c, cl;
2849
2850		if ( jQuery.isFunction( value ) ) {
2851			return this.each(function( j ) {
2852				jQuery( this ).addClass( value.call(this, j, this.className) );
2853			});
2854		}
2855
2856		if ( value && typeof value === "string" ) {
2857			classNames = value.split( rspace );
2858
2859			for ( i = 0, l = this.length; i < l; i++ ) {
2860				elem = this[ i ];
2861
2862				if ( elem.nodeType === 1 ) {
2863					if ( !elem.className && classNames.length === 1 ) {
2864						elem.className = value;
2865
2866					} else {
2867						setClass = " " + elem.className + " ";
2868
2869						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2870							if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2871								setClass += classNames[ c ] + " ";
2872							}
2873						}
2874						elem.className = jQuery.trim( setClass );
2875					}
2876				}
2877			}
2878		}
2879
2880		return this;
2881	},
2882
2883	removeClass: function( value ) {
2884		var classNames, i, l, elem, className, c, cl;
2885
2886		if ( jQuery.isFunction( value ) ) {
2887			return this.each(function( j ) {
2888				jQuery( this ).removeClass( value.call(this, j, this.className) );
2889			});
2890		}
2891
2892		if ( (value && typeof value === "string") || value === undefined ) {
2893			classNames = ( value || "" ).split( rspace );
2894
2895			for ( i = 0, l = this.length; i < l; i++ ) {
2896				elem = this[ i ];
2897
2898				if ( elem.nodeType === 1 && elem.className ) {
2899					if ( value ) {
2900						className = (" " + elem.className + " ").replace( rclass, " " );
2901						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2902							className = className.replace(" " + classNames[ c ] + " ", " ");
2903						}
2904						elem.className = jQuery.trim( className );
2905
2906					} else {
2907						elem.className = "";
2908					}
2909				}
2910			}
2911		}
2912
2913		return this;
2914	},
2915
2916	toggleClass: function( value, stateVal ) {
2917		var type = typeof value,
2918			isBool = typeof stateVal === "boolean";
2919
2920		if ( jQuery.isFunction( value ) ) {
2921			return this.each(function( i ) {
2922				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2923			});
2924		}
2925
2926		return this.each(function() {
2927			if ( type === "string" ) {
2928				// toggle individual class names
2929				var className,
2930					i = 0,
2931					self = jQuery( this ),
2932					state = stateVal,
2933					classNames = value.split( rspace );
2934
2935				while ( (className = classNames[ i++ ]) ) {
2936					// check each className given, space seperated list
2937					state = isBool ? state : !self.hasClass( className );
2938					self[ state ? "addClass" : "removeClass" ]( className );
2939				}
2940
2941			} else if ( type === "undefined" || type === "boolean" ) {
2942				if ( this.className ) {
2943					// store className if set
2944					jQuery._data( this, "__className__", this.className );
2945				}
2946
2947				// toggle whole className
2948				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2949			}
2950		});
2951	},
2952
2953	hasClass: function( selector ) {
2954		var className = " " + selector + " ",
2955			i = 0,
2956			l = this.length;
2957		for ( ; i < l; i++ ) {
2958			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2959				return true;
2960			}
2961		}
2962
2963		return false;