https://diagnosticquestions.com/app/build/vendor-bundle.b202dc83.js

1/*!
2 * jQuery JavaScript Library v2.1.0
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2014-01-23T21:10Z
13 */
14
15(function( global, factory ) {
16
17	if ( typeof module === "object" && typeof module.exports === "object" ) {
18		// For CommonJS and CommonJS-like environments where a proper window is present,
19		// execute the factory and get jQuery
20		// For environments that do not inherently posses a window with a document
21		// (such as Node.js), expose a jQuery-making factory as module.exports
22		// This accentuates the need for the creation of a real window
23		// e.g. var jQuery = require("jquery")(window);
24		// See ticket #14549 for more info
25		module.exports = global.document ?
26			factory( global, true ) :
27			function( w ) {
28				if ( !w.document ) {
29					throw new Error( "jQuery requires a window with a document" );
30				}
31				return factory( w );
32			};
33	} else {
34		factory( global );
35	}
36
37// Pass this if window is not defined yet
38}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
39
40// Can't do this because several apps including ASP.NET trace
41// the stack via arguments.caller.callee and Firefox dies if
42// you try to trace through "use strict" call chains. (#13335)
43// Support: Firefox 18+
44//
45
46var arr = [];
47
48var slice = arr.slice;
49
50var concat = arr.concat;
51
52var push = arr.push;
53
54var indexOf = arr.indexOf;
55
56var class2type = {};
57
58var toString = class2type.toString;
59
60var hasOwn = class2type.hasOwnProperty;
61
62var trim = "".trim;
63
64var support = {};
65
66
67
68var
69	// Use the correct document accordingly with window argument (sandbox)
70	document = window.document,
71
72	version = "2.1.0",
73
74	// Define a local copy of jQuery
75	jQuery = function( selector, context ) {
76		// The jQuery object is actually just the init constructor 'enhanced'
77		// Need init if jQuery is called (just allow error to be thrown if not included)
78		return new jQuery.fn.init( selector, context );
79	},
80
81	// Matches dashed string for camelizing
82	rmsPrefix = /^-ms-/,
83	rdashAlpha = /-([\da-z])/gi,
84
85	// Used by jQuery.camelCase as callback to replace()
86	fcamelCase = function( all, letter ) {
87		return letter.toUpperCase();
88	};
89
90jQuery.fn = jQuery.prototype = {
91	// The current version of jQuery being used
92	jquery: version,
93
94	constructor: jQuery,
95
96	// Start with an empty selector
97	selector: "",
98
99	// The default length of a jQuery object is 0
100	length: 0,
101
102	toArray: function() {
103		return slice.call( this );
104	},
105
106	// Get the Nth element in the matched element set OR
107	// Get the whole matched element set as a clean array
108	get: function( num ) {
109		return num != null ?
110
111			// Return a 'clean' array
112			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
113
114			// Return just the object
115			slice.call( this );
116	},
117
118	// Take an array of elements and push it onto the stack
119	// (returning the new matched element set)
120	pushStack: function( elems ) {
121
122		// Build a new jQuery matched element set
123		var ret = jQuery.merge( this.constructor(), elems );
124
125		// Add the old object onto the stack (as a reference)
126		ret.prevObject = this;
127		ret.context = this.context;
128
129		// Return the newly-formed element set
130		return ret;
131	},
132
133	// Execute a callback for every element in the matched set.
134	// (You can seed the arguments with an array of args, but this is
135	// only used internally.)
136	each: function( callback, args ) {
137		return jQuery.each( this, callback, args );
138	},
139
140	map: function( callback ) {
141		return this.pushStack( jQuery.map(this, function( elem, i ) {
142			return callback.call( elem, i, elem );
143		}));
144	},
145
146	slice: function() {
147		return this.pushStack( slice.apply( this, arguments ) );
148	},
149
150	first: function() {
151		return this.eq( 0 );
152	},
153
154	last: function() {
155		return this.eq( -1 );
156	},
157
158	eq: function( i ) {
159		var len = this.length,
160			j = +i + ( i < 0 ? len : 0 );
161		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
162	},
163
164	end: function() {
165		return this.prevObject || this.constructor(null);
166	},
167
168	// For internal use only.
169	// Behaves like an Array's method, not like a jQuery method.
170	push: push,
171	sort: arr.sort,
172	splice: arr.splice
173};

174
175jQuery.extend = jQuery.fn.extend = function() {
176	var options, name, src, copy, copyIsArray, clone,
177		target = arguments[0] || {},
178		i = 1,
179		length = arguments.length,
180		deep = false;
181
182	// Handle a deep copy situation
183	if ( typeof target === "boolean" ) {
184		deep = target;
185
186		// skip the boolean and the target
187		target = arguments[ i ] || {};
188		i++;
189	}
190
191	// Handle case when target is a string or something (possible in deep copy)
192	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
193		target = {};
194	}
195
196	// extend jQuery itself if only one argument is passed
197	if ( i === length ) {
198		target = this;
199		i--;
200	}
201
202	for ( ; i < length; i++ ) {
203		// Only deal with non-null/undefined values
204		if ( (options = arguments[ i ]) != null ) {
205			// Extend the base object
206			for ( name in options ) {
207				src = target[ name ];
208				copy = options[ name ];
209
210				// Prevent never-ending loop
211				if ( target === copy ) {
212					continue;
213				}
214
215				// Recurse if we're merging plain objects or arrays
216				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
217					if ( copyIsArray ) {
218						copyIsArray = false;
219						clone = src && jQuery.isArray(src) ? src : [];
220
221					} else {
222						clone = src && jQuery.isPlainObject(src) ? src : {};
223					}
224
225					// Never move original objects, clone them
226					target[ name ] = jQuery.extend( deep, clone, copy );
227
228				// Don't bring in undefined values
229				} else if ( copy !== undefined ) {
230					target[ name ] = copy;
231				}
232			}
233		}
234	}
235
236	// Return the modified object
237	return target;
238};
239
240jQuery.extend({
241	// Unique for each copy of jQuery on the page
242	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
243
244	// Assume jQuery is ready without the ready module
245	isReady: true,
246
247	error: function( msg ) {
248		throw new Error( msg );
249	},
250
251	noop: function() {},
252
253	// See test/unit/core.js for details concerning isFunction.
254	// Since version 1.3, DOM methods and functions like alert
255	// aren't supported. They return false on IE (#2968).
256	isFunction: function( obj ) {
257		return jQuery.type(obj) === "function";
258	},
259
260	isArray: Array.isArray,
261
262	isWindow: function( obj ) {
263		return obj != null && obj === obj.window;
264	},
265
266	isNumeric: function( obj ) {
267		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
268		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
269		// subtraction forces infinities to NaN
270		return obj - parseFloat( obj ) >= 0;
271	},
272
273	isPlainObject: function( obj ) {
274		// Not plain objects:
275		// - Any object or value whose internal [[Class]] property is not "[object Object]"
276		// - DOM nodes
277		// - window
278		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
279			return false;
280		}
281
282		// Support: Firefox <20
283		// The try/catch suppresses exceptions thrown when attempting to access
284		// the "constructor" property of certain host objects, ie. |window.location|
285		// https://bugzilla.mozilla.org/show_bug.cgi?id=814622
286		try {
287			if ( obj.constructor &&
288					!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
289				return false;
290			}
291		} catch ( e ) {
292			return false;
293		}
294
295		// If the function hasn't returned already, we're confident that
296		// |obj| is a plain object, created by {} or constructed with new Object
297		return true;
298	},
299
300	isEmptyObject: function( obj ) {
301		var name;
302		for ( name in obj ) {
303			return false;
304		}
305		return true;
306	},
307
308	type: function( obj ) {
309		if ( obj == null ) {
310			return obj + "";
311		}
312		// Support: Android < 4.0, iOS < 6 (functionish RegExp)
313		return typeof obj === "object" || typeof obj === "function" ?
314			class2type[ toString.call(obj) ] || "object" :
315			typeof obj;
316	},
317
318	// Evaluates a script in a global context
319	globalEval: function( code ) {
320		var script,
321			indirect = eval;
322
323		code = jQuery.trim( code );
324
325		if ( code ) {
326			// If the code includes a valid, prologue position
327			// strict mode pragma, execute code by injecting a
328			// script tag into the document.
329			if ( code.indexOf("use strict") === 1 ) {
330				script = document.createElement("script");
331				script.text = code;
332				document.head.appendChild( script ).parentNode.removeChild( script );
333			} else {
334			// Otherwise, avoid the DOM node creation, insertion
335			// and removal by using an indirect global eval
336				indirect( code );
337			}
338		}
339	},
340
341	// Convert dashed to camelCase; used by the css and data modules
342	// Microsoft forgot to hump their vendor prefix (#9572)
343	camelCase: function( string ) {
344		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
345	},
346
347	nodeName: function( elem, name ) {
348		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
349	},
350
351	// args is for internal usage only
352	each: function( obj, callback, args ) {
353		var value,
354			i = 0,
355			length = obj.length,
356			isArray = isArraylike( obj );
357
358		if ( args ) {
359			if ( isArray ) {
360				for ( ; i < length; i++ ) {
361					value = callback.apply( obj[ i ], args );
362
363					if ( value === false ) {
364						break;
365					}
366				}
367			} else {
368				for ( i in obj ) {
369					value = callback.apply( obj[ i ], args );
370
371					if ( value === false ) {
372						break;
373					}
374				}
375			}
376
377		// A special, fast, case for the most common use of each
378		} else {
379			if ( isArray ) {
380				for ( ; i < length; i++ ) {
381					value = callback.call( obj[ i ], i, obj[ i ] );
382
383					if ( value === false ) {
384						break;
385					}
386				}
387			} else {
388				for ( i in obj ) {
389					value = callback.call( obj[ i ], i, obj[ i ] );
390
391					if ( value === false ) {
392						break;
393					}
394				}
395			}
396		}
397
398		return obj;

399	},
400
401	trim: function( text ) {
402		return text == null ? "" : trim.call( text );
403	},
404
405	// results is for internal usage only
406	makeArray: function( arr, results ) {
407		var ret = results || [];
408
409		if ( arr != null ) {
410			if ( isArraylike( Object(arr) ) ) {
411				jQuery.merge( ret,
412					typeof arr === "string" ?
413					[ arr ] : arr
414				);
415			} else {
416				push.call( ret, arr );
417			}
418		}
419
420		return ret;
421	},
422
423	inArray: function( elem, arr, i ) {
424		return arr == null ? -1 : indexOf.call( arr, elem, i );
425	},
426
427	merge: function( first, second ) {
428		var len = +second.length,
429			j = 0,
430			i = first.length;
431
432		for ( ; j < len; j++ ) {
433			first[ i++ ] = second[ j ];
434		}
435
436		first.length = i;
437
438		return first;
439	},
440
441	grep: function( elems, callback, invert ) {
442		var callbackInverse,
443			matches = [],
444			i = 0,
445			length = elems.length,
446			callbackExpect = !invert;
447
448		// Go through the array, only saving the items
449		// that pass the validator function
450		for ( ; i < length; i++ ) {
451			callbackInverse = !callback( elems[ i ], i );
452			if ( callbackInverse !== callbackExpect ) {
453				matches.push( elems[ i ] );
454			}
455		}
456
457		return matches;
458	},
459
460	// arg is for internal usage only
461	map: function( elems, callback, arg ) {
462		var value,
463			i = 0,
464			length = elems.length,
465			isArray = isArraylike( elems ),
466			ret = [];
467
468		// Go through the array, translating each of the items to their new values
469		if ( isArray ) {
470			for ( ; i < length; i++ ) {
471				value = callback( elems[ i ], i, arg );
472
473				if ( value != null ) {
474					ret.push( value );
475				}
476			}
477
478		// Go through every key on the object,
479		} else {
480			for ( i in elems ) {
481				value = callback( elems[ i ], i, arg );
482
483				if ( value != null ) {
484					ret.push( value );
485				}
486			}
487		}
488
489		// Flatten any nested arrays
490		return concat.apply( [], ret );
491	},
492
493	// A global GUID counter for objects
494	guid: 1,
495
496	// Bind a function to a context, optionally partially applying any
497	// arguments.
498	proxy: function( fn, context ) {
499		var tmp, args, proxy;
500
501		if ( typeof context === "string" ) {
502			tmp = fn[ context ];
503			context = fn;
504			fn = tmp;
505		}
506
507		// Quick check to determine if target is callable, in the spec
508		// this throws a TypeError, but we will just return undefined.
509		if ( !jQuery.isFunction( fn ) ) {
510			return undefined;
511		}
512
513		// Simulated bind
514		args = slice.call( arguments, 2 );
515		proxy = function() {
516			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
517		};
518
519		// Set the guid of unique handler to the same of original handler, so it can be removed
520		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
521
522		return proxy;
523	},
524
525	now: Date.now,
526
527	// jQuery.support is not used in Core but other projects attach their
528	// properties to it so it needs to exist.
529	support: support
530});
531
532// Populate the class2type map
533jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
534	class2type[ "[object " + name + "]" ] = name.toLowerCase();
535});
536
537function isArraylike( obj ) {
538	var length = obj.length,
539		type = jQuery.type( obj );
540
541	if ( type === "function" || jQuery.isWindow( obj ) ) {
542		return false;
543	}
544
545	if ( obj.nodeType === 1 && length ) {
546		return true;
547	}
548
549	return type === "array" || length === 0 ||
550		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
551}
552var Sizzle =
553/*!
554 * Sizzle CSS Selector Engine v1.10.16
555 * http://sizzlejs.com/
556 *
557 * Copyright 2013 jQuery Foundation, Inc. and other contributors
558 * Released under the MIT license
559 * http://jquery.org/license
560 *
561 * Date: 2014-01-13
562 */
563(function( window ) {
564
565var i,
566	support,
567	Expr,
568	getText,
569	isXML,
570	compile,
571	outermostContext,
572	sortInput,
573	hasDuplicate,
574
575	// Local document vars
576	setDocument,
577	document,
578	docElem,
579	documentIsHTML,
580	rbuggyQSA,
581	rbuggyMatches,
582	matches,
583	contains,
584
585	// Instance-specific data
586	expando = "sizzle" + -(new Date()),
587	preferredDoc = window.document,
588	dirruns = 0,
589	done = 0,
590	classCache = createCache(),
591	tokenCache = createCache(),
592	compilerCache = createCache(),
593	sortOrder = function( a, b ) {
594		if ( a === b ) {
595			hasDuplicate = true;
596		}
597		return 0;
598	},
599
600	// General-purpose constants
601	strundefined = typeof undefined,
602	MAX_NEGATIVE = 1 << 31,
603
604	// Instance methods
605	hasOwn = ({}).hasOwnProperty,
606	arr = [],
607	pop = arr.pop,
608	push_native = arr.push,
609	push = arr.push,
610	slice = arr.slice,
611	// Use a stripped-down indexOf if we can't use a native one
612	indexOf = arr.indexOf || function( elem ) {
613		var i = 0,
614			len = this.length;
615		for ( ; i < len; i++ ) {
616			if ( this[i] === elem ) {
617				return i;
618			}
619		}
620		return -1;
621	},
622
623	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
624
625	// Regular expressions
626
627	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
628	whitespace = "[\\x20\\t\\r\\n\\f]",
629	// http://www.w3.org/TR/css3-syntax/#characters
630	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
631
632	// Loosely modeled on CSS identifier characters
633	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
634	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
635	identifier = characterEncoding.replace( "w", "w#" ),
636
637	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
638	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
639		"*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
640
641	// Prefer arguments quoted,
642	//   then not containing pseudos/brackets,
643	//   then attribute selectors/non-parenthetical expressions,
644	//   then anything else
645	// These preferences are here to reduce the number of selectors
646	//   needing tokenize in the PSEUDO preFilter
647	pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",
648
649	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
650	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
651
652	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
653	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
654
655	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
656
657	rpseudo = new RegExp( pseudos ),
658	ridentifier = new RegExp( "^" + identifier + "$" ),
659
660	matchExpr = {
661		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
662		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
663		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
664		"ATTR": new RegExp( "^" + attributes ),
665		"PSEUDO": new RegExp( "^" + pseudos ),
666		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
667			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
668			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
669		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
670		// For use in libraries implementing .is()
671		// We use this for POS matching in `select`
672		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
673			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
674	},
675
676	rinputs = /^(?:input|select|textarea|button)$/i,
677	rheader = /^h\d$/i,
678
679	rnative = /^[^{]+\{\s*\[native \w/,
680
681	// Easily-parseable/retrievable ID or TAG or CLASS selectors
682	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
683
684	rsibling = /[+~]/,
685	rescape = /'|\\/g,
686
687	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
688	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
689	funescape = function( _, escaped, escapedWhitespace ) {
690		var high = "0x" + escaped - 0x10000;
691		// NaN means non-codepoint
692		// Support: Firefox
693		// Workaround erroneous numeric interpretation of +"0x"
694		return high !== high || escapedWhitespace ?
695			escaped :
696			high < 0 ?
697				// BMP codepoint
698				String.fromCharCode( high + 0x10000 ) :
699				// Supplemental Plane codepoint (surrogate pair)
700				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
701	};
702
703// Optimize for push.apply( _, NodeList )
704try {
705	push.apply(
706		(arr = slice.call( preferredDoc.childNodes )),
707		preferredDoc.childNodes
708	);
709	// Support: Android<4.0
710	// Detect silently failing push.apply
711	arr[ preferredDoc.childNodes.length ].nodeType;
712} catch ( e ) {
713	push = { apply: arr.length ?
714
715		// Leverage slice if possible
716		function( target, els ) {
717			push_native.apply( target, slice.call(els) );
718		} :
719
720		// Support: IE<9
721		// Otherwise append directly
722		function( target, els ) {
723			var j = target.length,
724				i = 0;
725			// Can't trust NodeList.length
726			while ( (target[j++] = els[i++]) ) {}
727			target.length = j - 1;
728		}
729	};
730}
731
732function Sizzle( selector, context, results, seed ) {
733	var match, elem, m, nodeType,
734		// QSA vars
735		i, groups, old, nid, newContext, newSelector;
736
737	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
738		setDocument( context );
739	}
740
741	context = context || document;
742	results = results || [];
743
744	if ( !selector || typeof selector !== "string" ) {
745		return results;
746	}
747
748	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
749		return [];
750	}
751
752	if ( documentIsHTML && !seed ) {
753
754		// Shortcuts
755		if ( (match = rquickExpr.exec( selector )) ) {
756			// Speed-up: Sizzle("#ID")
757			if ( (m = match[1]) ) {
758				if ( nodeType === 9 ) {
759					elem = context.getElementById( m );
760					// Check parentNode to catch when Blackberry 4.6 returns
761					// nodes that are no longer in the document (jQuery #6963)
762					if ( elem && elem.parentNode ) {
763						// Handle the case where IE, Opera, and Webkit return items
764						// by name instead of ID
765						if ( elem.id === m ) {
766							results.push( elem );
767							return results;
768						}
769					} else {
770						return results;
771					}
772				} else {
773					// Context is not a document
774					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
775						contains( context, elem ) && elem.id === m ) {
776						results.push( elem );
777						return results;
778					}
779				}
780
781			// Speed-up: Sizzle("TAG")
782			} else if ( match[2] ) {
783				push.apply( results, context.getElementsByTagName( selector ) );
784				return results;
785
786			// Speed-up: Sizzle(".CLASS")
787			} else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {
788				push.apply( results, context.getElementsByClassName( m ) );
789				return results;
790			}
791		}
792
793		// QSA path
794		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
795			nid = old = expando;
796			newContext = context;
797			newSelector = nodeType === 9 && selector;
798
799			// qSA works strangely on Element-rooted queries
800			// We can work around this by specifying an extra ID on the root
801			// and working up from there (Thanks to Andrew Dupont for the technique)
802			// IE 8 doesn't work on object elements
803			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
804				groups = tokenize( selector );
805
806				if ( (old = context.getAttribute("id")) ) {
807					nid = old.replace( rescape, "\\$&" );
808				} else {
809					context.setAttribute( "id", nid );
810				}
811				nid = "[id='" + nid + "'] ";
812
813				i = groups.length;
814				while ( i-- ) {
815					groups[i] = nid + toSelector( groups[i] );
816				}
817				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
818				newSelector = groups.join(",");
819			}
820
821			if ( newSelector ) {
822				try {
823					push.apply( results,
824						newContext.querySelectorAll( newSelector )
825					);
826					return results;
827				} catch(qsaError) {
828				} finally {
829					if ( !old ) {
830						context.removeAttribute("id");
831					}
832				}
833			}
834		}
835	}
836
837	// All others
838	return select( selector.replace( rtrim, "$1" ), context, results, seed );
839}
840
841/**
842 * Create key-value caches of limited size
843 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
844 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
845 *	deleting the oldest entry
846 */
847function createCache() {
848	var keys = [];
849
850	function cache( key, value ) {
851		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
852		if ( keys.push( key + " " ) > Expr.cacheLength ) {
853			// Only keep the most recent entries
854			delete cache[ keys.shift() ];
855		}
856		return (cache[ key + " " ] = value);
857	}
858	return cache;
859}
860
861/**
862 * Mark a function for special use by Sizzle
863 * @param {Function} fn The function to mark
864 */
865function markFunction( fn ) {
866	fn[ expando ] = true;
867	return fn;
868}
869
870/**
871 * Support testing using an element
872 * @param {Function} fn Passed the created div and expects a boolean result
873 */
874function assert( fn ) {
875	var div = document.createElement("div");
876
877	try {
878		return !!fn( div );
879	} catch (e) {
880		return false;
881	} finally {
882		// Remove from its parent by default
883		if ( div.parentNode ) {
884			div.parentNode.removeChild( div );
885		}
886		// release memory in IE
887		div = null;
888	}
889}
890
891/**
892 * Adds the same handler for all of the specified attrs
893 * @param {String} attrs Pipe-separated list of attributes
894 * @param {Function} handler The method that will be applied
895 */
896function addHandle( attrs, handler ) {
897	var arr = attrs.split("|"),
898		i = attrs.length;
899
900	while ( i-- ) {
901		Expr.attrHandle[ arr[i] ] = handler;
902	}
903}
904
905/**
906 * Checks document order of two siblings
907 * @param {Element} a
908 * @param {Element} b
909 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
910 */
911function siblingCheck( a, b ) {
912	var cur = b && a,
913		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
914			( ~b.sourceIndex || MAX_NEGATIVE ) -
915			( ~a.sourceIndex || MAX_NEGATIVE );
916
917	// Use IE sourceIndex if available on both nodes
918	if ( diff ) {
919		return diff;
920	}
921
922	// Check if b follows a
923	if ( cur ) {
924		while ( (cur = cur.nextSibling) ) {
925			if ( cur === b ) {
926				return -1;
927			}
928		}
929	}
930
931	return a ? 1 : -1;
932}
933
934/**
935 * Returns a function to use in pseudos for input types
936 * @param {String} type
937 */
938function createInputPseudo( type ) {
939	return function( elem ) {
940		var name = elem.nodeName.toLowerCase();
941		return name === "input" && elem.type === type;
942	};
943}
944
945/**
946 * Returns a function to use in pseudos for buttons
947 * @param {String} type
948 */
949function createButtonPseudo( type ) {
950	return function( elem ) {
951		var name = elem.nodeName.toLowerCase();
952		return (name === "input" || name === "button") && elem.type === type;
953	};
954}
955
956/**
957 * Returns a function to use in pseudos for positionals
958 * @param {Function} fn
959 */
960function createPositionalPseudo( fn ) {
961	return markFunction(function( argument ) {
962		argument = +argument;
963		return markFunction(function( seed, matches ) {
964			var j,
965				matchIndexes = fn( [], seed.length, argument ),
966				i = matchIndexes.length;
967
968			// Match elements found at the specified indexes
969			while ( i-- ) {
970				if ( seed[ (j = matchIndexes[i]) ] ) {
971					seed[j] = !(matches[j] = seed[j]);
972				}
973			}
974		});
975	});
976}
977
978/**
979 * Checks a node for validity as a Sizzle context
980 * @param {Element|Object=} context
981 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
982 */
983function testContext( context ) {
984	return context && typeof context.getElementsByTagName !== strundefined && context;
985}
986
987// Expose support vars for convenience
988support = Sizzle.support = {};
989
990/**
991 * Detects XML nodes
992 * @param {Element|Object} elem An element or a document
993 * @returns {Boolean} True iff elem is a non-HTML XML node
994 */
995isXML = Sizzle.isXML = function( elem ) {
996	// documentElement is verified for cases where it doesn't yet exist
997	// (such as loading iframes in IE - #4833)
998	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
999	return documentElement ? documentElement.nodeName !== "HTML" : false;
1000};
1001
1002/**
1003 * Sets document-related variables once based on the current document
1004 * @param {Element|Object} [doc] An element or document object to use to set the document
1005 * @returns {Object} Returns the current document
1006 */
1007setDocument = Sizzle.setDocument = function( node ) {
1008	var hasCompare,
1009		doc = node ? node.ownerDocument || node : preferredDoc,
1010		parent = doc.defaultView;
1011
1012	// If no document and documentElement is available, return
1013	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1014		return document;
1015	}
1016
1017	// Set our document
1018	document = doc;
1019	docElem = doc.documentElement;
1020
1021	// Support tests
1022	documentIsHTML = !isXML( doc );
1023
1024	// Support: IE>8
1025	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
1026	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1027	// IE6-8 do not support the defaultView property so parent will be undefined
1028	if ( parent && parent !== parent.top ) {
1029		// IE11 does not have attachEvent, so all must suffer
1030		if ( parent.addEventListener ) {
1031			parent.addEventListener( "unload", function() {
1032				setDocument();
1033			}, false );
1034		} else if ( parent.attachEvent ) {
1035			parent.attachEvent( "onunload", function() {
1036				setDocument();
1037			});
1038		}
1039	}
1040
1041	/* Attributes
1042	---------------------------------------------------------------------- */
1043
1044	// Support: IE<8
1045	// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
1046	support.attributes = assert(function( div ) {
1047		div.className = "i";
1048		return !div.getAttribute("className");
1049	});
1050
1051	/* getElement(s)By*
1052	---------------------------------------------------------------------- */
1053
1054	// Check if getElementsByTagName("*") returns only elements
1055	support.getElementsByTagName = assert(function( div ) {
1056		div.appendChild( doc.createComment("") );
1057		return !div.getElementsByTagName("*").length;
1058	});
1059
1060	// Check if getElementsByClassName can be trusted
1061	support.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) {
1062		div.innerHTML = "<div class='a'></div><div class='a i'></div>";
1063
1064		// Support: Safari<4
1065		// Catch class over-caching
1066		div.firstChild.className = "i";
1067		// Support: Opera<10
1068		// Catch gEBCN failure to find non-leading classes
1069		return div.getElementsByClassName("i").length === 2;
1070	});
1071
1072	// Support: IE<10
1073	// Check if getElementById returns elements by name
1074	// The broken getElementById methods don't pick up programatically-set names,
1075	// so use a roundabout getElementsByName test
1076	support.getById = assert(function( div ) {
1077		docElem.appendChild( div ).id = expando;
1078		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
1079	});
1080
1081	// ID find and filter
1082	if ( support.getById ) {
1083		Expr.find["ID"] = function( id, context ) {
1084			if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
1085				var m = context.getElementById( id );
1086				// Check parentNode to catch when Blackberry 4.6 returns
1087				// nodes that are no longer in the document #6963
1088				return m && m.parentNode ? [m] : [];
1089			}
1090		};
1091		Expr.filter["ID"] = function( id ) {
1092			var attrId = id.replace( runescape, funescape );
1093			return function( elem ) {
1094				return elem.getAttribute("id") === attrId;
1095			};
1096		};
1097	} else {
1098		// Support: IE6/7
1099		// getElementById is not reliable as a find shortcut
1100		delete Expr.find["ID"];
1101
1102		Expr.filter["ID"] =  function( id ) {
1103			var attrId = id.replace( runescape, funescape );
1104			return function( elem ) {
1105				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1106				return node && node.value === attrId;
1107			};
1108		};
1109	}
1110
1111	// Tag
1112	Expr.find["TAG"] = support.getElementsByTagName ?
1113		function( tag, context ) {
1114			if ( typeof context.getElementsByTagName !== strundefined ) {
1115				return context.getElementsByTagName( tag );
1116			}
1117		} :
1118		function( tag, context ) {
1119			var elem,
1120				tmp = [],
1121				i = 0,
1122				results = context.getElementsByTagName( tag );
1123
1124			// Filter out possible comments
1125			if ( tag === "*" ) {
1126				while ( (elem = results[i++]) ) {
1127					if ( elem.nodeType === 1 ) {
1128						tmp.push( elem );
1129					}
1130				}
1131
1132				return tmp;
1133			}
1134			return results;
1135		};
1136
1137	// Class
1138	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1139		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1140			return context.getElementsByClassName( className );
1141		}
1142	};
1143
1144	/* QSA/matchesSelector
1145	---------------------------------------------------------------------- */
1146
1147	// QSA and matchesSelector support
1148
1149	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1150	rbuggyMatches = [];
1151
1152	// qSa(:focus) reports false when true (Chrome 21)
1153	// We allow this because of a bug in IE8/9 that throws an error
1154	// whenever `document.activeElement` is accessed on an iframe
1155	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1156	// See http://bugs.jquery.com/ticket/13378
1157	rbuggyQSA = [];
1158
1159	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1160		// Build QSA regex
1161		// Regex strategy adopted from Diego Perini
1162		assert(function( div ) {
1163			// Select is set to empty string on purpose
1164			// This is to test IE's treatment of not explicitly
1165			// setting a boolean content attribute,
1166			// since its presence should be enough
1167			// http://bugs.jquery.com/ticket/12359
1168			div.innerHTML = "<select t=''><option selected=''></option></select>";
1169
1170			// Support: IE8, Opera 10-12
1171			// Nothing should be selected when empty strings follow ^= or $= or *=
1172			if ( div.querySelectorAll("[t^='']").length ) {
1173				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1174			}
1175
1176			// Support: IE8
1177			// Boolean attributes and "value" are not treated correctly
1178			if ( !div.querySelectorAll("[selected]").length ) {
1179				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1180			}
1181
1182			// Webkit/Opera - :checked should return selected option elements
1183			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1184			// IE8 throws error here and will not see later tests
1185			if ( !div.querySelectorAll(":checked").length ) {
1186				rbuggyQSA.push(":checked");
1187			}
1188		});
1189
1190		assert(function( div ) {
1191			// Support: Windows 8 Native Apps
1192			// The type and name attributes are restricted during .innerHTML assignment
1193			var input = doc.createElement("input");
1194			input.setAttribute( "type", "hidden" );
1195			div.appendChild( input ).setAttribute( "name", "D" );
1196
1197			// Support: IE8
1198			// Enforce case-sensitivity of name attribute
1199			if ( div.querySelectorAll("[name=d]").length ) {
1200				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1201			}
1202
1203			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1204			// IE8 throws error here and will not see later tests
1205			if ( !div.querySelectorAll(":enabled").length ) {
1206				rbuggyQSA.push( ":enabled", ":disabled" );
1207			}
1208
1209			// Opera 10-11 does not throw on post-comma invalid pseudos
1210			div.querySelectorAll("*,:x");
1211			rbuggyQSA.push(",.*:");
1212		});
1213	}
1214
1215	if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
1216		docElem.mozMatchesSelector ||
1217		docElem.oMatchesSelector ||
1218		docElem.msMatchesSelector) )) ) {
1219
1220		assert(function( div ) {
1221			// Check to see if it's possible to do matchesSelector
1222			// on a disconnected node (IE 9)
1223			support.disconnectedMatch = matches.call( div, "div" );
1224
1225			// This should fail with an exception
1226			// Gecko does not error, returns false instead
1227			matches.call( div, "[s!='']:x" );
1228			rbuggyMatches.push( "!=", pseudos );
1229		});
1230	}
1231
1232	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1233	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1234
1235	/* Contains
1236	---------------------------------------------------------------------- */
1237	hasCompare = rnative.test( docElem.compareDocumentPosition );
1238
1239	// Element contains another
1240	// Purposefully does not implement inclusive descendent
1241	// As in, an element does not contain itself
1242	contains = hasCompare || rnative.test( docElem.contains ) ?
1243		function( a, b ) {
1244			var adown = a.nodeType === 9 ? a.documentElement : a,
1245				bup = b && b.parentNode;
1246			return a === bup || !!( bup && bup.nodeType === 1 && (
1247				adown.contains ?
1248					adown.contains( bup ) :
1249					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1250			));
1251		} :
1252		function( a, b ) {
1253			if ( b ) {
1254				while ( (b = b.parentNode) ) {
1255					if ( b === a ) {
1256						return true;
1257					}
1258				}
1259			}
1260			return false;
1261		};
1262
1263	/* Sorting
1264	---------------------------------------------------------------------- */
1265
1266	// Document order sorting
1267	sortOrder = hasCompare ?
1268	function( a, b ) {
1269
1270		// Flag for duplicate removal
1271		if ( a === b ) {
1272			hasDuplicate = true;
1273			return 0;
1274		}
1275
1276		// Sort on method existence if only one input has compareDocumentPosition
1277		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1278		if ( compare ) {
1279			return compare;
1280		}
1281
1282		// Calculate position if both inputs belong to the same document
1283		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1284			a.compareDocumentPosition( b ) :
1285
1286			// Otherwise we know they are disconnected
1287			1;
1288
1289		// Disconnected nodes
1290		if ( compare & 1 ||
1291			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1292
1293			// Choose the first element that is related to our preferred document
1294			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1295				return -1;
1296			}
1297			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1298				return 1;
1299			}
1300
1301			// Maintain original order
1302			return sortInput ?
1303				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1304				0;
1305		}
1306
1307		return compare & 4 ? -1 : 1;
1308	} :
1309	function( a, b ) {
1310		// Exit early if the nodes are identical
1311		if ( a === b ) {
1312			hasDuplicate = true;
1313			return 0;
1314		}
1315
1316		var cur,
1317			i = 0,
1318			aup = a.parentNode,
1319			bup = b.parentNode,
1320			ap = [ a ],
1321			bp = [ b ];
1322
1323		// Parentless nodes are either documents or disconnected
1324		if ( !aup || !bup ) {
1325			return a === doc ? -1 :
1326				b === doc ? 1 :
1327				aup ? -1 :
1328				bup ? 1 :
1329				sortInput ?
1330				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1331				0;
1332
1333		// If the nodes are siblings, we can do a quick check
1334		} else if ( aup === bup ) {
1335			return siblingCheck( a, b );
1336		}
1337
1338		// Otherwise we need full lists of their ancestors for comparison
1339		cur = a;
1340		while ( (cur = cur.parentNode) ) {
1341			ap.unshift( cur );
1342		}
1343		cur = b;
1344		while ( (cur = cur.parentNode) ) {
1345			bp.unshift( cur );
1346		}
1347
1348		// Walk down the tree looking for a discrepancy
1349		while ( ap[i] === bp[i] ) {
1350			i++;
1351		}
1352
1353		return i ?
1354			// Do a sibling check if the nodes have a common ancestor
1355			siblingCheck( ap[i], bp[i] ) :
1356
1357			// Otherwise nodes in our document sort first
1358			ap[i] === preferredDoc ? -1 :
1359			bp[i] === preferredDoc ? 1 :
1360			0;
1361	};
1362
1363	return doc;
1364};
1365
1366Sizzle.matches = function( expr, elements ) {
1367	return Sizzle( expr, null, null, elements );
1368};
1369
1370Sizzle.matchesSelector = function( elem, expr ) {
1371	// Set document vars if needed
1372	if ( ( elem.ownerDocument || elem ) !== document ) {
1373		setDocument( elem );
1374	}
1375
1376	// Make sure that attribute selectors are quoted
1377	expr = expr.replace( rattributeQuotes, "='$1']" );
1378
1379	if ( support.matchesSelector && documentIsHTML &&
1380		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1381		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1382
1383		try {
1384			var ret = matches.call( elem, expr );
1385
1386			// IE 9's matchesSelector returns false on disconnected nodes
1387			if ( ret || support.disconnectedMatch ||
1388					// As well, disconnected nodes are said to be in a document
1389					// fragment in IE 9
1390					elem.document && elem.document.nodeType !== 11 ) {
1391				return ret;
1392			}
1393		} catch(e) {}
1394	}
1395
1396	return Sizzle( expr, document, null, [elem] ).length > 0;
1397};
1398
1399Sizzle.contains = function( context, elem ) {
1400	// Set document vars if needed
1401	if ( ( context.ownerDocument || context ) !== document ) {
1402		setDocument( context );
1403	}
1404	return contains( context, elem );
1405};
1406
1407Sizzle.attr = function( elem, name ) {
1408	// Set document vars if needed
1409	if ( ( elem.ownerDocument || elem ) !== document ) {
1410		setDocument( elem );
1411	}
1412
1413	var fn = Expr.attrHandle[ name.toLowerCase() ],
1414		// Don't get fooled by Object.prototype properties (jQuery #13807)
1415		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1416			fn( elem, name, !documentIsHTML ) :
1417			undefined;
1418
1419	return val !== undefined ?
1420		val :
1421		support.attributes || !documentIsHTML ?
1422			elem.getAttribute( name ) :
1423			(val = elem.getAttributeNode(name)) && val.specified ?
1424				val.value :
1425				null;
1426};
1427
1428Sizzle.error = function( msg ) {
1429	throw new Error( "Syntax error, unrecognized expression: " + msg );
1430};
1431
1432/**
1433 * Document sorting and removing duplicates
1434 * @param {ArrayLike} results
1435 */
1436Sizzle.uniqueSort = function( results ) {
1437	var elem,
1438		duplicates = [],
1439		j = 0,
1440		i = 0;
1441
1442	// Unless we *know* we can detect duplicates, assume their presence
1443	hasDuplicate = !support.detectDuplicates;
1444	sortInput = !support.sortStable && results.slice( 0 );
1445	results.sort( sortOrder );
1446
1447	if ( hasDuplicate ) {
1448		while ( (elem = results[i++]) ) {
1449			if ( elem === results[ i ] ) {
1450				j = duplicates.push( i );
1451			}
1452		}
1453		while ( j-- ) {
1454			results.splice( duplicates[ j ], 1 );
1455		}
1456	}
1457
1458	// Clear input after sorting to release objects
1459	// See https://github.com/jquery/sizzle/pull/225
1460	sortInput = null;
1461
1462	return results;
1463};
1464
1465/**
1466 * Utility function for retrieving the text value of an array of DOM nodes
1467 * @param {Array|Element} elem
1468 */
1469getText = Sizzle.getText = function( elem ) {
1470	var node,
1471		ret = "",
1472		i = 0,
1473		nodeType = elem.nodeType;
1474
1475	if ( !nodeType ) {
1476		// If no nodeType, this is expected to be an array
1477		while ( (node = elem[i++]) ) {
1478			// Do not traverse comment nodes
1479			ret += getText( node );
1480		}
1481	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1482		// Use textContent for elements
1483		// innerText usage removed for consistency of new lines (jQuery #11153)
1484		if ( typeof elem.textContent === "string" ) {
1485			return elem.textContent;
1486		} else {
1487			// Traverse its children
1488			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1489				ret += getText( elem );
1490			}
1491		}
1492	} else if ( nodeType === 3 || nodeType === 4 ) {
1493		return elem.nodeValue;
1494	}
1495	// Do not include comment or processing instruction nodes
1496
1497	return ret;
1498};
1499
1500Expr = Sizzle.selectors = {
1501
1502	// Can be adjusted by the user
1503	cacheLength: 50,
1504
1505	createPseudo: markFunction,
1506
1507	match: matchExpr,
1508
1509	attrHandle: {},
1510
1511	find: {},
1512
1513	relative: {
1514		">": { dir: "parentNode", first: true },
1515		" ": { dir: "parentNode" },
1516		"+": { dir: "previousSibling", first: true },
1517		"~": { dir: "previousSibling" }
1518	},
1519
1520	preFilter: {
1521		"ATTR": function( match ) {
1522			match[1] = match[1].replace( runescape, funescape );
1523
1524			// Move the given value to match[3] whether quoted or unquoted
1525			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
1526
1527			if ( match[2] === "~=" ) {
1528				match[3] = " " + match[3] + " ";
1529			}
1530
1531			return match.slice( 0, 4 );
1532		},
1533
1534		"CHILD": function( match ) {
1535			/* matches from matchExpr["CHILD"]
1536				1 type (only|nth|...)
1537				2 what (child|of-type)
1538				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1539				4 xn-component of xn+y argument ([+-]?\d*n|)
1540				5 sign of xn-component
1541				6 x of xn-component
1542				7 sign of y-component
1543				8 y of y-component
1544			*/
1545			match[1] = match[1].toLowerCase();
1546
1547			if ( match[1].slice( 0, 3 ) === "nth" ) {
1548				// nth-* requires argument
1549				if ( !match[3] ) {
1550					Sizzle.error( match[0] );
1551				}
1552
1553				// numeric x and y parameters for Expr.filter.CHILD
1554				// remember that false/true cast respectively to 0/1
1555				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1556				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1557
1558			// other types prohibit arguments
1559			} else if ( match[3] ) {
1560				Sizzle.error( match[0] );
1561			}
1562
1563			return match;
1564		},
1565
1566		"PSEUDO": function( match ) {
1567			var excess,
1568				unquoted = !match[5] && match[2];
1569
1570			if ( matchExpr["CHILD"].test( match[0] ) ) {
1571				return null;
1572			}
1573
1574			// Accept quoted arguments as-is
1575			if ( match[3] && match[4] !== undefined ) {
1576				match[2] = match[4];
1577
1578			// Strip excess characters from unquoted arguments
1579			} else if ( unquoted && rpseudo.test( unquoted ) &&
1580				// Get excess from tokenize (recursively)
1581				(excess = tokenize( unquoted, true )) &&
1582				// advance to the next closing parenthesis
1583				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1584
1585				// excess is a negative index
1586				match[0] = match[0].slice( 0, excess );
1587				match[2] = unquoted.slice( 0, excess );
1588			}
1589
1590			// Return only captures needed by the pseudo filter method (type and argument)
1591			return match.slice( 0, 3 );
1592		}
1593	},
1594
1595	filter: {
1596
1597		"TAG": function( nodeNameSelector ) {
1598			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1599			return nodeNameSelector === "*" ?
1600				function() { return true; } :
1601				function( elem ) {
1602					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1603				};
1604		},
1605
1606		"CLASS": function( className ) {
1607			var pattern = classCache[ className + " " ];
1608
1609			return pattern ||
1610				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1611				classCache( className, function( elem ) {
1612					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
1613				});
1614		},
1615
1616		"ATTR": function( name, operator, check ) {
1617			return function( elem ) {
1618				var result = Sizzle.attr( elem, name );
1619
1620				if ( result == null ) {
1621					return operator === "!=";
1622				}
1623				if ( !operator ) {
1624					return true;
1625				}
1626
1627				result += "";
1628
1629				return operator === "=" ? result === check :
1630					operator === "!=" ? result !== check :
1631					operator === "^=" ? check && result.indexOf( check ) === 0 :
1632					operator === "*=" ? check && result.indexOf( check ) > -1 :
1633					operator === "$=" ? check && result.slice( -check.length ) === check :
1634					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
1635					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1636					false;
1637			};
1638		},
1639
1640		"CHILD": function( type, what, argument, first, last ) {
1641			var simple = type.slice( 0, 3 ) !== "nth",
1642				forward = type.slice( -4 ) !== "last",
1643				ofType = what === "of-type";
1644
1645			return first === 1 && last === 0 ?
1646
1647				// Shortcut for :nth-*(n)
1648				function( elem ) {
1649					return !!elem.parentNode;
1650				} :
1651
1652				function( elem, context, xml ) {
1653					var cache, outerCache, node, diff, nodeIndex, start,
1654						dir = simple !== forward ? "nextSibling" : "previousSibling",
1655						parent = elem.parentNode,
1656						name = ofType && elem.nodeName.toLowerCase(),
1657						useCache = !xml && !ofType;
1658
1659					if ( parent ) {
1660
1661						// :(first|last|only)-(child|of-type)
1662						if ( simple ) {
1663							while ( dir ) {
1664								node = elem;
1665								while ( (node = node[ dir ]) ) {
1666									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
1667										return false;
1668									}
1669								}
1670								// Reverse direction for :only-* (if we haven't yet done so)
1671								start = dir = type === "only" && !start && "nextSibling";
1672							}
1673							return true;
1674						}
1675
1676						start = [ forward ? parent.firstChild : parent.lastChild ];
1677
1678						// non-xml :nth-child(...) stores cache data on `parent`
1679						if ( forward && useCache ) {
1680							// Seek `elem` from a previously-cached index
1681							outerCache = parent[ expando ] || (parent[ expando ] = {});
1682							cache = outerCache[ type ] || [];
1683							nodeIndex = cache[0] === dirruns && cache[1];
1684							diff = cache[0] === dirruns && cache[2];
1685							node = nodeIndex && parent.childNodes[ nodeIndex ];
1686
1687							while ( (node = ++nodeIndex && node && node[ dir ] ||
1688
1689								// Fallback to seeking `elem` from the start
1690								(diff = nodeIndex = 0) || start.pop()) ) {
1691
1692								// When found, cache indexes on `parent` and break
1693								if ( node.nodeType === 1 && ++diff && node === elem ) {
1694									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1695									break;
1696								}
1697							}
1698
1699						// Use previously-cached element index if available
1700						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
1701							diff = cache[1];
1702
1703						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
1704						} else {
1705							// Use the same loop as above to seek `elem` from the start
1706							while ( (node = ++nodeIndex && node && node[ dir ] ||
1707								(diff = nodeIndex = 0) || start.pop()) ) {
1708
1709								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
1710									// Cache the index of each encountered element
1711									if ( useCache ) {
1712										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
1713									}
1714
1715									if ( node === elem ) {
1716										break;
1717									}
1718								}
1719							}
1720						}
1721
1722						// Incorporate the offset, then check against cycle size
1723						diff -= last;
1724						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1725					}
1726				};
1727		},
1728
1729		"PSEUDO": function( pseudo, argument ) {
1730			// pseudo-class names are case-insensitive
1731			// http://www.w3.org/TR/selectors/#pseudo-classes
1732			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1733			// Remember that setFilters inherits from pseudos
1734			var args,
1735				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1736					Sizzle.error( "unsupported pseudo: " + pseudo );
1737
1738			// The user may use createPseudo to indicate that
1739			// arguments are needed to create the filter function
1740			// just as Sizzle does
1741			if ( fn[ expando ] ) {
1742				return fn( argument );
1743			}
1744
1745			// But maintain support for old signatures
1746			if ( fn.length > 1 ) {
1747				args = [ pseudo, pseudo, "", argument ];
1748				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1749					markFunction(function( seed, matches ) {
1750						var idx,
1751							matched = fn( seed, argument ),
1752							i = matched.length;
1753						while ( i-- ) {
1754							idx = indexOf.call( seed, matched[i] );
1755							seed[ idx ] = !( matches[ idx ] = matched[i] );
1756						}
1757					}) :
1758					function( elem ) {
1759						return fn( elem, 0, args );
1760					};
1761			}
1762
1763			return fn;
1764		}
1765	},
1766
1767	pseudos: {
1768		// Potentially complex pseudos
1769		"not": markFunction(function( selector ) {
1770			// Trim the selector passed to compile
1771			// to avoid treating leading and trailing
1772			// spaces as combinators
1773			var input = [],
1774				results = [],
1775				matcher = compile( selector.replace( rtrim, "$1" ) );
1776
1777			return matcher[ expando ] ?
1778				markFunction(function( seed, matches, context, xml ) {
1779					var elem,
1780						unmatched = matcher( seed, null, xml, [] ),
1781						i = seed.length;
1782
1783					// Match elements unmatched by `matcher`
1784					while ( i-- ) {
1785						if ( (elem = unmatched[i]) ) {
1786							seed[i] = !(matches[i] = elem);
1787						}
1788					}
1789				}) :
1790				function( elem, context, xml ) {
1791					input[0] = elem;
1792					matcher( input, null, xml, results );
1793					return !results.pop();
1794				};
1795		}),
1796
1797		"has": markFunction(function( selector ) {
1798			return function( elem ) {
1799				return Sizzle( selector, elem ).length > 0;
1800			};
1801		}),
1802
1803		"contains": markFunction(function( text ) {
1804			return function( elem ) {
1805				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1806			};
1807		}),
1808
1809		// "Whether an element is represented by a :lang() selector
1810		// is based solely on the element's language value
1811		// being equal to the identifier C,
1812		// or beginning with the identifier C immediately followed by "-".
1813		// The matching of C against the element's language value is performed case-insensitively.
1814		// The identifier C does not have to be a valid language name."
1815		// http://www.w3.org/TR/selectors/#lang-pseudo
1816		"lang": markFunction( function( lang ) {
1817			// lang value must be a valid identifier
1818			if ( !ridentifier.test(lang || "") ) {
1819				Sizzle.error( "unsupported lang: " + lang );
1820			}
1821			lang = lang.replace( runescape, funescape ).toLowerCase();
1822			return function( elem ) {
1823				var elemLang;
1824				do {
1825					if ( (elemLang = documentIsHTML ?
1826						elem.lang :
1827						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
1828
1829						elemLang = elemLang.toLowerCase();
1830						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1831					}
1832				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
1833				return false;
1834			};
1835		}),
1836
1837		// Miscellaneous
1838		"target": function( elem ) {
1839			var hash = window.location && window.location.hash;
1840			return hash && hash.slice( 1 ) === elem.id;
1841		},
1842
1843		"root": function( elem ) {
1844			return elem === docElem;
1845		},
1846
1847		"focus": function( elem ) {
1848			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1849		},
1850
1851		// Boolean properties
1852		"enabled": function( elem ) {
1853			return elem.disabled === false;
1854		},
1855
1856		"disabled": function( elem ) {
1857			return elem.disabled === true;
1858		},
1859
1860		"checked": function( elem ) {
1861			// In CSS3, :checked should return both checked and selected elements
1862			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1863			var nodeName = elem.nodeName.toLowerCase();
1864			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1865		},
1866
1867		"selected": function( elem ) {
1868			// Accessing this property makes selected-by-default
1869			// options in Safari work properly
1870			if ( elem.parentNode ) {
1871				elem.parentNode.selectedIndex;
1872			}
1873
1874			return elem.selected === true;
1875		},
1876
1877		// Contents
1878		"empty": function( elem ) {
1879			// http://www.w3.org/TR/selectors/#empty-pseudo
1880			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1881			//   but not by others (comment: 8; processing instruction: 7; etc.)
1882			// nodeType < 6 works because attributes (2) do not appear as children
1883			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1884				if ( elem.nodeType < 6 ) {
1885					return false;
1886				}
1887			}
1888			return true;
1889		},
1890
1891		"parent": function( elem ) {
1892			return !Expr.pseudos["empty"]( elem );
1893		},
1894
1895		// Element/input types
1896		"header": function( elem ) {
1897			return rheader.test( elem.nodeName );
1898		},
1899
1900		"input": function( elem ) {
1901			return rinputs.test( elem.nodeName );
1902		},
1903
1904		"button": function( elem ) {
1905			var name = elem.nodeName.toLowerCase();
1906			return name === "input" && elem.type === "button" || name === "button";
1907		},
1908
1909		"text": function( elem ) {
1910			var attr;
1911			return elem.nodeName.toLowerCase() === "input" &&
1912				elem.type === "text" &&
1913
1914				// Support: IE<8
1915				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
1916				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
1917		},
1918
1919		// Position-in-collection
1920		"first": createPositionalPseudo(function() {
1921			return [ 0 ];
1922		}),
1923
1924		"last": createPositionalPseudo(function( matchIndexes, length ) {
1925			return [ length - 1 ];
1926		}),
1927
1928		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
1929			return [ argument < 0 ? argument + length : argument ];
1930		}),
1931
1932		"even": createPositionalPseudo(function( matchIndexes, length ) {
1933			var i = 0;
1934			for ( ; i < length; i += 2 ) {
1935				matchIndexes.push( i );
1936			}
1937			return matchIndexes;
1938		}),
1939
1940		"odd": createPositionalPseudo(function( matchIndexes, length ) {
1941			var i = 1;
1942			for ( ; i < length; i += 2 ) {
1943				matchIndexes.push( i );
1944			}
1945			return matchIndexes;
1946		}),
1947
1948		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1949			var i = argument < 0 ? argument + length : argument;
1950			for ( ; --i >= 0; ) {
1951				matchIndexes.push( i );
1952			}
1953			return matchIndexes;
1954		}),
1955
1956		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1957			var i = argument < 0 ? argument + length : argument;
1958			for ( ; ++i < length; ) {
1959				matchIndexes.push( i );
1960			}
1961			return matchIndexes;
1962		})
1963	}
1964};
1965
1966Expr.pseudos["nth"] = Expr.pseudos["eq"];
1967
1968// Add button/input type pseudos
1969for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
1970	Expr.pseudos[ i ] = createInputPseudo( i );
1971}
1972for ( i in { submit: true, reset: true } ) {
1973	Expr.pseudos[ i ] = createButtonPseudo( i );
1974}
1975
1976// Easy API for creating new setFilters
1977function setFilters() {}
1978setFilters.prototype = Expr.filters = Expr.pseudos;
1979Expr.setFilters = new setFilters();
1980
1981function tokenize( selector, parseOnly ) {
1982	var matched, match, tokens, type,
1983		soFar, groups, preFilters,
1984		cached = tokenCache[ selector + " " ];
1985
1986	if ( cached ) {
1987		return parseOnly ? 0 : cached.slice( 0 );
1988	}
1989
1990	soFar = selector;
1991	groups = [];
1992	preFilters = Expr.preFilter;
1993
1994	while ( soFar ) {
1995
1996		// Comma and first run
1997		if ( !matched || (match = rcomma.exec( soFar )) ) {
1998			if ( match ) {
1999				// Don't consume trailing commas as valid
2000				soFar = soFar.slice( match[0].length ) || soFar;
2001			}
2002			groups.push( (tokens = []) );
2003		}
2004
2005		matched = false;
2006
2007		// Combinators
2008		if ( (match = rcombinators.exec( soFar )) ) {
2009			matched = match.shift();
2010			tokens.push({
2011				value: matched,
2012				// Cast descendant combinators to space
2013				type: match[0].replace( rtrim, " " )
2014			});
2015			soFar = soFar.slice( matched.length );
2016		}
2017
2018		// Filters
2019		for ( type in Expr.filter ) {
2020			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2021				(match = preFilters[ type ]( match ))) ) {
2022				matched = match.shift();
2023				tokens.push({
2024					value: matched,
2025					type: type,
2026					matches: match
2027				});
2028				soFar = soFar.slice( matched.length );
2029			}
2030		}
2031
2032		if ( !matched ) {
2033			break;
2034		}
2035	}
2036
2037	// Return the length of the invalid excess
2038	// if we're just parsing
2039	// Otherwise, throw an error or return tokens
2040	return parseOnly ?
2041		soFar.length :
2042		soFar ?
2043			Sizzle.error( selector ) :
2044			// Cache the tokens
2045			tokenCache( selector, groups ).slice( 0 );
2046}
2047
2048function toSelector( tokens ) {
2049	var i = 0,
2050		len = tokens.length,
2051		selector = "";
2052	for ( ; i < len; i++ ) {
2053		selector += tokens[i].value;
2054	}
2055	return selector;
2056}
2057
2058function addCombinator( matcher, combinator, base ) {
2059	var dir = combinator.dir,
2060		checkNonElements = base && dir === "parentNode",
2061		doneName = done++;
2062
2063	return combinator.first ?
2064		// Check against closest ancestor/preceding element
2065		function( elem, context, xml ) {
2066			while ( (elem = elem[ dir ]) ) {
2067				if ( elem.nodeType === 1 || checkNonElements ) {
2068					return matcher( elem, context, xml );
2069				}
2070			}
2071		} :
2072
2073		// Check against all ancestor/preceding elements
2074		function( elem, context, xml ) {
2075			var oldCache, outerCache,
2076				newCache = [ dirruns, doneName ];
2077
2078			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2079			if ( xml ) {
2080				while ( (elem = elem[ dir ]) ) {
2081					if ( elem.nodeType === 1 || checkNonElements ) {
2082						if ( matcher( elem, context, xml ) ) {
2083							return true;
2084						}
2085					}
2086				}
2087			} else {
2088				while ( (elem = elem[ dir ]) ) {
2089					if ( elem.nodeType === 1 || checkNonElements ) {
2090						outerCache = elem[ expando ] || (elem[ expando ] = {});
2091						if ( (oldCache = outerCache[ dir ]) &&
2092							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2093
2094							// Assign to newCache so results back-propagate to previous elements
2095							return (newCache[ 2 ] = oldCache[ 2 ]);
2096						} else {
2097							// Reuse newcache so results back-propagate to previous elements
2098							outerCache[ dir ] = newCache;
2099
2100							// A match means we're done; a fail means we have to keep checking
2101							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2102								return true;
2103							}
2104						}
2105					}
2106				}
2107			}
2108		};
2109}
2110
2111function elementMatcher( matchers ) {
2112	return matchers.length > 1 ?
2113		function( elem, context, xml ) {
2114			var i = matchers.length;
2115			while ( i-- ) {
2116				if ( !matchers[i]( elem, context, xml ) ) {
2117					return false;
2118				}
2119			}
2120			return true;
2121		} :
2122		matchers[0];
2123}
2124
2125function condense( unmatched, map, filter, context, xml ) {
2126	var elem,
2127		newUnmatched = [],
2128		i = 0,
2129		len = unmatched.length,
2130		mapped = map != null;
2131
2132	for ( ; i < len; i++ ) {
2133		if ( (elem = unmatched[i]) ) {
2134			if ( !filter || filter( elem, context, xml ) ) {
2135				newUnmatched.push( elem );
2136				if ( mapped ) {
2137					map.push( i );
2138				}
2139			}
2140		}
2141	}
2142
2143	return newUnmatched;
2144}
2145
2146function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2147	if ( postFilter && !postFilter[ expando ] ) {
2148		postFilter = setMatcher( postFilter );
2149	}
2150	if ( postFinder && !postFinder[ expando ] ) {
2151		postFinder = setMatcher( postFinder, postSelector );
2152	}
2153	return markFunction(function( seed, results, context, xml ) {
2154		var temp, i, elem,
2155			preMap = [],
2156			postMap = [],
2157			preexisting = results.length,
2158
2159			// Get initial elements from seed or context
2160			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2161
2162			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2163			matcherIn = preFilter && ( seed || !selector ) ?
2164				condense( elems, preMap, preFilter, context, xml ) :
2165				elems,
2166
2167			matcherOut = matcher ?
2168				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2169				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2170
2171					// ...intermediate processing is necessary
2172					[] :
2173
2174					// ...otherwise use results directly
2175					results :
2176				matcherIn;
2177
2178		// Find primary matches
2179		if ( matcher ) {
2180			matcher( matcherIn, matcherOut, context, xml );
2181		}
2182
2183		// Apply postFilter
2184		if ( postFilter ) {
2185			temp = condense( matcherOut, postMap );
2186			postFilter( temp, [], context, xml );
2187
2188			// Un-match failing elements by moving them back to matcherIn
2189			i = temp.length;
2190			while ( i-- ) {
2191				if ( (elem = temp[i]) ) {
2192					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2193				}
2194			}
2195		}
2196
2197		if ( seed ) {
2198			if ( postFinder || preFilter ) {
2199				if ( postFinder ) {
2200					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2201					temp = [];
2202					i = matcherOut.length;
2203					while ( i-- ) {
2204						if ( (elem = matcherOut[i]) ) {
2205							// Restore matcherIn since elem is not yet a final match
2206							temp.push( (matcherIn[i] = elem) );
2207						}
2208					}
2209					postFinder( null, (matcherOut = []), temp, xml );
2210				}
2211
2212				// Move matched elements from seed to results to keep them synchronized
2213				i = matcherOut.length;
2214				while ( i-- ) {
2215					if ( (elem = matcherOut[i]) &&
2216						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2217
2218						seed[temp] = !(results[temp] = elem);
2219					}
2220				}
2221			}
2222
2223		// Add elements to results, through postFinder if defined
2224		} else {
2225			matcherOut = condense(
2226				matcherOut === results ?
2227					matcherOut.splice( preexisting, matcherOut.length ) :
2228					matcherOut
2229			);
2230			if ( postFinder ) {
2231				postFinder( null, results, matcherOut, xml );
2232			} else {
2233				push.apply( results, matcherOut );
2234			}
2235		}
2236	});
2237}
2238
2239function matcherFromTokens( tokens ) {
2240	var checkContext, matcher, j,
2241		len = tokens.length,
2242		leadingRelative = Expr.relative[ tokens[0].type ],
2243		implicitRelative = leadingRelative || Expr.relative[" "],
2244		i = leadingRelative ? 1 : 0,
2245
2246		// The foundational matcher ensures that elements are reachable from top-level context(s)
2247		matchContext = addCombinator( function( elem ) {
2248			return elem === checkContext;
2249		}, implicitRelative, true ),
2250		matchAnyContext = addCombinator( function( elem ) {
2251			return indexOf.call( checkContext, elem ) > -1;
2252		}, implicitRelative, true ),
2253		matchers = [ function( elem, context, xml ) {
2254			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2255				(checkContext = context).nodeType ?
2256					matchContext( elem, context, xml ) :
2257					matchAnyContext( elem, context, xml ) );
2258		} ];
2259
2260	for ( ; i < len; i++ ) {
2261		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2262			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2263		} else {
2264			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2265
2266			// Return special upon seeing a positional matcher
2267			if ( matcher[ expando ] ) {
2268				// Find the next relative operator (if any) for proper handling
2269				j = ++i;
2270				for ( ; j < len; j++ ) {
2271					if ( Expr.relative[ tokens[j].type ] ) {
2272						break;
2273					}
2274				}
2275				return setMatcher(
2276					i > 1 && elementMatcher( matchers ),
2277					i > 1 && toSelector(
2278						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2279						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2280					).replace( rtrim, "$1" ),
2281					matcher,
2282					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2283					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2284					j < len && toSelector( tokens )
2285				);
2286			}
2287			matchers.push( matcher );
2288		}
2289	}
2290
2291	return elementMatcher( matchers );
2292}
2293
2294function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2295	var bySet = setMatchers.length > 0,
2296		byElement = elementMatchers.length > 0,
2297		superMatcher = function( seed, context, xml, results, outermost ) {
2298			var elem, j, matcher,
2299				matchedCount = 0,
2300				i = "0",
2301				unmatched = seed && [],
2302				setMatched = [],
2303				contextBackup = outermostContext,
2304				// We must always have either seed elements or outermost context
2305				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2306				// Use integer dirruns iff this is the outermost matcher
2307				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2308				len = elems.length;
2309
2310			if ( outermost ) {
2311				outermostContext = context !== document && context;
2312			}
2313
2314			// Add elements passing elementMatchers directly to results
2315			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2316			// Support: IE<9, Safari
2317			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2318			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2319				if ( byElement && elem ) {
2320					j = 0;
2321					while ( (matcher = elementMatchers[j++]) ) {
2322						if ( matcher( elem, context, xml ) ) {
2323							results.push( elem );
2324							break;
2325						}
2326					}
2327					if ( outermost ) {
2328						dirruns = dirrunsUnique;
2329					}
2330				}
2331
2332				// Track unmatched elements for set filters
2333				if ( bySet ) {
2334					// They will have gone through all possible matchers
2335					if ( (elem = !matcher && elem) ) {
2336						matchedCount--;
2337					}
2338
2339					// Lengthen the array for every element, matched or not
2340					if ( seed ) {
2341						unmatched.push( elem );
2342					}
2343				}
2344			}
2345
2346			// Apply set filters to unmatched elements
2347			matchedCount += i;
2348			if ( bySet && i !== matchedCount ) {
2349				j = 0;
2350				while ( (matcher = setMatchers[j++]) ) {
2351					matcher( unmatched, setMatched, context, xml );
2352				}
2353
2354				if ( seed ) {
2355					// Reintegrate element matches to eliminate the need for sorting
2356					if ( matchedCount > 0 ) {
2357						while ( i-- ) {
2358							if ( !(unmatched[i] || setMatched[i]) ) {
2359								setMatched[i] = pop.call( results );
2360							}
2361						}
2362					}
2363
2364					// Discard index placeholder values to get only actual matches
2365					setMatched = condense( setMatched );
2366				}
2367
2368				// Add matches to results
2369				push.apply( results, setMatched );
2370
2371				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2372				if ( outermost && !seed && setMatched.length > 0 &&
2373					( matchedCount + setMatchers.length ) > 1 ) {
2374
2375					Sizzle.uniqueSort( results );
2376				}
2377			}
2378
2379			// Override manipulation of globals by nested matchers
2380			if ( outermost ) {
2381				dirruns = dirrunsUnique;
2382				outermostContext = contextBackup;
2383			}
2384
2385			return unmatched;
2386		};
2387
2388	return bySet ?
2389		markFunction( superMatcher ) :
2390		superMatcher;
2391}
2392
2393compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
2394	var i,
2395		setMatchers = [],
2396		elementMatchers = [],
2397		cached = compilerCache[ selector + " " ];
2398
2399	if ( !cached ) {
2400		// Generate a function of recursive functions that can be used to check each element
2401		if ( !group ) {
2402			group = tokenize( selector );
2403		}
2404		i = group.length;
2405		while ( i-- ) {
2406			cached = matcherFromTokens( group[i] );
2407			if ( cached[ expando ] ) {
2408				setMatchers.push( cached );
2409			} else {
2410				elementMatchers.push( cached );
2411			}
2412		}
2413
2414		// Cache the compiled function
2415		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2416	}
2417	return cached;
2418};
2419
2420function multipleContexts( selector, contexts, results ) {
2421	var i = 0,
2422		len = contexts.length;
2423	for ( ; i < len; i++ ) {
2424		Sizzle( selector, contexts[i], results );
2425	}
2426	return results;
2427}
2428
2429function select( selector, context, results, seed ) {
2430	var i, tokens, token, type, find,
2431		match = tokenize( selector );
2432
2433	if ( !seed ) {
2434		// Try to minimize operations if there is only one group
2435		if ( match.length === 1 ) {
2436
2437			// Take a shortcut and set the context if the root selector is an ID
2438			tokens = match[0] = match[0].slice( 0 );
2439			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2440					support.getById && context.nodeType === 9 && documentIsHTML &&
2441					Expr.relative[ tokens[1].type ] ) {
2442
2443				context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2444				if ( !context ) {
2445					return results;
2446				}
2447				selector = selector.slice( tokens.shift().value.length );
2448			}
2449
2450			// Fetch a seed set for right-to-left matching
2451			i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2452			while ( i-- ) {
2453				token = tokens[i];
2454
2455				// Abort if we hit a combinator
2456				if ( Expr.relative[ (type = token.type) ] ) {
2457					break;
2458				}
2459				if ( (find = Expr.find[ type ]) ) {
2460					// Search, expanding context for leading sibling combinators
2461					if ( (seed = find(
2462						token.matches[0].replace( runescape, funescape ),

2463						rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2464					)) ) {
2465
2466						// If seed is empty or no tokens remain, we can return early
2467						tokens.splice( i, 1 );
2468						selector = seed.length && toSelector( tokens );
2469						if ( !selector ) {
2470							push.apply( results, seed );
2471							return results;
2472						}
2473
2474						break;
2475					}
2476				}
2477			}
2478		}
2479	}
2480
2481	// Compile and execute a filtering function
2482	// Provide `match` to avoid retokenization if we modified the selector above
2483	compile( selector, match )(
2484		seed,
2485		context,
2486		!documentIsHTML,
2487		results,
2488		rsibling.test( selector ) && testContext( context.parentNode ) || context
2489	);
2490	return results;
2491}
2492
2493// One-time assignments
2494
2495// Sort stability
2496support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2497
2498// Support: Chrome<14
2499// Always assume duplicates if they aren't passed to the comparison function
2500support.detectDuplicates = !!hasDuplicate;
2501
2502// Initialize against the default document
2503setDocument();
2504
2505// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2506// Detached nodes confoundingly follow *each other*
2507support.sortDetached = assert(function( div1 ) {
2508	// Should return 1, but returns 4 (following)
2509	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2510});
2511
2512// Support: IE<8
2513// Prevent attribute/property "interpolation"
2514// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2515if ( !assert(function( div ) {
2516	div.innerHTML = "<a href='#'></a>";
2517	return div.firstChild.getAttribute("href") === "#" ;
2518}) ) {
2519	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2520		if ( !isXML ) {
2521			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2522		}
2523	});
2524}
2525
2526// Support: IE<9
2527// Use defaultValue in place of getAttribute("value")
2528if ( !support.attributes || !assert(function( div ) {
2529	div.innerHTML = "<input/>";
2530	div.firstChild.setAttribute( "value", "" );
2531	return div.firstChild.getAttribute( "value" ) === "";
2532}) ) {
2533	addHandle( "value", function( elem, name, isXML ) {
2534		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2535			return elem.defaultValue;
2536		}
2537	});
2538}
2539
2540// Support: IE<9
2541// Use getAttributeNode to fetch booleans when getAttribute lies
2542if ( !assert(function( div ) {
2543	return div.getAttribute("disabled") == null;
2544}) ) {
2545	addHandle( booleans, function( elem, name, isXML ) {
2546		var val;
2547		if ( !isXML ) {
2548			return elem[ name ] === true ? name.toLowerCase() :
2549					(val = elem.getAttributeNode( name )) && val.specified ?
2550					val.value :
2551				null;
2552		}
2553	});
2554}
2555
2556return Sizzle;
2557
2558})( window );
2559
2560
2561
2562jQuery.find = Sizzle;
2563jQuery.expr = Sizzle.selectors;
2564jQuery.expr[":"] = jQuery.expr.pseudos;
2565jQuery.unique = Sizzle.uniqueSort;
2566jQuery.text = Sizzle.getText;
2567jQuery.isXMLDoc = Sizzle.isXML;
2568jQuery.contains = Sizzle.contains;
2569
2570
2571
2572var rneedsContext = jQuery.expr.match.needsContext;
2573
2574var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
2575
2576
2577
2578var risSimple = /^.[^:#\[\.,]*$/;
2579
2580// Implement the identical functionality for filter and not
2581function winnow( elements, qualifier, not ) {
2582	if ( jQuery.isFunction( qualifier ) ) {
2583		return jQuery.grep( elements, function( elem, i ) {
2584			/* jshint -W018 */
2585			return !!qualifier.call( elem, i, elem ) !== not;
2586		});
2587
2588	}
2589
2590	if ( qualifier.nodeType ) {
2591		return jQuery.grep( elements, function( elem ) {
2592			return ( elem === qualifier ) !== not;
2593		});
2594
2595	}
2596
2597	if ( typeof qualifier === "string" ) {
2598		if ( risSimple.test( qualifier ) ) {
2599			return jQuery.filter( qualifier, elements, not );
2600		}
2601
2602		qualifier = jQuery.filter( qualifier, elements );
2603	}
2604
2605	return jQuery.grep( elements, function( elem ) {
2606		return ( indexOf.call( qualifier, elem ) >= 0 ) !== not;
2607	});
2608}
2609
2610jQuery.filter = function( expr, elems, not ) {
2611	var elem = elems[ 0 ];
2612
2613	if ( not ) {
2614		expr = ":not(" + expr + ")";
2615	}
2616
2617	return elems.length === 1 && elem.nodeType === 1 ?
2618		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2619		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2620			return elem.nodeType === 1;
2621		}));
2622};
2623
2624jQuery.fn.extend({
2625	find: function( selector ) {
2626		var i,
2627			len = this.length,
2628			ret = [],
2629			self = this;
2630
2631		if ( typeof selector !== "string" ) {
2632			return this.pushStack( jQuery( selector ).filter(function() {
2633				for ( i = 0; i < len; i++ ) {
2634					if ( jQuery.contains( self[ i ], this ) ) {
2635						return true;
2636					}
2637				}
2638			}) );
2639		}
2640
2641		for ( i = 0; i < len; i++ ) {
2642			jQuery.find( selector, self[ i ], ret );
2643		}
2644
2645		// Needed because $( selector, context ) becomes $( context ).find( selector )
2646		ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
2647		ret.selector = this.selector ? this.selector + " " + selector : selector;
2648		return ret;
2649	},
2650	filter: function( selector ) {
2651		return this.pushStack( winnow(this, selector || [], false) );
2652	},
2653	not: function( selector ) {
2654		return this.pushStack( winnow(this, selector || [], true) );
2655	},
2656	is: function( selector ) {
2657		return !!winnow(
2658			this,
2659
2660			// If this is a positional/relative selector, check membership in the returned set
2661			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2662			typeof selector === "string" && rneedsContext.test( selector ) ?
2663				jQuery( selector ) :
2664				selector || [],
2665			false
2666		).length;
2667	}
2668});
2669
2670
2671// Initialize a jQuery object
2672
2673
2674// A central reference to the root jQuery(document)
2675var rootjQuery,
2676
2677	// A simple way to check for HTML strings
2678	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2679	// Strict HTML recognition (#11290: must start with <)
2680	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
2681
2682	init = jQuery.fn.init = function( selector, context ) {
2683		var match, elem;
2684
2685		// HANDLE: $(""), $(null), $(undefined), $(false)
2686		if ( !selector ) {
2687			return this;
2688		}
2689
2690		// Handle HTML strings
2691		if ( typeof selector === "string" ) {
2692			if ( selector[0] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) {
2693				// Assume that strings that start and end with <> are HTML and skip the regex check
2694				match = [ null, selector, null ];
2695
2696			} else {
2697				match = rquickExpr.exec( selector );
2698			}
2699
2700			// Match html or make sure no context is specified for #id
2701			if ( match && (match[1] || !context) ) {
2702
2703				// HANDLE: $(html) -> $(array)
2704				if ( match[1] ) {
2705					context = context instanceof jQuery ? context[0] : context;
2706
2707					// scripts is true for back-compat
2708					// Intentionally let the error be thrown if parseHTML is not present
2709					jQuery.merge( this, jQuery.parseHTML(
2710						match[1],
2711						context && context.nodeType ? context.ownerDocument || context : document,
2712						true
2713					) );
2714
2715					// HANDLE: $(html, props)
2716					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
2717						for ( match in context ) {
2718							// Properties of context are called as methods if possible
2719							if ( jQuery.isFunction( this[ match ] ) ) {
2720								this[ match ]( context[ match ] );
2721
2722							// ...and otherwise set as attributes
2723							} else {
2724								this.attr( match, context[ match ] );
2725							}
2726						}
2727					}
2728
2729					return this;
2730
2731				// HANDLE: $(#id)
2732				} else {
2733					elem = document.getElementById( match[2] );
2734
2735					// Check parentNode to catch when Blackberry 4.6 returns
2736					// nodes that are no longer in the document #6963
2737					if ( elem && elem.parentNode ) {
2738						// Inject the element directly into the jQuery object
2739						this.length = 1;
2740						this[0] = elem;
2741					}
2742
2743					this.context = document;
2744					this.selector = selector;
2745					return this;
2746				}
2747
2748			// HANDLE: $(expr, $(...))
2749			} else if ( !context || context.jquery ) {
2750				return ( context || rootjQuery ).find( selector );
2751
2752			// HANDLE: $(expr, context)
2753			// (which is just equivalent to: $(context).find(expr)
2754			} else {
2755				return this.constructor( context ).find( selector );
2756			}
2757
2758		// HANDLE: $(DOMElement)
2759		} else if ( selector.nodeType ) {
2760			this.context = this[0] = selector;
2761			this.length = 1;
2762			return this;
2763
2764		// HANDLE: $(function)
2765		// Shortcut for document ready
2766		} else if ( jQuery.isFunction( selector ) ) {
2767			return typeof rootjQuery.ready !== "undefined" ?
2768				rootjQuery.ready( selector ) :
2769				// Execute immediately if ready is not present
2770				selector( jQuery );
2771		}
2772
2773		if ( selector.selector !== undefined ) {
2774			this.selector = selector.selector;
2775			this.context = selector.context;
2776		}
2777
2778		return jQuery.makeArray( selector, this );
2779	};
2780
2781// Give the init function the jQuery prototype for later instantiation
2782init.prototype = jQuery.fn;
2783
2784// Initialize central reference
2785rootjQuery = jQuery( document );
2786
2787
2788var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2789	// methods guaranteed to produce a unique set when starting from a unique set
2790	guaranteedUnique = {
2791		children: true,
2792		contents: true,
2793		next: true,
2794		prev: true
2795	};
2796
2797jQuery.extend({
2798	dir: function( elem, dir, until ) {
2799		var matched = [],
2800			truncate = until !== undefined;
2801
2802		while ( (elem = elem[ dir ]) && elem.nodeType !== 9 ) {
2803			if ( elem.nodeType === 1 ) {
2804				if ( truncate && jQuery( elem ).is( until ) ) {
2805					break;
2806				}
2807				matched.push( elem );
2808			}
2809		}
2810		return matched;
2811	},
2812
2813	sibling: function( n, elem ) {
2814		var matched = [];
2815
2816		for ( ; n; n = n.nextSibling ) {
2817			if ( n.nodeType === 1 && n !== elem ) {
2818				matched.push( n );
2819			}
2820		}
2821
2822		return matched;
2823	}
2824});
2825
2826jQuery.fn.extend({
2827	has: function( target ) {
2828		var targets = jQuery( target, this ),
2829			l = targets.length;
2830
2831		return this.filter(function() {
2832			var i = 0;
2833			for ( ; i < l; i++ ) {
2834				if ( jQuery.contains( this, targets[i] ) ) {
2835					return true;
2836				}
2837			}
2838		});
2839	},
2840
2841	closest: function( selectors, context ) {
2842		var cur,
2843			i = 0,
2844			l = this.length,
2845			matched = [],
2846			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
2847				jQuery( selectors, context || this.context ) :
2848				0;
2849
2850		for ( ; i < l; i++ ) {
2851			for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
2852				// Always skip document fragments
2853				if ( cur.nodeType < 11 && (pos ?
2854					pos.index(cur) > -1 :
2855
2856					// Don't pass non-elements to Sizzle
2857					cur.nodeType === 1 &&
2858						jQuery.find.matchesSelector(cur, selectors)) ) {
2859
2860					matched.push( cur );
2861					break;
2862				}
2863			}
2864		}
2865
2866		return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
2867	},
2868
2869	// Determine the position of an element within
2870	// the matched set of elements
2871	index: function( elem ) {
2872
2873		// No argument, return index in parent
2874		if ( !elem ) {
2875			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
2876		}
2877
2878		// index in selector
2879		if ( typeof elem === "string" ) {
2880			return indexOf.call( jQuery( elem ), this[ 0 ] );
2881		}
2882
2883		// Locate the position of the desired element
2884		return indexOf.call( this,
2885
2886			// If it receives a jQuery object, the first element is used
2887			elem.jquery ? elem[ 0 ] : elem
2888		);
2889	},
2890
2891	add: function( selector, context ) {
2892		return this.pushStack(
2893			jQuery.unique(
2894				jQuery.merge( this.get(), jQuery( selector, context ) )
2895			)
2896		);
2897	},
2898
2899	addBack: function( selector ) {
2900		return this.add( selector == null ?
2901			this.prevObject : this.prevObject.filter(selector)
2902		);
2903	}
2904});
2905
2906function sibling( cur, dir ) {
2907	while ( (cur = cur[dir]) && cur.nodeType !== 1 ) {}
2908	return cur;
2909}
2910
2911jQuery.each({
2912	parent: function( elem ) {
2913		var parent = elem.parentNode;
2914		return parent && parent.nodeType !== 11 ? parent : null;
2915	},
2916	parents: function( elem ) {
2917		return jQuery.dir( elem, "parentNode" );
2918	},
2919	parentsUntil: function( elem, i, until ) {
2920		return jQuery.dir( elem, "parentNode", until );
2921	},
2922	next: function( elem ) {
2923		return sibling( elem, "nextSibling" );
2924	},
2925	prev: function( elem ) {
2926		return sibling( elem, "previousSibling" );
2927	},
2928	nextAll: function( elem ) {
2929		return jQuery.dir( elem, "nextSibling" );
2930	},
2931	prevAll: function( elem ) {
2932		return jQuery.dir( elem, "previousSibling" );
2933	},
2934	nextUntil: function( elem, i, until ) {
2935		return jQuery.dir( elem, "nextSibling", until );
2936	},
2937	prevUntil: function( elem, i, until ) {
2938		return jQuery.dir( elem, "previousSibling", until );
2939	},
2940	siblings: function( elem ) {
2941		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
2942	},
2943	children: function( elem ) {
2944		return jQuery.sibling( elem.firstChild );
2945	},
2946	contents: function( elem ) {
2947		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
2948	}
2949}, function( name, fn ) {
2950	jQuery.fn[ name ] = function( until, selector ) {
2951		var matched = jQuery.map( this, fn, until );
2952
2953		if ( name.slice( -5 ) !== "Until" ) {
2954			selector = until;
2955		}
2956
2957		if ( selector && typeof selector === "string" ) {
2958			matched = jQuery.filter( selector, matched );
2959		}
2960
2961		if ( this.length > 1 ) {
2962			// Remove duplicates
2963			if ( !guaranteedUnique[ name ] ) {
2964				jQuery.unique( matched );
2965			}
2966
2967			// Reverse order for parents* and prev-derivatives
2968			if ( rparentsprev.test( name ) ) {
2969				matched.reverse();
2970			}
2971		}
2972
2973		return this.pushStack( matched );
2974	};
2975});
2976var rnotwhite = (/\S+/g);
2977
2978
2979
2980// String to Object options format cache
2981var optionsCache = {};
2982
2983// Convert String-formatted options into Object-formatted ones and store in cache
2984function createOptions( options ) {
2985	var object = optionsCache[ options ] = {};
2986	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
2987		object[ flag ] = true;
2988	});
2989	return object;
2990}
2991
2992/*
2993 * Create a callback list using the following parameters:
2994 *
2995 *	options: an optional list of space-separated options that will change how
2996 *			the callback list behaves or a more traditional option object
2997 *
2998 * By default a callback list will act like an event callback list and can be
2999 * "fired" multiple times.
3000 *
3001 * Possible options:
3002 *
3003 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3004 *
3005 *	memory:			will keep track of previous values and will call any callback added
3006 *					after the list has been fired right away with the latest "memorized"
3007 *					values (like a Deferred)
3008 *
3009 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3010 *
3011 *	stopOnFalse:	interrupt callings when a callback returns false
3012 *
3013 */
3014jQuery.Callbacks = function( options ) {
3015
3016	// Convert options from String-formatted to Object-formatted if needed
3017	// (we check in cache first)
3018	options = typeof options === "string" ?
3019		( optionsCache[ options ] || createOptions( options ) ) :
3020		jQuery.extend( {}, options );
3021
3022	var // Last fire value (for non-forgettable lists)
3023		memory,
3024		// Flag to know if list was already fired
3025		fired,
3026		// Flag to know if list is currently firing
3027		firing,
3028		// First callback to fire (used internally by add and fireWith)
3029		firingStart,
3030		// End of the loop when firing
3031		firingLength,
3032		// Index of currently firing callback (modified by remove if needed)
3033		firingIndex,
3034		// Actual callback list
3035		list = [],