https://f-kamogawa.jp/js/jquery.js

1/*!
2 * jQuery JavaScript Library v2.0.2
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2013-05-30T21:25Z
13 */
14(function( window, undefined ) {
15
16// Can't do this because several apps including ASP.NET trace
17// the stack via arguments.caller.callee and Firefox dies if
18// you try to trace through "use strict" call chains. (#13335)
19// Support: Firefox 18+
20//"use strict";
21var
22	// A central reference to the root jQuery(document)
23	rootjQuery,
24
25	// The deferred used on DOM ready
26	readyList,
27
28	// Support: IE9
29	// For `typeof xmlNode.method` instead of `xmlNode.method !== undefined`
30	core_strundefined = typeof undefined,
31
32	// Use the correct document accordingly with window argument (sandbox)
33	location = window.location,
34	document = window.document,
35	docElem = document.documentElement,
36
37	// Map over jQuery in case of overwrite
38	_jQuery = window.jQuery,
39
40	// Map over the $ in case of overwrite
41	_$ = window.$,
42
43	// [[Class]] -> type pairs
44	class2type = {},
45
46	// List of deleted data cache ids, so we can reuse them
47	core_deletedIds = [],
48
49	core_version = "2.0.2",
50
51	// Save a reference to some core methods
52	core_concat = core_deletedIds.concat,
53	core_push = core_deletedIds.push,
54	core_slice = core_deletedIds.slice,
55	core_indexOf = core_deletedIds.indexOf,
56	core_toString = class2type.toString,
57	core_hasOwn = class2type.hasOwnProperty,
58	core_trim = core_version.trim,
59
60	// Define a local copy of jQuery
61	jQuery = function( selector, context ) {
62		// The jQuery object is actually just the init constructor 'enhanced'
63		return new jQuery.fn.init( selector, context, rootjQuery );
64	},
65
66	// Used for matching numbers
67	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
68
69	// Used for splitting on whitespace
70	core_rnotwhite = /\S+/g,
71
72	// A simple way to check for HTML strings
73	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
74	// Strict HTML recognition (#11290: must start with <)
75	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
76
77	// Match a standalone tag
78	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
79
80	// Matches dashed string for camelizing
81	rmsPrefix = /^-ms-/,
82	rdashAlpha = /-([\da-z])/gi,
83
84	// Used by jQuery.camelCase as callback to replace()
85	fcamelCase = function( all, letter ) {
86		return letter.toUpperCase();
87	},
88
89	// The ready event handler and self cleanup method
90	completed = function() {
91		document.removeEventListener( "DOMContentLoaded", completed, false );
92		window.removeEventListener( "load", completed, false );
93		jQuery.ready();
94	};
95
96jQuery.fn = jQuery.prototype = {
97	// The current version of jQuery being used
98	jquery: core_version,
99
100	constructor: jQuery,
101	init: function( selector, context, rootjQuery ) {
102		var match, elem;
103
104		// HANDLE: $(""), $(null), $(undefined), $(false)
105		if ( !selector ) {
106			return this;
107		}
108
109		// Handle HTML strings
110		if ( typeof selector === "string" ) {
111			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
112				// Assume that strings that start and end with <> are HTML and skip the regex check
113				match = [ null, selector, null ];
114
115			} else {
116				match = rquickExpr.exec( selector );
117			}
118
119			// Match html or make sure no context is specified for #id
120			if ( match && (match[1] || !context) ) {
121
122				// HANDLE: $(html) -> $(array)
123				if ( match[1] ) {
124					context = context instanceof jQuery ? context[0] : context;
125
126					// scripts is true for back-compat
127					jQuery.merge( this, jQuery.parseHTML(
128						match[1],
129						context && context.nodeType ? context.ownerDocument || context : document,
130						true
131					) );
132
133					// HANDLE: $(html, props)
134					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
135						for ( match in context ) {
136							// Properties of context are called as methods if possible
137							if ( jQuery.isFunction( this[ match ] ) ) {
138								this[ match ]( context[ match ] );
139
140							// ...and otherwise set as attributes
141							} else {
142								this.attr( match, context[ match ] );
143							}
144						}
145					}
146
147					return this;
148
149				// HANDLE: $(#id)
150				} else {
151					elem = document.getElementById( match[2] );
152
153					// Check parentNode to catch when Blackberry 4.6 returns
154					// nodes that are no longer in the document #6963
155					if ( elem && elem.parentNode ) {
156						// Inject the element directly into the jQuery object
157						this.length = 1;
158						this[0] = elem;
159					}
160
161					this.context = document;
162					this.selector = selector;
163					return this;
164				}
165
166			// HANDLE: $(expr, $(...))
167			} else if ( !context || context.jquery ) {
168				return ( context || rootjQuery ).find( selector );
169
170			// HANDLE: $(expr, context)
171			// (which is just equivalent to: $(context).find(expr)
172			} else {
173				return this.constructor( context ).find( selector );
174			}
175
176		// HANDLE: $(DOMElement)
177		} else if ( selector.nodeType ) {
178			this.context = this[0] = selector;
179			this.length = 1;
180			return this;
181
182		// HANDLE: $(function)
183		// Shortcut for document ready
184		} else if ( jQuery.isFunction( selector ) ) {
185			return rootjQuery.ready( selector );
186		}
187
188		if ( selector.selector !== undefined ) {
189			this.selector = selector.selector;
190			this.context = selector.context;
191		}
192
193		return jQuery.makeArray( selector, this );
194	},
195
196	// Start with an empty selector
197	selector: "",
198
199	// The default length of a jQuery object is 0
200	length: 0,
201
202	toArray: function() {
203		return core_slice.call( this );
204	},
205
206	// Get the Nth element in the matched element set OR
207	// Get the whole matched element set as a clean array
208	get: function( num ) {
209		return num == null ?
210
211			// Return a 'clean' array
212			this.toArray() :
213
214			// Return just the object
215			( num < 0 ? this[ this.length + num ] : this[ num ] );
216	},
217
218	// Take an array of elements and push it onto the stack
219	// (returning the new matched element set)
220	pushStack: function( elems ) {
221
222		// Build a new jQuery matched element set
223		var ret = jQuery.merge( this.constructor(), elems );
224
225		// Add the old object onto the stack (as a reference)

226		ret.prevObject = this;
227		ret.context = this.context;
228
229		// Return the newly-formed element set
230		return ret;
231	},
232
233	// Execute a callback for every element in the matched set.
234	// (You can seed the arguments with an array of args, but this is
235	// only used internally.)
236	each: function( callback, args ) {
237		return jQuery.each( this, callback, args );
238	},
239
240	ready: function( fn ) {
241		// Add the callback
242		jQuery.ready.promise().done( fn );
243
244		return this;
245	},
246
247	slice: function() {
248		return this.pushStack( core_slice.apply( this, arguments ) );
249	},
250
251	first: function() {
252		return this.eq( 0 );
253	},
254
255	last: function() {
256		return this.eq( -1 );
257	},
258
259	eq: function( i ) {
260		var len = this.length,
261			j = +i + ( i < 0 ? len : 0 );
262		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
263	},
264
265	map: function( callback ) {
266		return this.pushStack( jQuery.map(this, function( elem, i ) {
267			return callback.call( elem, i, elem );
268		}));
269	},
270
271	end: function() {
272		return this.prevObject || this.constructor(null);
273	},
274
275	// For internal use only.
276	// Behaves like an Array's method, not like a jQuery method.
277	push: core_push,
278	sort: [].sort,
279	splice: [].splice
280};
281
282// Give the init function the jQuery prototype for later instantiation
283jQuery.fn.init.prototype = jQuery.fn;
284
285jQuery.extend = jQuery.fn.extend = function() {
286	var options, name, src, copy, copyIsArray, clone,
287		target = arguments[0] || {},
288		i = 1,
289		length = arguments.length,
290		deep = false;
291
292	// Handle a deep copy situation
293	if ( typeof target === "boolean" ) {
294		deep = target;
295		target = arguments[1] || {};
296		// skip the boolean and the target
297		i = 2;
298	}
299
300	// Handle case when target is a string or something (possible in deep copy)
301	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
302		target = {};
303	}
304
305	// extend jQuery itself if only one argument is passed
306	if ( length === i ) {
307		target = this;
308		--i;
309	}
310
311	for ( ; i < length; i++ ) {
312		// Only deal with non-null/undefined values
313		if ( (options = arguments[ i ]) != null ) {
314			// Extend the base object
315			for ( name in options ) {
316				src = target[ name ];
317				copy = options[ name ];
318
319				// Prevent never-ending loop
320				if ( target === copy ) {
321					continue;
322				}
323
324				// Recurse if we're merging plain objects or arrays
325				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
326					if ( copyIsArray ) {
327						copyIsArray = false;
328						clone = src && jQuery.isArray(src) ? src : [];
329
330					} else {
331						clone = src && jQuery.isPlainObject(src) ? src : {};
332					}
333
334					// Never move original objects, clone them
335					target[ name ] = jQuery.extend( deep, clone, copy );
336
337				// Don't bring in undefined values
338				} else if ( copy !== undefined ) {
339					target[ name ] = copy;
340				}
341			}
342		}
343	}
344
345	// Return the modified object
346	return target;
347};
348
349jQuery.extend({
350	// Unique for each copy of jQuery on the page
351	expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
352
353	noConflict: function( deep ) {
354		if ( window.$ === jQuery ) {
355			window.$ = _$;
356		}
357
358		if ( deep && window.jQuery === jQuery ) {
359			window.jQuery = _jQuery;
360		}
361
362		return jQuery;
363	},
364
365	// Is the DOM ready to be used? Set to true once it occurs.
366	isReady: false,
367
368	// A counter to track how many items to wait for before
369	// the ready event fires. See #6781
370	readyWait: 1,
371
372	// Hold (or release) the ready event
373	holdReady: function( hold ) {
374		if ( hold ) {
375			jQuery.readyWait++;
376		} else {
377			jQuery.ready( true );
378		}
379	},
380
381	// Handle when the DOM is ready
382	ready: function( wait ) {
383
384		// Abort if there are pending holds or we're already ready
385		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
386			return;
387		}
388
389		// Remember that the DOM is ready
390		jQuery.isReady = true;
391
392		// If a normal DOM Ready event fired, decrement, and wait if need be
393		if ( wait !== true && --jQuery.readyWait > 0 ) {
394			return;
395		}
396
397		// If there are functions bound, to execute
398		readyList.resolveWith( document, [ jQuery ] );
399
400		// Trigger any bound ready events
401		if ( jQuery.fn.trigger ) {
402			jQuery( document ).trigger("ready").off("ready");
403		}
404	},
405
406	// See test/unit/core.js for details concerning isFunction.
407	// Since version 1.3, DOM methods and functions like alert
408	// aren't supported. They return false on IE (#2968).
409	isFunction: function( obj ) {
410		return jQuery.type(obj) === "function";
411	},
412
413	isArray: Array.isArray,
414
415	isWindow: function( obj ) {
416		return obj != null && obj === obj.window;
417	},
418
419	isNumeric: function( obj ) {
420		return !isNaN( parseFloat(obj) ) && isFinite( obj );
421	},
422
423	type: function( obj ) {
424		if ( obj == null ) {
425			return String( obj );
426		}

427		// Support: Safari <= 5.1 (functionish RegExp)
428		return typeof obj === "object" || typeof obj === "function" ?
429			class2type[ core_toString.call(obj) ] || "object" :
430			typeof obj;
431	},
432
433	isPlainObject: function( obj ) {
434		// Not plain objects:
435		// - Any object or value whose internal [[Class]] property is not "[object Object]"
436		// - DOM nodes
437		// - window
438		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
439			return false;
440		}
441
442		// Support: Firefox <20
443		// The try/catch suppresses exceptions thrown when attempting to access
444		// the "constructor" property of certain host objects, ie. |window.location|
445		// https://bugzilla.mozilla.org/show_bug.cgi?id=814622
446		try {
447			if ( obj.constructor &&
448					!core_hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
449				return false;
450			}
451		} catch ( e ) {
452			return false;
453		}
454
455		// If the function hasn't returned already, we're confident that
456		// |obj| is a plain object, created by {} or constructed with new Object
457		return true;
458	},
459
460	isEmptyObject: function( obj ) {
461		var name;
462		for ( name in obj ) {
463			return false;
464		}
465		return true;
466	},
467
468	error: function( msg ) {
469		throw new Error( msg );
470	},
471
472	// data: string of html
473	// context (optional): If specified, the fragment will be created in this context, defaults to document
474	// keepScripts (optional): If true, will include scripts passed in the html string
475	parseHTML: function( data, context, keepScripts ) {
476		if ( !data || typeof data !== "string" ) {
477			return null;
478		}
479		if ( typeof context === "boolean" ) {
480			keepScripts = context;
481			context = false;
482		}
483		context = context || document;
484
485		var parsed = rsingleTag.exec( data ),
486			scripts = !keepScripts && [];
487
488		// Single tag
489		if ( parsed ) {
490			return [ context.createElement( parsed[1] ) ];
491		}
492
493		parsed = jQuery.buildFragment( [ data ], context, scripts );
494
495		if ( scripts ) {
496			jQuery( scripts ).remove();
497		}
498
499		return jQuery.merge( [], parsed.childNodes );
500	},
501
502	parseJSON: JSON.parse,
503
504	// Cross-browser xml parsing
505	parseXML: function( data ) {
506		var xml, tmp;
507		if ( !data || typeof data !== "string" ) {
508			return null;
509		}
510
511		// Support: IE9
512		try {
513			tmp = new DOMParser();
514			xml = tmp.parseFromString( data , "text/xml" );
515		} catch ( e ) {
516			xml = undefined;
517		}
518
519		if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
520			jQuery.error( "Invalid XML: " + data );
521		}
522		return xml;
523	},
524
525	noop: function() {},
526
527	// Evaluates a script in a global context
528	globalEval: function( code ) {
529		var script,
530				indirect = eval;
531
532		code = jQuery.trim( code );
533
534		if ( code ) {
535			// If the code includes a valid, prologue position
536			// strict mode pragma, execute code by injecting a
537			// script tag into the document.
538			if ( code.indexOf("use strict") === 1 ) {
539				script = document.createElement("script");
540				script.text = code;
541				document.head.appendChild( script ).parentNode.removeChild( script );
542			} else {
543			// Otherwise, avoid the DOM node creation, insertion
544			// and removal by using an indirect global eval
545				indirect( code );
546			}
547		}
548	},
549
550	// Convert dashed to camelCase; used by the css and data modules
551	// Microsoft forgot to hump their vendor prefix (#9572)
552	camelCase: function( string ) {
553		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
554	},
555
556	nodeName: function( elem, name ) {
557		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
558	},
559
560	// args is for internal usage only
561	each: function( obj, callback, args ) {
562		var value,
563			i = 0,
564			length = obj.length,
565			isArray = isArraylike( obj );
566
567		if ( args ) {
568			if ( isArray ) {
569				for ( ; i < length; i++ ) {
570					value = callback.apply( obj[ i ], args );
571
572					if ( value === false ) {
573						break;
574					}
575				}
576			} else {
577				for ( i in obj ) {
578					value = callback.apply( obj[ i ], args );
579
580					if ( value === false ) {
581						break;
582					}
583				}
584			}
585
586		// A special, fast, case for the most common use of each
587		} else {
588			if ( isArray ) {
589				for ( ; i < length; i++ ) {
590					value = callback.call( obj[ i ], i, obj[ i ] );
591
592					if ( value === false ) {
593						break;
594					}
595				}
596			} else {
597				for ( i in obj ) {
598					value = callback.call( obj[ i ], i, obj[ i ] );
599
600					if ( value === false ) {
601						break;
602					}
603				}
604			}
605		}
606
607		return obj;
608	},
609
610	trim: function( text ) {
611		return text == null ? "" : core_trim.call( text );
612	},
613
614	// results is for internal usage only
615	makeArray: function( arr, results ) {
616		var ret = results || [];
617
618		if ( arr != null ) {
619			if ( isArraylike( Object(arr) ) ) {
620				jQuery.merge( ret,
621					typeof arr === "string" ?
622					[ arr ] : arr
623				);
624			} else {
625				core_push.call( ret, arr );
626			}
627		}
628
629		return ret;
630	},
631
632	inArray: function( elem, arr, i ) {
633		return arr == null ? -1 : core_indexOf.call( arr, elem, i );
634	},
635
636	merge: function( first, second ) {
637		var l = second.length,
638			i = first.length,
639			j = 0;
640
641		if ( typeof l === "number" ) {
642			for ( ; j < l; j++ ) {
643				first[ i++ ] = second[ j ];
644			}
645		} else {
646			while ( second[j] !== undefined ) {
647				first[ i++ ] = second[ j++ ];
648			}
649		}
650
651		first.length = i;
652
653		return first;
654	},
655
656	grep: function( elems, callback, inv ) {
657		var retVal,
658			ret = [],
659			i = 0,
660			length = elems.length;
661		inv = !!inv;
662
663		// Go through the array, only saving the items
664		// that pass the validator function
665		for ( ; i < length; i++ ) {
666			retVal = !!callback( elems[ i ], i );
667			if ( inv !== retVal ) {
668				ret.push( elems[ i ] );
669			}
670		}
671
672		return ret;
673	},
674
675	// arg is for internal usage only
676	map: function( elems, callback, arg ) {
677		var value,
678			i = 0,
679			length = elems.length,
680			isArray = isArraylike( elems ),
681			ret = [];
682
683		// Go through the array, translating each of the items to their
684		if ( isArray ) {
685			for ( ; i < length; i++ ) {
686				value = callback( elems[ i ], i, arg );
687
688				if ( value != null ) {
689					ret[ ret.length ] = value;
690				}
691			}
692
693		// Go through every key on the object,
694		} else {
695			for ( i in elems ) {
696				value = callback( elems[ i ], i, arg );
697
698				if ( value != null ) {
699					ret[ ret.length ] = value;
700				}
701			}
702		}
703
704		// Flatten any nested arrays
705		return core_concat.apply( [], ret );
706	},
707
708	// A global GUID counter for objects
709	guid: 1,
710
711	// Bind a function to a context, optionally partially applying any
712	// arguments.
713	proxy: function( fn, context ) {
714		var tmp, args, proxy;
715
716		if ( typeof context === "string" ) {
717			tmp = fn[ context ];
718			context = fn;
719			fn = tmp;
720		}
721
722		// Quick check to determine if target is callable, in the spec
723		// this throws a TypeError, but we will just return undefined.
724		if ( !jQuery.isFunction( fn ) ) {
725			return undefined;
726		}
727
728		// Simulated bind
729		args = core_slice.call( arguments, 2 );
730		proxy = function() {
731			return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
732		};
733
734		// Set the guid of unique handler to the same of original handler, so it can be removed
735		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
736
737		return proxy;
738	},
739
740	// Multifunctional method to get and set values of a collection
741	// The value/s can optionally be executed if it's a function
742	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
743		var i = 0,
744			length = elems.length,
745			bulk = key == null;
746
747		// Sets many values
748		if ( jQuery.type( key ) === "object" ) {
749			chainable = true;
750			for ( i in key ) {
751				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
752			}
753
754		// Sets one value
755		} else if ( value !== undefined ) {
756			chainable = true;
757
758			if ( !jQuery.isFunction( value ) ) {
759				raw = true;
760			}
761
762			if ( bulk ) {
763				// Bulk operations run against the entire set
764				if ( raw ) {
765					fn.call( elems, value );
766					fn = null;
767
768				// ...except when executing function values
769				} else {
770					bulk = fn;
771					fn = function( elem, key, value ) {

772						return bulk.call( jQuery( elem ), value );
773					};
774				}
775			}
776
777			if ( fn ) {
778				for ( ; i < length; i++ ) {
779					fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
780				}
781			}
782		}
783
784		return chainable ?
785			elems :
786
787			// Gets
788			bulk ?
789				fn.call( elems ) :
790				length ? fn( elems[0], key ) : emptyGet;
791	},
792
793	now: Date.now,
794
795	// A method for quickly swapping in/out CSS properties to get correct calculations.
796	// Note: this method belongs to the css module but it's needed here for the support module.
797	// If support gets modularized, this method should be moved back to the css module.
798	swap: function( elem, options, callback, args ) {
799		var ret, name,
800			old = {};
801
802		// Remember the old values, and insert the new ones
803		for ( name in options ) {
804			old[ name ] = elem.style[ name ];
805			elem.style[ name ] = options[ name ];
806		}
807
808		ret = callback.apply( elem, args || [] );
809
810		// Revert the old values
811		for ( name in options ) {
812			elem.style[ name ] = old[ name ];
813		}
814
815		return ret;
816	}
817});
818
819jQuery.ready.promise = function( obj ) {
820	if ( !readyList ) {
821
822		readyList = jQuery.Deferred();
823
824		// Catch cases where $(document).ready() is called after the browser event has already occurred.
825		// we once tried to use readyState "interactive" here, but it caused issues like the one
826		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
827		if ( document.readyState === "complete" ) {
828			// Handle it asynchronously to allow scripts the opportunity to delay ready
829			setTimeout( jQuery.ready );
830
831		} else {
832
833			// Use the handy event callback
834			document.addEventListener( "DOMContentLoaded", completed, false );
835
836			// A fallback to window.onload, that will always work
837			window.addEventListener( "load", completed, false );
838		}
839	}
840	return readyList.promise( obj );
841};
842
843// Populate the class2type map
844jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
845	class2type[ "[object " + name + "]" ] = name.toLowerCase();
846});
847
848function isArraylike( obj ) {
849	var length = obj.length,
850		type = jQuery.type( obj );
851
852	if ( jQuery.isWindow( obj ) ) {
853		return false;
854	}
855
856	if ( obj.nodeType === 1 && length ) {
857		return true;
858	}
859
860	return type === "array" || type !== "function" &&
861		( length === 0 ||
862		typeof length === "number" && length > 0 && ( length - 1 ) in obj );
863}
864
865// All jQuery objects should point back to these
866rootjQuery = jQuery(document);
867/*!
868 * Sizzle CSS Selector Engine v1.9.4-pre
869 * http://sizzlejs.com/
870 *
871 * Copyright 2013 jQuery Foundation, Inc. and other contributors
872 * Released under the MIT license
873 * http://jquery.org/license
874 *
875 * Date: 2013-05-27
876 */
877(function( window, undefined ) {
878
879var i,
880	support,
881	cachedruns,
882	Expr,
883	getText,
884	isXML,
885	compile,
886	outermostContext,
887	sortInput,
888
889	// Local document vars
890	setDocument,
891	document,
892	docElem,
893	documentIsHTML,
894	rbuggyQSA,
895	rbuggyMatches,
896	matches,
897	contains,
898
899	// Instance-specific data
900	expando = "sizzle" + -(new Date()),
901	preferredDoc = window.document,
902	dirruns = 0,
903	done = 0,
904	classCache = createCache(),
905	tokenCache = createCache(),
906	compilerCache = createCache(),
907	hasDuplicate = false,
908	sortOrder = function() { return 0; },
909
910	// General-purpose constants
911	strundefined = typeof undefined,
912	MAX_NEGATIVE = 1 << 31,
913
914	// Instance methods
915	hasOwn = ({}).hasOwnProperty,
916	arr = [],
917	pop = arr.pop,
918	push_native = arr.push,
919	push = arr.push,
920	slice = arr.slice,
921	// Use a stripped-down indexOf if we can't use a native one
922	indexOf = arr.indexOf || function( elem ) {
923		var i = 0,
924			len = this.length;
925		for ( ; i < len; i++ ) {
926			if ( this[i] === elem ) {
927				return i;
928			}
929		}
930		return -1;
931	},
932
933	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
934
935	// Regular expressions
936
937	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
938	whitespace = "[\\x20\\t\\r\\n\\f]",
939	// http://www.w3.org/TR/css3-syntax/#characters
940	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
941
942	// Loosely modeled on CSS identifier characters
943	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
944	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
945	identifier = characterEncoding.replace( "w", "w#" ),
946
947	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
948	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
949		"*(?:([*^$|!~]?=)" + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
950
951	// Prefer arguments quoted,
952	//   then not containing pseudos/brackets,
953	//   then attribute selectors/non-parenthetical expressions,
954	//   then anything else
955	// These preferences are here to reduce the number of selectors
956	//   needing tokenize in the PSEUDO preFilter
957	pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",
958
959	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
960	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
961
962	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
963	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
964
965	rsibling = new RegExp( whitespace + "*[+~]" ),
966	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*)" + whitespace + "*\\]", "g" ),
967
968	rpseudo = new RegExp( pseudos ),
969	ridentifier = new RegExp( "^" + identifier + "$" ),
970
971	matchExpr = {
972		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
973		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
974		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
975		"ATTR": new RegExp( "^" + attributes ),
976		"PSEUDO": new RegExp( "^" + pseudos ),
977		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
978			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
979			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
980		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
981		// For use in libraries implementing .is()
982		// We use this for POS matching in `select`
983		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
984			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
985	},
986
987	rnative = /^[^{]+\{\s*\[native \w/,
988
989	// Easily-parseable/retrievable ID or TAG or CLASS selectors
990	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
991
992	rinputs = /^(?:input|select|textarea|button)$/i,
993	rheader = /^h\d$/i,
994
995	rescape = /'|\\/g,
996
997	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
998	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
999	funescape = function( _, escaped, escapedWhitespace ) {
1000		var high = "0x" + escaped - 0x10000;
1001		// NaN means non-codepoint
1002		// Support: Firefox
1003		// Workaround erroneous numeric interpretation of +"0x"
1004		return high !== high || escapedWhitespace ?
1005			escaped :
1006			// BMP codepoint
1007			high < 0 ?
1008				String.fromCharCode( high + 0x10000 ) :
1009				// Supplemental Plane codepoint (surrogate pair)
1010				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1011	};
1012
1013// Optimize for push.apply( _, NodeList )
1014try {
1015	push.apply(
1016		(arr = slice.call( preferredDoc.childNodes )),
1017		preferredDoc.childNodes
1018	);
1019	// Support: Android<4.0
1020	// Detect silently failing push.apply
1021	arr[ preferredDoc.childNodes.length ].nodeType;
1022} catch ( e ) {
1023	push = { apply: arr.length ?
1024
1025		// Leverage slice if possible
1026		function( target, els ) {
1027			push_native.apply( target, slice.call(els) );
1028		} :
1029
1030		// Support: IE<9
1031		// Otherwise append directly
1032		function( target, els ) {
1033			var j = target.length,
1034				i = 0;
1035			// Can't trust NodeList.length
1036			while ( (target[j++] = els[i++]) ) {}
1037			target.length = j - 1;
1038		}
1039	};
1040}
1041
1042function Sizzle( selector, context, results, seed ) {
1043	var match, elem, m, nodeType,
1044		// QSA vars
1045		i, groups, old, nid, newContext, newSelector;
1046
1047	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
1048		setDocument( context );
1049	}
1050
1051	context = context || document;
1052	results = results || [];
1053
1054	if ( !selector || typeof selector !== "string" ) {
1055		return results;
1056	}
1057
1058	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
1059		return [];
1060	}
1061
1062	if ( documentIsHTML && !seed ) {
1063
1064		// Shortcuts
1065		if ( (match = rquickExpr.exec( selector )) ) {
1066			// Speed-up: Sizzle("#ID")
1067			if ( (m = match[1]) ) {
1068				if ( nodeType === 9 ) {
1069					elem = context.getElementById( m );
1070					// Check parentNode to catch when Blackberry 4.6 returns
1071					// nodes that are no longer in the document #6963
1072					if ( elem && elem.parentNode ) {
1073						// Handle the case where IE, Opera, and Webkit return items
1074						// by name instead of ID
1075						if ( elem.id === m ) {
1076							results.push( elem );
1077							return results;
1078						}
1079					} else {
1080						return results;
1081					}
1082				} else {
1083					// Context is not a document
1084					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
1085						contains( context, elem ) && elem.id === m ) {
1086						results.push( elem );
1087						return results;
1088					}
1089				}
1090
1091			// Speed-up: Sizzle("TAG")
1092			} else if ( match[2] ) {
1093				push.apply( results, context.getElementsByTagName( selector ) );
1094				return results;
1095
1096			// Speed-up: Sizzle(".CLASS")
1097			} else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {
1098				push.apply( results, context.getElementsByClassName( m ) );
1099				return results;
1100			}
1101		}
1102
1103		// QSA path
1104		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
1105			nid = old = expando;
1106			newContext = context;
1107			newSelector = nodeType === 9 && selector;
1108
1109			// qSA works strangely on Element-rooted queries
1110			// We can work around this by specifying an extra ID on the root
1111			// and working up from there (Thanks to Andrew Dupont for the technique)
1112			// IE 8 doesn't work on object elements
1113			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
1114				groups = tokenize( selector );
1115
1116				if ( (old = context.getAttribute("id")) ) {
1117					nid = old.replace( rescape, "\\$&" );
1118				} else {
1119					context.setAttribute( "id", nid );
1120				}
1121				nid = "[id='" + nid + "'] ";
1122
1123				i = groups.length;
1124				while ( i-- ) {
1125					groups[i] = nid + toSelector( groups[i] );
1126				}
1127				newContext = rsibling.test( selector ) && context.parentNode || context;
1128				newSelector = groups.join(",");
1129			}
1130
1131			if ( newSelector ) {
1132				try {
1133					push.apply( results,
1134						newContext.querySelectorAll( newSelector )
1135					);
1136					return results;
1137				} catch(qsaError) {
1138				} finally {
1139					if ( !old ) {
1140						context.removeAttribute("id");
1141					}
1142				}
1143			}
1144		}
1145	}
1146
1147	// All others
1148	return select( selector.replace( rtrim, "$1" ), context, results, seed );
1149}
1150
1151/**
1152 * For feature detection
1153 * @param {Function} fn The function to test for native support
1154 */
1155function isNative( fn ) {
1156	return rnative.test( fn + "" );
1157}
1158
1159/**
1160 * Create key-value caches of limited size
1161 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
1162 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1163 *	deleting the oldest entry
1164 */
1165function createCache() {
1166	var keys = [];
1167
1168	function cache( key, value ) {
1169		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1170		if ( keys.push( key += " " ) > Expr.cacheLength ) {
1171			// Only keep the most recent entries
1172			delete cache[ keys.shift() ];
1173		}
1174		return (cache[ key ] = value);
1175	}
1176	return cache;
1177}
1178
1179/**
1180 * Mark a function for special use by Sizzle
1181 * @param {Function} fn The function to mark
1182 */
1183function markFunction( fn ) {
1184	fn[ expando ] = true;
1185	return fn;
1186}
1187
1188/**
1189 * Support testing using an element
1190 * @param {Function} fn Passed the created div and expects a boolean result
1191 */
1192function assert( fn ) {
1193	var div = document.createElement("div");
1194
1195	try {
1196		return !!fn( div );
1197	} catch (e) {
1198		return false;

1463		// Support: IE6/7
1464		// getElementById is not reliable as a find shortcut
1465		delete Expr.find["ID"];
1466
1467		Expr.filter["ID"] =  function( id ) {
1468			var attrId = id.replace( runescape, funescape );
1469			return function( elem ) {
1470				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1471				return node && node.value === attrId;
1472			};
1473		};
1474	}
1475
1476	// Tag
1477	Expr.find["TAG"] = support.getElementsByTagName ?
1478		function( tag, context ) {
1479			if ( typeof context.getElementsByTagName !== strundefined ) {
1480				return context.getElementsByTagName( tag );
1481			}
1482		} :
1483		function( tag, context ) {
1484			var elem,
1485				tmp = [],
1486				i = 0,
1487				results = context.getElementsByTagName( tag );
1488
1489			// Filter out possible comments
1490			if ( tag === "*" ) {
1491				while ( (elem = results[i++]) ) {
1492					if ( elem.nodeType === 1 ) {
1493						tmp.push( elem );
1494					}
1495				}
1496
1497				return tmp;
1498			}
1499			return results;
1500		};
1501
1502	// Class
1503	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1504		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1505			return context.getElementsByClassName( className );
1506		}
1507	};
1508
1509	/* QSA/matchesSelector
1510	---------------------------------------------------------------------- */
1511
1512	// QSA and matchesSelector support
1513
1514	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1515	rbuggyMatches = [];
1516
1517	// qSa(:focus) reports false when true (Chrome 21)
1518	// We allow this because of a bug in IE8/9 that throws an error
1519	// whenever `document.activeElement` is accessed on an iframe
1520	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1521	// See http://bugs.jquery.com/ticket/13378
1522	rbuggyQSA = [];
1523
1524	if ( (support.qsa = isNative(doc.querySelectorAll)) ) {
1525		// Build QSA regex
1526		// Regex strategy adopted from Diego Perini
1527		assert(function( div ) {
1528			// Select is set to empty string on purpose
1529			// This is to test IE's treatment of not explicitly
1530			// setting a boolean content attribute,
1531			// since its presence should be enough
1532			// http://bugs.jquery.com/ticket/12359
1533			div.innerHTML = "<select><option selected=''></option></select>";
1534
1535			// Support: IE8
1536			// Boolean attributes and "value" are not treated correctly
1537			if ( !div.querySelectorAll("[selected]").length ) {
1538				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1539			}
1540
1541			// Webkit/Opera - :checked should return selected option elements
1542			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1543			// IE8 throws error here and will not see later tests
1544			if ( !div.querySelectorAll(":checked").length ) {
1545				rbuggyQSA.push(":checked");
1546			}
1547		});
1548
1549		assert(function( div ) {
1550
1551			// Support: Opera 10-12/IE8
1552			// ^= $= *= and empty values
1553			// Should not select anything
1554			// Support: Windows 8 Native Apps
1555			// The type attribute is restricted during .innerHTML assignment
1556			var input = doc.createElement("input");
1557			input.setAttribute( "type", "hidden" );
1558			div.appendChild( input ).setAttribute( "t", "" );
1559
1560			if ( div.querySelectorAll("[t^='']").length ) {
1561				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1562			}
1563
1564			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1565			// IE8 throws error here and will not see later tests
1566			if ( !div.querySelectorAll(":enabled").length ) {
1567				rbuggyQSA.push( ":enabled", ":disabled" );
1568			}
1569
1570			// Opera 10-11 does not throw on post-comma invalid pseudos
1571			div.querySelectorAll("*,:x");
1572			rbuggyQSA.push(",.*:");
1573		});
1574	}
1575
1576	if ( (support.matchesSelector = isNative( (matches = docElem.webkitMatchesSelector ||
1577		docElem.mozMatchesSelector ||
1578		docElem.oMatchesSelector ||
1579		docElem.msMatchesSelector) )) ) {
1580
1581		assert(function( div ) {
1582			// Check to see if it's possible to do matchesSelector
1583			// on a disconnected node (IE 9)
1584			support.disconnectedMatch = matches.call( div, "div" );
1585
1586			// This should fail with an exception
1587			// Gecko does not error, returns false instead
1588			matches.call( div, "[s!='']:x" );
1589			rbuggyMatches.push( "!=", pseudos );
1590		});
1591	}
1592
1593	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1594	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1595
1596	/* Contains
1597	---------------------------------------------------------------------- */
1598
1599	// Element contains another
1600	// Purposefully does not implement inclusive descendent
1601	// As in, an element does not contain itself
1602	contains = isNative(docElem.contains) || docElem.compareDocumentPosition ?
1603		function( a, b ) {
1604			var adown = a.nodeType === 9 ? a.documentElement : a,
1605				bup = b && b.parentNode;
1606			return a === bup || !!( bup && bup.nodeType === 1 && (
1607				adown.contains ?
1608					adown.contains( bup ) :
1609					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1610			));
1611		} :
1612		function( a, b ) {
1613			if ( b ) {
1614				while ( (b = b.parentNode) ) {
1615					if ( b === a ) {
1616						return true;
1617					}
1618				}
1619			}
1620			return false;
1621		};
1622
1623	/* Sorting
1624	---------------------------------------------------------------------- */
1625
1626	// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
1627	// Detached nodes confoundingly follow *each other*
1628	support.sortDetached = assert(function( div1 ) {
1629		// Should return 1, but returns 4 (following)
1630		return div1.compareDocumentPosition( doc.createElement("div") ) & 1;
1631	});
1632
1633	// Document order sorting
1634	sortOrder = docElem.compareDocumentPosition ?
1635	function( a, b ) {
1636
1637		// Flag for duplicate removal
1638		if ( a === b ) {
1639			hasDuplicate = true;
1640			return 0;
1641		}
1642
1643		var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b );
1644
1645		if ( compare ) {
1646			// Disconnected nodes
1647			if ( compare & 1 ||
1648				(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1649
1650				// Choose the first element that is related to our preferred document
1651				if ( a === doc || contains(preferredDoc, a) ) {
1652					return -1;
1653				}
1654				if ( b === doc || contains(preferredDoc, b) ) {
1655					return 1;
1656				}
1657
1658				// Maintain original order
1659				return sortInput ?
1660					( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1661					0;
1662			}
1663
1664			return compare & 4 ? -1 : 1;
1665		}
1666
1667		// Not directly comparable, sort on existence of method
1668		return a.compareDocumentPosition ? -1 : 1;
1669	} :
1670	function( a, b ) {
1671		var cur,
1672			i = 0,
1673			aup = a.parentNode,
1674			bup = b.parentNode,
1675			ap = [ a ],
1676			bp = [ b ];
1677
1678		// Exit early if the nodes are identical
1679		if ( a === b ) {
1680			hasDuplicate = true;
1681			return 0;
1682
1683		// Parentless nodes are either documents or disconnected
1684		} else if ( !aup || !bup ) {
1685			return a === doc ? -1 :
1686				b === doc ? 1 :
1687				aup ? -1 :
1688				bup ? 1 :
1689				sortInput ?
1690				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1691				0;
1692
1693		// If the nodes are siblings, we can do a quick check
1694		} else if ( aup === bup ) {
1695			return siblingCheck( a, b );
1696		}
1697
1698		// Otherwise we need full lists of their ancestors for comparison
1699		cur = a;
1700		while ( (cur = cur.parentNode) ) {
1701			ap.unshift( cur );
1702		}
1703		cur = b;
1704		while ( (cur = cur.parentNode) ) {
1705			bp.unshift( cur );
1706		}
1707
1708		// Walk down the tree looking for a discrepancy
1709		while ( ap[i] === bp[i] ) {
1710			i++;
1711		}
1712
1713		return i ?
1714			// Do a sibling check if the nodes have a common ancestor
1715			siblingCheck( ap[i], bp[i] ) :
1716
1717			// Otherwise nodes in our document sort first
1718			ap[i] === preferredDoc ? -1 :
1719			bp[i] === preferredDoc ? 1 :
1720			0;
1721	};
1722
1723	return doc;
1724};
1725
1726Sizzle.matches = function( expr, elements ) {
1727	return Sizzle( expr, null, null, elements );
1728};
1729
1730Sizzle.matchesSelector = function( elem, expr ) {
1731	// Set document vars if needed
1732	if ( ( elem.ownerDocument || elem ) !== document ) {
1733		setDocument( elem );
1734	}
1735
1736	// Make sure that attribute selectors are quoted
1737	expr = expr.replace( rattributeQuotes, "='$1']" );
1738
1739	if ( support.matchesSelector && documentIsHTML &&
1740		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1741		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1742
1743		try {
1744			var ret = matches.call( elem, expr );
1745
1746			// IE 9's matchesSelector returns false on disconnected nodes
1747			if ( ret || support.disconnectedMatch ||
1748					// As well, disconnected nodes are said to be in a document
1749					// fragment in IE 9
1750					elem.document && elem.document.nodeType !== 11 ) {
1751				return ret;
1752			}
1753		} catch(e) {}
1754	}
1755
1756	return Sizzle( expr, document, null, [elem] ).length > 0;
1757};
1758
1759Sizzle.contains = function( context, elem ) {
1760	// Set document vars if needed
1761	if ( ( context.ownerDocument || context ) !== document ) {
1762		setDocument( context );
1763	}
1764	return contains( context, elem );
1765};
1766
1767Sizzle.attr = function( elem, name ) {
1768	// Set document vars if needed
1769	if ( ( elem.ownerDocument || elem ) !== document ) {
1770		setDocument( elem );
1771	}
1772
1773	var fn = Expr.attrHandle[ name.toLowerCase() ],
1774		// Don't get fooled by Object.prototype properties (jQuery #13807)
1775		val = ( fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1776			fn( elem, name, !documentIsHTML ) :
1777			undefined );
1778
1779	return val === undefined ?
1780		support.attributes || !documentIsHTML ?
1781			elem.getAttribute( name ) :
1782			(val = elem.getAttributeNode(name)) && val.specified ?
1783				val.value :
1784				null :
1785		val;
1786};
1787
1788Sizzle.error = function( msg ) {
1789	throw new Error( "Syntax error, unrecognized expression: " + msg );
1790};
1791
1792/**
1793 * Document sorting and removing duplicates
1794 * @param {ArrayLike} results
1795 */
1796Sizzle.uniqueSort = function( results ) {
1797	var elem,
1798		duplicates = [],
1799		j = 0,
1800		i = 0;
1801
1802	// Unless we *know* we can detect duplicates, assume their presence
1803	hasDuplicate = !support.detectDuplicates;
1804	sortInput = !support.sortStable && results.slice( 0 );
1805	results.sort( sortOrder );
1806
1807	if ( hasDuplicate ) {
1808		while ( (elem = results[i++]) ) {
1809			if ( elem === results[ i ] ) {
1810				j = duplicates.push( i );
1811			}
1812		}
1813		while ( j-- ) {
1814			results.splice( duplicates[ j ], 1 );
1815		}
1816	}
1817
1818	return results;
1819};
1820
1821/**
1822 * Utility function for retrieving the text value of an array of DOM nodes
1823 * @param {Array|Element} elem
1824 */
1825getText = Sizzle.getText = function( elem ) {
1826	var node,
1827		ret = "",
1828		i = 0,
1829		nodeType = elem.nodeType;
1830
1831	if ( !nodeType ) {
1832		// If no nodeType, this is expected to be an array
1833		for ( ; (node = elem[i]); i++ ) {

1834			// Do not traverse comment nodes
1835			ret += getText( node );
1836		}
1837	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1838		// Use textContent for elements
1839		// innerText usage removed for consistency of new lines (see #11153)
1840		if ( typeof elem.textContent === "string" ) {
1841			return elem.textContent;
1842		} else {
1843			// Traverse its children
1844			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1845				ret += getText( elem );
1846			}
1847		}
1848	} else if ( nodeType === 3 || nodeType === 4 ) {
1849		return elem.nodeValue;
1850	}
1851	// Do not include comment or processing instruction nodes
1852
1853	return ret;
1854};
1855
1856Expr = Sizzle.selectors = {
1857
1858	// Can be adjusted by the user
1859	cacheLength: 50,
1860
1861	createPseudo: markFunction,
1862
1863	match: matchExpr,
1864
1865	attrHandle: {},
1866
1867	find: {},
1868
1869	relative: {
1870		">": { dir: "parentNode", first: true },
1871		" ": { dir: "parentNode" },
1872		"+": { dir: "previousSibling", first: true },
1873		"~": { dir: "previousSibling" }
1874	},
1875
1876	preFilter: {
1877		"ATTR": function( match ) {
1878			match[1] = match[1].replace( runescape, funescape );
1879
1880			// Move the given value to match[3] whether quoted or unquoted
1881			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
1882
1883			if ( match[2] === "~=" ) {
1884				match[3] = " " + match[3] + " ";
1885			}
1886
1887			return match.slice( 0, 4 );
1888		},
1889
1890		"CHILD": function( match ) {
1891			/* matches from matchExpr["CHILD"]
1892				1 type (only|nth|...)
1893				2 what (child|of-type)
1894				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1895				4 xn-component of xn+y argument ([+-]?\d*n|)
1896				5 sign of xn-component
1897				6 x of xn-component
1898				7 sign of y-component
1899				8 y of y-component
1900			*/
1901			match[1] = match[1].toLowerCase();
1902
1903			if ( match[1].slice( 0, 3 ) === "nth" ) {
1904				// nth-* requires argument
1905				if ( !match[3] ) {
1906					Sizzle.error( match[0] );
1907				}
1908
1909				// numeric x and y parameters for Expr.filter.CHILD
1910				// remember that false/true cast respectively to 0/1
1911				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1912				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1913
1914			// other types prohibit arguments
1915			} else if ( match[3] ) {
1916				Sizzle.error( match[0] );
1917			}
1918
1919			return match;
1920		},
1921
1922		"PSEUDO": function( match ) {
1923			var excess,
1924				unquoted = !match[5] && match[2];
1925
1926			if ( matchExpr["CHILD"].test( match[0] ) ) {
1927				return null;
1928			}
1929
1930			// Accept quoted arguments as-is
1931			if ( match[3] && match[4] !== undefined ) {
1932				match[2] = match[4]

1932;
1933
1934			// Strip excess characters from unquoted arguments
1935			} else if ( unquoted && rpseudo.test( unquoted ) &&
1936				// Get excess from tokenize (recursively)
1937				(excess = tokenize( unquoted, true )) &&
1938				// advance to the next closing parenthesis
1939				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1940
1941				// excess is a negative index
1942				match[0] = match[0].slice( 0, excess );
1943				match[2] = unquoted.slice( 0, excess );
1944			}
1945
1946			// Return only captures needed by the pseudo filter method (type and argument)
1947			return match.slice( 0, 3 );
1948		}
1949	},
1950
1951	filter: {
1952
1953		"TAG": function( nodeNameSelector ) {
1954			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1955			return nodeNameSelector === "*" ?
1956				function() { return true; } :
1957				function( elem ) {
1958					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1959				};
1960		},
1961
1962		"CLASS": function( className ) {
1963			var pattern = classCache[ className + " " ];
1964
1965			return pattern ||
1966				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1967				classCache( className, function( elem ) {
1968					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
1969				});
1970		},
1971
1972		"ATTR": function( name, operator, check ) {
1973			return function( elem ) {
1974				var result = Sizzle.attr( elem, name );
1975
1976				if ( result == null ) {
1977					return operator === "!=";
1978				}
1979				if ( !operator ) {
1980					return true;
1981				}
1982
1983				result += "";
1984
1985				return operator === "=" ? result === check :
1986					operator === "!=" ? result !== check :
1987					operator === "^=" ? check && result.indexOf( check ) === 0 :
1988					operator === "*=" ? check && result.indexOf( check ) > -1 :
1989					operator === "$=" ? check && result.slice( -check.length ) === check :
1990					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
1991					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1992					false;
1993			};
1994		},
1995
1996		"CHILD": function( type, what, argument, first, last ) {
1997			var simple = type.slice( 0, 3 ) !== "nth",
1998				forward = type.slice( -4 ) !== "last",
1999				ofType = what === "of-type";
2000
2001			return first === 1 && last === 0 ?
2002
2003				// Shortcut for :nth-*(n)
2004				function( elem ) {
2005					return !!elem.parentNode;
2006				} :
2007
2008				function( elem, context, xml ) {
2009					var cache, outerCache, node, diff, nodeIndex, start,
2010						dir = simple !== forward ? "nextSibling" : "previousSibling",
2011						parent = elem.parentNode,
2012						name = ofType && elem.nodeName.toLowerCase(),
2013						useCache = !xml && !ofType;
2014
2015					if ( parent ) {
2016
2017						// :(first|last|only)-(child|of-type)
2018						if ( simple ) {
2019							while ( dir ) {
2020								node = elem;
2021								while ( (node = node[ dir ]) ) {
2022									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
2023										return false;
2024									}
2025								}
2026								// Reverse direction for :only-* (if we haven't yet done so)
2027								start = dir = type === "only" && !start && "nextSibling";
2028							}
2029							return true;
2030						}
2031
2032						start = [ forward ? parent.firstChild : parent.lastChild ];
2033
2034						// non-xml :nth-child(...) stores cache data on `parent`
2035						if ( forward && useCache ) {
2036							// Seek `elem` from a previously-cached index
2037							outerCache = parent[ expando ] || (parent[ expando ] = {});
2038							cache = outerCache[ type ] || [];
2039							nodeIndex = cache[0] === dirruns && cache[1];
2040							diff = cache[0] === dirruns && cache[2];
2041							node = nodeIndex && parent.childNodes[ nodeIndex ];
2042
2043							while ( (node = ++nodeIndex && node && node[ dir ] ||
2044
2045								// Fallback to seeking `elem` from the start
2046								(diff = nodeIndex = 0) || start.pop()) ) {
2047
2048								// When found, cache indexes on `parent` and break
2049								if ( node.nodeType === 1 && ++diff && node === elem ) {
2050									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
2051									break;
2052								}
2053							}
2054
2055						// Use previously-cached element index if available
2056						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
2057							diff = cache[1];
2058
2059						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
2060						} else {
2061							// Use the same loop as above to seek `elem` from the start
2062							while ( (node = ++nodeIndex && node && node[ dir ] ||
2063								(diff = nodeIndex = 0) || start.pop()) ) {
2064
2065								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
2066									// Cache the index of each encountered element
2067									if ( useCache ) {
2068										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
2069									}
2070
2071									if ( node === elem ) {
2072										break;
2073									}
2074								}
2075							}
2076						}
2077
2078						// Incorporate the offset, then check against cycle size
2079						diff -= last;
2080						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2081					}
2082				};
2083		},
2084
2085		"PSEUDO": function( pseudo, argument ) {
2086			// pseudo-class names are case-insensitive
2087			// http://www.w3.org/TR/selectors/#pseudo-classes
2088			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2089			// Remember that setFilters inherits from pseudos
2090			var args,
2091				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2092					Sizzle.error( "unsupported pseudo: " + pseudo );
2093
2094			// The user may use createPseudo to indicate that
2095			// arguments are needed to create the filter function
2096			// just as Sizzle does
2097			if ( fn[ expando ] ) {
2098				return fn( argument );
2099			}
2100
2101			// But maintain support for old signatures
2102			if ( fn.length > 1 ) {
2103				args = [ pseudo, pseudo, "", argument ];
2104				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2105					markFunction(function( seed, matches ) {
2106						var idx,
2107							matched = fn( seed, argument ),
2108							i = matched.length;
2109						while ( i-- ) {
2110							idx = indexOf.call( seed, matched[i] );
2111							seed[ idx ] = !( matches[ idx ] = matched[i] );
2112						}
2113					}) :
2114					function( elem ) {
2115						return fn( elem, 0, args );
2116					};
2117			}
2118
2119			return fn;
2120		}
2121	},
2122
2123	pseudos: {
2124		// Potentially complex pseudos
2125		"not": markFunction(function( selector ) {
2126			// Trim the selector passed to compile
2127			// to avoid treating leading and trailing
2128			// spaces as combinators
2129			var input = [],
2130				results = [],
2131				matcher = compile( selector.replace( rtrim, "$1" ) );
2132
2133			return matcher[ expando ] ?
2134				markFunction(function( seed, matches, context, xml ) {
2135					var elem,
2136						unmatched = matcher( seed, null, xml, [] ),
2137						i = seed.length;
2138
2139					// Match elements unmatched by `matcher`
2140					while ( i-- ) {
2141						if ( (elem = unmatched[i]) ) {
2142							seed[i] = !(matches[i] = elem);
2143						}
2144					}
2145				}) :
2146				function( elem, context, xml ) {
2147					input[0] = elem;
2148					matcher( input, null, xml, results );
2149					return !results.pop();
2150				};
2151		}),
2152
2153		"has": markFunction(function( selector ) {
2154			return function( elem ) {
2155				return Sizzle( selector, elem ).length > 0;
2156			};
2157		}),
2158
2159		"contains": markFunction(function( text ) {
2160			return function( elem ) {
2161				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2162			};
2163		}),
2164
2165		// "Whether an element is represented by a :lang() selector
2166		// is based solely on the element's language value
2167		// being equal to the identifier C,
2168		// or beginning with the identifier C immediately followed by "-".
2169		// The matching of C against the element's language value is performed case-insensitively.
2170		// The identifier C does not have to be a valid language name."
2171		// http://www.w3.org/TR/selectors/#lang-pseudo
2172		"lang": markFunction( function( lang ) {
2173			// lang value must be a valid identifier
2174			if ( !ridentifier.test(lang || "") ) {
2175				Sizzle.error( "unsupported lang: " + lang );
2176			}
2177			lang = lang.replace( runescape, funescape ).toLowerCase();
2178			return function( elem ) {
2179				var elemLang;
2180				do {
2181					if ( (elemLang = documentIsHTML ?
2182						elem.lang :
2183						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2184
2185						elemLang = elemLang.toLowerCase();
2186						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2187					}
2188				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2189				return false;
2190			};
2191		}),
2192
2193		// Miscellaneous
2194		"target": function( elem ) {
2195			var hash = window.location && window.location.hash;
2196			return hash && hash.slice( 1 ) === elem.id;
2197		},
2198
2199		"root": function( elem ) {
2200			return elem === docElem;
2201		},
2202
2203		"focus": function( elem ) {
2204			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2205		},
2206
2207		// Boolean properties
2208		"enabled": function( elem ) {
2209			return elem.disabled === false;
2210		},
2211
2212		"disabled": function( elem ) {
2213			return elem.disabled === true;
2214		},
2215
2216		"checked": function( elem ) {
2217			// In CSS3, :checked should return both checked and selected elements
2218			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2219			var nodeName = elem.nodeName.toLowerCase();
2220			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2221		},
2222
2223		"selected": function( elem ) {
2224			// Accessing this property makes selected-by-default
2225			// options in Safari work properly
2226			if ( elem.parentNode ) {
2227				elem.parentNode.selectedIndex;
2228			}
2229
2230			return elem.selected === true;
2231		},
2232
2233		// Contents
2234		"empty": function( elem ) {
2235			// http://www.w3.org/TR/selectors/#empty-pseudo
2236			// :empty is 

2236only affected by element nodes and content nodes(including text(3), cdata(4)),
2237			//   not comment, processing instructions, or others
2238			// Thanks to Diego Perini for the nodeName shortcut
2239			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
2240			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2241				if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
2242					return false;
2243				}
2244			}
2245			return true;
2246		},
2247
2248		"parent": function( elem ) {
2249			return !Expr.pseudos["empty"]( elem );
2250		},
2251
2252		// Element/input types
2253		"header": function( elem ) {
2254			return rheader.test( elem.nodeName );
2255		},
2256
2257		"input": function( elem ) {
2258			return rinputs.test( elem.nodeName );
2259		},
2260
2261		"button": function( elem ) {
2262			var name = elem.nodeName.toLowerCase();
2263			return name === "input" && elem.type === "button" || name === "button";
2264		},
2265
2266		"text": function( elem ) {
2267			var attr;
2268			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
2269			// use getAttribute instead to test this case
2270			return elem.nodeName.toLowerCase() === "input" &&
2271				elem.type === "text" &&
2272				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
2273		},
2274
2275		// Position-in-collection
2276		"first": createPositionalPseudo(function() {
2277			return [ 0 ];
2278		}),
2279
2280		"last": createPositionalPseudo(function( matchIndexes, length ) {
2281			return [ length - 1 ];
2282		}),
2283
2284		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2285			return [ argument < 0 ? argument + length : argument ];
2286		}),
2287
2288		"even": createPositionalPseudo(function( matchIndexes, length ) {
2289			var i = 0;
2290			for ( ; i < length; i += 2 ) {
2291				matchIndexes.push( i );
2292			}
2293			return matchIndexes;
2294		}),
2295
2296		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2297			var i = 1;
2298			for ( ; i < length; i += 2 ) {
2299				matchIndexes.push( i );
2300			}
2301			return matchIndexes;
2302		}),
2303
2304		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2305			var i = argument < 0 ? argument + length : argument;
2306			for ( ; --i >= 0; ) {
2307				matchIndexes.push( i );
2308			}
2309			return matchIndexes;
2310		}),
2311
2312		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2313			var i = argument < 0 ? argument + length : argument;
2314			for ( ; ++i < length; ) {
2315				matchIndexes.push( i );
2316			}
2317			return matchIndexes;
2318		})
2319	}
2320};
2321
2322// Add button/input type pseudos
2323for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2324	Expr.pseudos[ i ] = createInputPseudo( i );
2325}
2326for ( i in { submit: true, reset: true } ) {
2327	Expr.pseudos[ i ] = createButtonPseudo( i );
2328}
2329
2330function tokenize( selector, parseOnly ) {
2331	var matched, match, tokens, type,
2332		soFar, groups, preFilters,
2333		cached = tokenCache[ selector + " " ];
2334
2335	if ( cached ) {
2336		return parseOnly ? 0 : cached.slice( 0 );
2337	}
2338
2339	soFar = selector;
2340	groups = [];
2341	preFilters = Expr.preFilter;
2342
2343	while ( soFar ) {
2344
2345		// Comma and first run
2346		if ( !matched || (match = rcomma.exec( soFar )) ) {
2347			if ( match ) {
2348				// Don't consume trailing commas as valid
2349				soFar = soFar.slice( match[0].length ) || soFar;
2350			}
2351			groups.push( tokens = [] );
2352		}
2353
2354		matched = false;

2355
2356		// Combinators
2357		if ( (match = rcombinators.exec( soFar )) ) {
2358			matched = match.shift();
2359			tokens.push({
2360				value: matched,
2361				// Cast descendant combinators to space
2362				type: match[0].replace( rtrim, " " )
2363			});
2364			soFar = soFar.slice( matched.length );
2365		}
2366
2367		// Filters
2368		for ( type in Expr.filter ) {
2369			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2370				(match = preFilters[ type ]( match ))) ) {
2371				matched = match.shift();
2372				tokens.push({
2373					value: matched,
2374					type: type,
2375					matches: match
2376				});
2377				soFar = soFar.slice( matched.length );
2378			}
2379		}
2380
2381		if ( !matched ) {
2382			break;
2383		}
2384	}
2385
2386	// Return the length of the invalid excess
2387	// if we're just parsing
2388	// Otherwise, throw an error or return tokens
2389	return parseOnly ?
2390		soFar.length :
2391		soFar ?
2392			Sizzle.error( selector ) :
2393			// Cache the tokens
2394			tokenCache( selector, groups ).slice( 0 );
2395}
2396
2397function toSelector( tokens ) {
2398	var i = 0,
2399		len = tokens.length,
2400		selector = "";
2401	for ( ; i < len; i++ ) {
2402		selector += tokens[i].value;
2403	}
2404	return selector;
2405}
2406
2407function addCombinator( matcher, combinator, base ) {
2408	var dir = combinator.dir,
2409		checkNonElements = base && dir === "parentNode",
2410		doneName = done++;
2411
2412	return combinator.first ?
2413		// Check against closest ancestor/preceding element
2414		function( elem, context, xml ) {
2415			while ( (elem = elem[ dir ]) ) {
2416				if ( elem.nodeType === 1 || checkNonElements ) {
2417					return matcher( elem, context, xml );
2418				}
2419			}
2420		} :
2421
2422		// Check against all ancestor/preceding elements
2423		function( elem, context, xml ) {
2424			var data, cache, outerCache,
2425				dirkey = dirruns + " " + doneName;
2426
2427			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2428			if ( xml ) {
2429				while ( (elem = elem[ dir ]) ) {
2430					if ( elem.nodeType === 1 || checkNonElements ) {
2431						if ( matcher( elem, context, xml ) ) {
2432							return true;
2433						}
2434					}
2435				}
2436			} else {
2437				while ( (elem = elem[ dir ]) ) {
2438					if ( elem.nodeType === 1 || checkNonElements ) {
2439						outerCache = elem[ expando ] || (elem[ expando ] = {});
2440						if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
2441							if ( (data = cache[1]) === true || data === cachedruns ) {
2442								return data === true;
2443							}
2444						} else {
2445							cache = outerCache[ dir ] = [ dirkey ];
2446							cache[1] = matcher( elem, context, xml ) || cachedruns;
2447							if ( cache[1] === true ) {
2448								return true;
2449							}
2450						}
2451					}
2452				}
2453			}
2454		};
2455}
2456
2457function elementMatcher( matchers ) {
2458	return matchers.length > 1 ?
2459		function( elem, context, xml ) {
2460			var i = matchers.length;
2461			while ( i-- ) {
2462				if ( !matchers[i]( elem, context, xml ) ) {
2463					return false;
2464				}
2465			}
2466			return true;
2467		} :
2468		matchers[0];
2469}
2470
2471function condense( unmatched, map, filter, context, xml ) {
2472	var elem,
2473		newUnmatched = [],
2474		i = 0,
2475		len = unmatched.length,
2476		mapped = map != null;
2477
2478	for ( ; i < len; i++ ) {
2479		if ( (elem = unmatched[i]) ) {
2480			if ( !filter || filter( elem, context, xml ) ) {
2481				newUnmatched.push( elem );
2482				if ( mapped ) {
2483					map.push( i );
2484				}
2485			}
2486		}
2487	}
2488
2489	return newUnmatched;
2490}
2491
2492function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2493	if ( postFilter && !postFilter[ expando ] ) {
2494		postFilter = setMatcher( postFilter );
2495	}
2496	if ( postFinder && !postFinder[ expando ] ) {
2497		postFinder = setMatcher( postFinder, postSelector );
2498	}
2499	return markFunction(function( seed, results, context, xml ) {
2500		var temp, i, elem,
2501			preMap = [],
2502			postMap = [],
2503			preexisting = results.length,
2504
2505			// Get initial elements from seed or context
2506			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2507
2508			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2509			matcherIn = preFilter && ( seed || !selector ) ?
2510				condense( elems, preMap, preFilter, context, xml ) :
2511				elems,
2512
2513			matcherOut = matcher ?
2514				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2515				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2516
2517					// ...intermediate processing is necessary
2518					[] :
2519
2520					// ...otherwise use results directly
2521					results :
2522				matcherIn;
2523
2524		// Find primary matches
2525		if ( matcher ) {
2526			matcher( matcherIn, matcherOut, context, xml );
2527		}
2528
2529		// Apply postFilter
2530		if ( postFilter ) {
2531			temp = condense( matcherOut, postMap );
2532			postFilter( temp, [], context, xml );
2533
2534			// Un-match failing elements by moving them back to matcherIn
2535			i = temp.length;
2536			while ( i-- ) {
2537				if ( (elem = temp[i]) ) {
2538					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2539				}
2540			}
2541		}
2542
2543		if ( seed ) {
2544			if ( postFinder || preFilter ) {
2545				if ( postFinder ) {
2546					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2547					temp = [];
2548					i = matcherOut.length;
2549					while ( i-- ) {
2550						if ( (elem = matcherOut[i]) ) {
2551							// Restore matcherIn since elem is not yet a final match
2552							temp.push( (matcherIn[i] = elem) );
2553						}
2554					}
2555					postFinder( null, (matcherOut = []), temp, xml );
2556				}
2557
2558				// Move matched elements from seed to results to keep them synchronized
2559				i = matcherOut.length;
2560				while ( i-- ) {
2561					if ( (elem = matcherOut[i]) &&
2562						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2563
2564						seed[temp] = !(results[temp] = elem);
2565					}
2566				}
2567			}
2568
2569		// Add elements to results, through postFinder if defined
2570		} else {
2571			matcherOut = condense(
2572				matcherOut === results ?
2573					matcherOut.splice( preexisting, matcherOut.length ) :
2574					matcherOut
2575			);
2576			if ( postFinder ) {
2577				postFinder( null, results, matcherOut, xml );
2578			} else {
2579				push.apply( results, matcherOut );
2580			}
2581		}
2582	});
2583}
2584
2585function matcherFromTokens( tokens ) {
2586	var checkContext, matcher, j,
2587		len = tokens.length,
2588		leadingRelative = Expr.relative[ tokens[0].type ],
2589		implicitRelative = leadingRelative || Expr.relative[" "],
2590		i = leadingRelative ? 1 : 0,
2591
2592		// The foundational matcher ensures that elements are reachable from top-level context(s)
2593		matchContext = addCombinator( function( elem ) {
2594			return elem === checkContext;
2595		}, implicitRelative, true ),
2596		matchAnyContext = addCombinator( function( elem ) {
2597			return indexOf.call( checkContext, elem ) > -1;
2598		}, implicitRelative, true ),
2599		matchers = [ function( elem, context, xml ) {
2600			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2601				(checkContext = context).nodeType ?
2602					matchContext( elem, context, xml ) :
2603					matchAnyContext( elem, context, xml ) );
2604		} ];
2605
2606	for ( ; i < len; i++ ) {
2607		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2608			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2609		} else {
2610			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2611
2612			// Return special upon seeing a positional matcher
2613			if ( matcher[ expando ] ) {
2614				// Find the next relative operator (if any) for proper handling
2615				j = ++i;
2616				for ( ; j < len; j++ ) {
2617					if ( Expr.relative[ tokens[j].type ] ) {
2618						break;
2619					}
2620				}
2621				return setMatcher(
2622					i > 1 && elementMatcher( matchers ),
2623					i > 1 && toSelector(
2624						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2625						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2626					).replace( rtrim, "$1" ),
2627					matcher,
2628					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2629					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2630					j < len && toSelector( tokens )
2631				);
2632			}
2633			matchers.push( matcher );
2634		}
2635	}
2636
2637	return elementMatcher( matchers );
2638}
2639
2640function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2641	// A counter to specify which element is currently being matched
2642	var matcherCachedRuns = 0,
2643		bySet = setMatchers.length > 0,
2644		byElement = elementMatchers.length > 0,
2645		superMatcher = function( seed, context, xml, results, expandContext ) {
2646			var elem, j, matcher,
2647				setMatched = [],
2648				matchedCount = 0,
2649				i = "0",
2650				unmatched = seed && [],
2651				outermost = expandContext != null,
2652				contextBackup = outermostContext,
2653				// We must always have either seed elements or context
2654				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
2655				// Use integer dirruns iff this is the outermost matcher
2656				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
2657
2658			if ( outermost ) {
2659				outermostContext = context !== document && context;
2660				cachedruns = matcherCachedRuns;
2661			}
2662
2663			// Add elements passing elementMatchers directly to results
2664			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2665			for ( ; (elem = elems[i]) != null; i++ ) {
2666				if ( byElement && elem ) {
2667					j = 0;
2668					while ( (matcher = elementMatchers[j++]) ) {
2669						if ( matcher( elem, context, xml ) ) {
2670							results.push( elem );
2671							break;
2672						}
2673					}
2674					if ( outermost ) {
2675						dirruns = dirrunsUnique;
2676						cachedruns = ++matcherCachedRuns;
2677					}
2678				}
2679
2680				// Track unmatched elements for set filters
2681				if ( bySet ) {
2682					// They will have gone through all possible matchers
2683					if ( (elem = !matcher && elem) ) {
2684						matchedCount--;
2685					}
2686
2687					// Lengthen the array for every element, matched or not
2688					if ( seed ) {
2689						unmatched.push( elem );
2690					}
2691				}
2692			}
2693
2694			// Apply set filters to unmatched elements
2695			matchedCount += i;
2696			if ( bySet && i !== matchedCount ) {
2697				j = 0;
2698				while ( (matcher = setMatchers[j++]) ) {
2699					matcher( unmatched, setMatched, context, xml );
2700				}
2701
2702				if ( seed ) {
2703					// Reintegrate element matches to eliminate the need for sorting
2704					if ( matchedCount > 0 ) {
2705						while ( i-- ) {
2706							if ( !(unmatched[i] || setMatched[i]) ) {
2707								setMatched[i] = pop.call( results );
2708							}
2709						}
2710					}
2711
2712					// Discard index placeholder values to get only actual matches
2713					setMatched = condense( setMatched );
2714				}
2715
2716				// Add matches to results
2717				push.apply( results, setMatched );
2718
2719				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2720				if ( outermost && !seed && setMatched.length > 0 &&
2721					( matchedCount + setMatchers.length ) > 1 ) {
2722
2723					Sizzle.uniqueSort( results );
2724				}
2725			}
2726
2727			// Override manipulation of globals by nested matchers
2728			if ( outermost ) {
2729				dirruns = dirrunsUnique;
2730				outermostContext = contextBackup;
2731			}
2732
2733			return unmatched;
2734		};
2735
2736	return bySet ?
2737		markFunction( superMatcher ) :
2738		superMatcher;
2739}
2740
2741compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
2742	var i,
2743		setMatchers = [],
2744		elementMatchers = [],
2745		cached = compilerCache[ selector + " " ];
2746
2747	if ( !cached ) {
2748		// Generate a function of recursive functions that can be used to check each element
2749		if ( !group ) {
2750			group = tokenize( selector );
2751		}
2752		i = group.length;
2753		while ( i-- ) {
2754			cached = matcherFromTokens( group[i] );
2755			if ( cached[ expando ] ) {
2756				setMatchers.push( cached );
2757			} else {
2758				elementMatchers.push( cached );
2759			}
2760		}
2761
2762		// Cache the compiled function
2763		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2764	}
2765	return cached;
2766};
2767
2768function multipleContexts( selector, contexts, results ) {
2769	var i = 0,
2770		len = contexts.length;
2771	for ( ; i < len; i++ ) {
2772		Sizzle( selector, contexts[i], results );
2773	}
2774	return results;
2775}
2776
2777function select( selector, context, results, seed ) {
2778	var i, tokens, token, type, find,
2779		match = tokenize( selector );
2780
2781	if ( !seed ) {
2782		// Try to minimize operations if there is only one group
2783		if ( match.length === 1 ) {
2784
2785			// Take a shortcut and set the context if the root selector is an ID
2786			tokens = match[0] = match[0].slice( 0 );
2787			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2788					support.getById && context.nodeType === 9 && documentIsHTML &&
2789					Expr.relative[ tokens[1].type ] ) {
2790
2791				context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2792				if ( !context ) {
2793					return results;
2794				}
2795				selector = selector.slice( tokens.shift().value.length );
2796			}
2797
2798			// Fetch a seed set for right-to-left matching
2799			i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2800			while ( i-- ) {
2801				token = tokens[i];
2802
2803				// Abort if we hit a combinator
2804				if ( Expr.relative[ (type = token.type) ] ) {
2805					break;
2806				}
2807				if ( (find = Expr.find[ type ]) ) {
2808					// Search, expanding context for leading sibling combinators
2809					if ( (seed = find(
2810						token.matches[0].replace( runescape, funescape ),
2811						rsibling.test( tokens[0].type ) && context.parentNode || context
2812					)) ) {
2813
2814						// If seed is empty or no tokens remain, we can return early
2815						tokens.splice( i, 1 );
2816						selector = seed.length && toSelector( tokens );
2817						if ( !selector ) {
2818							push.apply( results, seed );
2819							return results;
2820						}
2821
2822						break;
2823					}
2824				}
2825			}
2826		}
2827	}
2828
2829	// Compile and execute a filtering function
2830	// Provide `match` to avoid retokenization if we modified the selector above
2831	compile( selector, match )(
2832		seed,
2833		context,
2834		!documentIsHTML,
2835		results,
2836		rsibling.test( selector )
2837	);
2838	return results;
2839}
2840
2841// Deprecated
2842Expr.pseudos["nth"] = Expr.pseudos["eq"];
2843
2844// Easy API for creating new setFilters
2845function setFilters() {}
2846setFilters.prototype = Expr.filters = Expr.pseudos;
2847Expr.setFilters = new setFilters();
2848
2849// One-time assignments
2850
2851// Sort stability
2852support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2853
2854// Initialize against the default document
2855setDocument();
2856
2857// Support: Chrome<<14
2858// Always assume duplicates if they aren't passed to the comparison function
2859[0, 0].sort( sortOrder );
2860support.detectDuplicates = hasDuplicate;
2861
2862jQuery.find = Sizzle;
2863jQuery.expr = Sizzle.selectors;
2864jQuery.expr[":"] = jQuery.expr.pseudos;
2865jQuery.unique = Sizzle.uniqueSort;
2866jQuery.text = Sizzle.getText;
2867jQuery.isXMLDoc = Sizzle.isXML;
2868jQuery.contains = Sizzle.contains;
2869
2870
2871})( window );
2872// String to Object options format cache
2873var optionsCache = {};
2874
2875// Convert String-formatted options into Object-formatted ones and store in cache
2876function createOptions( options ) {
2877	var object = optionsCache[ options ] = {};
2878	jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
2879		object[ flag ] = true;
2880	});
2881	return object;
2882}
2883
2884/*
2885 * Create a callback list using the following parameters:
2886 *
2887 *	options: an optional list of space-separated options that will change how
2888 *			the callback list behaves or a more traditional option object
2889 *
2890 * By default a callback list will act like an event callback list and can be
2891 * "fired" multiple times.
2892 *
2893 * Possible options:
2894 *
2895 *	once:			will ensure the callback list can only be fired once (like a Deferred)
2896 *
2897 *	memory:			will keep track of previous values and will call any callback added
2898 *					after the list has been fired right away with the latest "memorized"
2899 *					values (like a Deferred)
2900 *
2901 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
2902 *
2903 *	stopOnFalse:	interrupt callings when a callback returns false
2904 *
2905 */
2906jQuery.Callbacks = function( options ) {
2907
2908	// Convert options from String-formatted to Object-formatted if needed
2909	// (we check in cache first)
2910	options = typeof options === "string" ?
2911		( optionsCache[ options ] || createOptions( options ) ) :
2912		jQuery.extend( {}, options );
2913
2914	var // Last fire value (for non-forgettable lists)
2915		memory,
2916		// Flag to know if list was already fired
2917		fired,
2918		// Flag to know if list is currently firing
2919		firing,
2920		// First callback to fire (used internally by add and fireWith)
2921		firingStart,
2922		// End of the loop when firing
2923		firingLength,
2924		// Index of currently firing callback (modified by remove if needed)
2925		firingIndex,
2926		// Actual callback list
2927		list = [],
2928		// Stack of fire calls for repeatable lists
2929		stack = !options.once && [],
2930		// Fire callbacks
2931		fire = function( data ) {
2932			memory = options.memory && data;
2933			fired = true;
2934			firingIndex = firingStart || 0;
2935			firingStart = 0;
2936			firingLength = list.length;
2937			firing = true;
2938			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
2939				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
2940					memory = false; // To prevent further calls using add
2941					break;
2942				}
2943			}
2944			firing = false;
2945			if ( list ) {
2946				if ( stack ) {
2947					if ( stack.length ) {
2948						fire( stack.shift() );
2949					}
2950				} else if ( memory ) {
2951					list = [];
2952				} else {
2953					self.disable();
2954				}
2955			}
2956		},
2957		// Actual Callbacks object
2958		self = {
2959			// Add a callback or a collection of callbacks to the list
2960			add: function() {
2961				if ( list ) {
2962					// First, we save the current length
2963					var start = list.length;
2964					(function add( args ) {
2965						jQuery.each( args, function( _, arg ) {
2966							var type = jQuery.type( arg );
2967							if ( type === "function" ) {
2968								if ( !options.unique || !self.has( arg ) ) {
2969									list.push( arg );
2970								}
2971							} else if ( arg && arg.length && type !== "string" ) {
2972								// Inspect recursively
2973								add( arg );
2974							}
2975						});
2976					})( arguments );
2977					// Do we need to add the callbacks to the
2978					// current firing batch?
2979					if ( firing ) {
2980						firingLength = list.length;
2981					// With memory, if we're not firing then
2982					// we should call right away
2983					} else if ( memory ) {
2984						firingStart = start;
2985						fire( memory );
2986					}
2987				}
2988				return this;
2989			},
2990			// Remove a callback from the list
2991			remove: function() {
2992				if ( list ) {
2993					jQuery.each( arguments, function( _, arg ) {
2994						var index;
2995						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
2996							list.splice( index, 1 );
2997							// Handle firing indexes
2998							if ( firing ) {
2999								if ( index <= firingLength ) {
3000									firingLength--;
3001								}
3002								if ( index <= firingIndex ) {
3003									firingIndex--;
3004								}
3005							}
3006						}
3007					});
3008				}
3009				return this;
3010			},
3011			// Check if a given callback is in the list.
3012			// If no argument is given, return whether or not list has callbacks attached.
3013			has: function( fn ) {
3014				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
3015			},
3016			// Remove all callbacks from the list
3017			empty: function() {
3018				list = [];
3019				firingLength = 0;
3020				return this;
3021			},
3022			// Have the list do nothing anymore
3023			disable: function() {
3024				list = stack = memory = undefined;
3025				return this;
3026			},
3027			// Is it disabled?
3028			disabled: function() {
3029				return !list;
3030			},
3031			// Lock the list in its current state
3032			lock: function() {
3033				stack = undefined;
3034				if ( !memory ) {
3035					self.disable();
3036				}
3037				return this;
3038			},
3039			// Is it locked?
3040			locked: function() {
3041				return !stack;
3042			},
3043			// Call all callbacks with the given context and arguments
3044			fireWith: function( context, args ) {
3045				args = args || [];
3046				args = [ context, args.slice ? args.slice() : args ];
3047				if ( list && ( !fired || stack ) ) {
3048					if ( firing ) {
3049						stack.push( args );
3050					} else {
3051						fire( args );
3052					}
3053				}
3054				return this;
3055			},
3056			// Call all the callbacks with the given arguments
3057			fire: function() {
3058				self.fireWith( this, arguments );
3059				return this;
3060			},
3061			// To know if the callbacks have already been called at least once
3062			fired: function() {
3063				return !!fired;
3064			}
3065		};
3066
3067	return self;
3068};
3069jQuery.extend({
3070
3071	Deferred: function( func ) {
3072		var tuples = [
3073				// action, add listener, listener list, final state
3074				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
3075				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
3076				[ "notify", "progress", jQuery.Callbacks("memory") ]
3077			],
3078			state = "pending",
3079			promise = {
3080				state: function() {
3081					return state;
3082				},
3083				always: function() {
3084					deferred.done( arguments ).fail( arguments );
3085					return this;
3086				},
3087				then: function( /* fnDone, fnFail, fnProgress */ ) {
3088					var fns = arguments;
3089					return jQuery.Deferred(function( newDefer ) {
3090						jQuery.each( tuples, function( i, tuple ) {
3091							var action = tuple[ 0 ],