https://threeriver.net/wp-content/themes/threeriver/assets/scripts/app.js?ver=1761767127

1/*!
2 * jQuery JavaScript Library v2.0.3
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-07-03T13:30Z
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.3",
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};

1008		// Support: Firefox
1009		// Workaround erroneous numeric interpretation of +"0x"
1010		return high !== high || escapedWhitespace ?
1011			escaped :
1012			// BMP codepoint
1013			high < 0 ?
1014				String.fromCharCode( high + 0x10000 ) :
1015				// Supplemental Plane codepoint (surrogate pair)
1016				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1017	};
1018
1019// Optimize for push.apply( _, NodeList )
1020try {
1021	push.apply(
1022		(arr = slice.call( preferredDoc.childNodes )),
1023		preferredDoc.childNodes
1024	);
1025	// Support: Android<4.0
1026	// Detect silently failing push.apply
1027	arr[ preferredDoc.childNodes.length ].nodeType;
1028} catch ( e ) {
1029	push = { apply: arr.length ?
1030
1031		// Leverage slice if possible
1032		function( target, els ) {
1033			push_native.apply( target, slice.call(els) );
1034		} :
1035
1036		// Support: IE<9
1037		// Otherwise append directly
1038		function( target, els ) {
1039			var j = target.length,
1040				i = 0;
1041			// Can't trust NodeList.length
1042			while ( (target[j++] = els[i++]) ) {}
1043			target.length = j - 1;
1044		}
1045	};
1046}
1047
1048function Sizzle( selector, context, results, seed ) {
1049	var match, elem, m, nodeType,
1050		// QSA vars
1051		i, groups, old, nid, newContext, newSelector;
1052
1053	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
1054		setDocument( context );
1055	}
1056
1057	context = context || document;
1058	results = results || [];
1059
1060	if ( !selector || typeof selector !== "string" ) {
1061		return results;
1062	}
1063
1064	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
1065		return [];
1066	}
1067
1068	if ( documentIsHTML && !seed ) {
1069
1070		// Shortcuts
1071		if ( (match = rquickExpr.exec( selector )) ) {
1072			// Speed-up: Sizzle("#ID")
1073			if ( (m = match[1]) ) {
1074				if ( nodeType === 9 ) {
1075					elem = context.getElementById( m );
1076					// Check parentNode to catch when Blackberry 4.6 returns
1077					// nodes that are no longer in the document #6963
1078					if ( elem && elem.parentNode ) {
1079						// Handle the case where IE, Opera, and Webkit return items
1080						// by name instead of ID
1081						if ( elem.id === m ) {
1082							results.push( elem );
1083							return results;
1084						}
1085					} else {
1086						return results;
1087					}
1088				} else {
1089					// Context is not a document
1090					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
1091						contains( context, elem ) && elem.id === m ) {
1092						results.push( elem );
1093						return results;
1094					}
1095				}
1096
1097			// Speed-up: Sizzle("TAG")
1098			} else if ( match[2] ) {
1099				push.apply( results, context.getElementsByTagName( selector ) );
1100				return results;
1101
1102			// Speed-up: Sizzle(".CLASS")
1103			} else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {
1104				push.apply( results, context.getElementsByClassName( m ) );
1105				return results;
1106			}
1107		}
1108
1109		// QSA path
1110		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
1111			nid = old = expando;
1112			newContext = context;
1113			newSelector = nodeType === 9 && selector;
1114
1115			// qSA works strangely on Element-rooted queries
1116			// We can work around this by specifying an extra ID on the root
1117			// and working up from there (Thanks to Andrew Dupont for the technique)
1118			// IE 8 doesn't work on object elements
1119			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
1120				groups = tokenize( selector );
1121
1122				if ( (old = context.getAttribute("id")) ) {
1123					nid = old.replace( rescape, "\\$&" );
1124				} else {
1125					context.setAttribute( "id", nid );
1126				}
1127				nid = "[id='" + nid + "'] ";
1128
1129				i = groups.length;
1130				while ( i-- ) {
1131					groups[i] = nid + toSelector( groups[i] );
1132				}
1133				newContext = rsibling.test( selector ) && context.parentNode || context;
1134				newSelector = groups.join(",");
1135			}
1136
1137			if ( newSelector ) {
1138				try {
1139					push.apply( results,
1140						newContext.querySelectorAll( newSelector )
1141					);
1142					return results;
1143				} catch(qsaError) {
1144				} finally {
1145					if ( !old ) {
1146						context.removeAttribute("id");
1147					}
1148				}
1149			}
1150		}
1151	}
1152
1153	// All others
1154	return select( selector.replace( rtrim, "$1" ), context, results, seed );
1155}
1156
1157/**
1158 * Create key-value caches of limited size
1159 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
1160 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1161 *	deleting the oldest entry
1162 */
1163function createCache() {
1164	var keys = [];
1165
1166	function cache( key, value ) {
1167		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1168		if ( keys.push( key += " " ) > Expr.cacheLength ) {
1169			// Only keep the most recent entries
1170			delete cache[ keys.shift() ];
1171		}
1172		return (cache[ key ] = value);
1173	}
1174	return cache;
1175}
1176
1177/**
1178 * Mark a function for special use by Sizzle
1179 * @param {Function} fn The function to mark
1180 */
1181function markFunction( fn ) {
1182	fn[ expando ] = true;
1183	return fn;
1184}
1185
1186/**
1187 * Support testing using an element
1188 * @param {Function} fn Passed the created div and expects a boolean result
1189 */
1190function assert( fn ) {
1191	var div = document.createElement("div");
1192
1193	try {
1194		return !!fn( div );
1195	} catch (e) {
1196		return false;
1197	} finally {
1198		// Remove from its parent by default
1199		if ( div.parentNode ) {
1200			div.parentNode.removeChild( div );
1201		}
1202		// release memory in IE
1203		div = null;
1204	}
1205}
1206
1207/**
1208 * Adds the same handler for all of the specified attrs
1209 * @param {String} attrs Pipe-separated list of attributes
1210 * @param {Function} handler The method that will be applied
1211 */
1212function addHandle( attrs, handler ) {
1213	var arr = attrs.split("|"),
1214		i = attrs.length;
1215
1216	while ( i-- ) {
1217		Expr.attrHandle[ arr[i] ] = handler;
1218	}
1219}
1220
1221/**
1222 * Checks document order of two siblings
1223 * @param {Element} a
1224 * @param {Element} b
1225 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1226 */
1227function siblingCheck( a, b ) {
1228	var cur = b && a,
1229		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1230			( ~b.sourceIndex || MAX_NEGATIVE ) -
1231			( ~a.sourceIndex || MAX_NEGATIVE );
1232
1233	// Use IE sourceIndex if available on both nodes
1234	if ( diff ) {
1235		return diff;
1236	}
1237
1238	// Check if b follows a
1239	if ( cur ) {
1240		while ( (cur = cur.nextSibling) ) {
1241			if ( cur === b ) {
1242				return -1;
1243			}
1244		}
1245	}
1246
1247	return a ? 1 : -1;
1248}
1249
1250/**
1251 * Returns a function to use in pseudos for input types
1252 * @param {String} type
1253 */
1254function createInputPseudo( type ) {
1255	return function( elem ) {
1256		var name = elem.nodeName.toLowerCase();
1257		return name === "input" && elem.type === type;
1258	};
1259}
1260
1261/**
1262 * Returns a function to use in pseudos for buttons
1263 * @param {String} type
1264 */
1265function createButtonPseudo( type ) {
1266	return function( elem ) {
1267		var name = elem.nodeName.toLowerCase();
1268		return (name === "input" || name === "button") && elem.type === type;
1269	};
1270}
1271
1272/**
1273 * Returns a function to use in pseudos for positionals
1274 * @param {Function} fn
1275 */
1276function createPositionalPseudo( fn ) {
1277	return markFunction(function( argument ) {
1278		argument = +argument;
1279		return markFunction(function( seed, matches ) {
1280			var j,
1281				matchIndexes = fn( [], seed.length, argument ),
1282				i = matchIndexes.length;
1283
1284			// Match elements found at the specified indexes
1285			while ( i-- ) {
1286				if ( seed[ (j = matchIndexes[i]) ] ) {
1287					seed[j] = !(matches[j] = seed[j]);
1288				}
1289			}
1290		});
1291	});
1292}
1293
1294/**
1295 * Detect xml
1296 * @param {Element|Object} elem An element or a document
1297 */
1298isXML = Sizzle.isXML = function( elem ) {
1299	// documentElement is verified for cases where it doesn't yet exist
1300	// (such as loading iframes in IE - #4833)
1301	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1302	return documentElement ? documentElement.nodeName !== "HTML" : false;
1303};
1304
1305// Expose support vars for convenience
1306support = Sizzle.support = {};
1307
1308/**
1309 * Sets document-related variables once based on the current document
1310 * @param {Element|Object} [doc] An element or document object to use to set the document
1311 * @returns {Object} Returns the current document
1312 */
1313setDocument = Sizzle.setDocument = function( node ) {
1314	var doc = node ? node.ownerDocument || node : preferredDoc,
1315		parent = doc.defaultView;
1316
1317	// If no document and documentElement is available, return
1318	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1319		return document;
1320	}
1321
1322	// Set our document
1323	document = doc;
1324	docElem = doc.documentElement;
1325
1326	// Support tests
1327	documentIsHTML = !isXML( doc );
1328
1329	// Support: IE>8
1330	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
1331	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1332	// IE6-8 do not support the defaultView property so parent will be undefined
1333	if ( parent && parent.attachEvent && parent !== parent.top ) {
1334		parent.attachEvent( "onbeforeunload", function() {
1335			setDocument();
1336		});
1337	}
1338
1339	/* Attributes
1340	---------------------------------------------------------------------- */
1341
1342	// Support: IE<8
1343	// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
1344	support.attributes = assert(function( div ) {
1345		div.className = "i";
1346		return !div.getAttribute("className");
1347	});
1348
1349	/* getElement(s)By*
1350	---------------------------------------------------------------------- */
1351
1352	// Check if getElementsByTagName("*") returns only elements
1353	support.getElementsByTagName = assert(function( div ) {
1354		div.appendChild( doc.createComment("") );
1355		return !div.getElementsByTagName("*").length;
1356	});
1357
1358	// Check if getElementsByClassName can be trusted
1359	support.getElementsByClassName = assert(function( div ) {
1360		div.innerHTML = "<div class='a'></div><div class='a i'></div>";
1361
1362		// Support: Safari<4
1363		// Catch class over-caching
1364		div.firstChild.className = "i";
1365		// Support: Opera<10
1366		// Catch gEBCN failure to find non-leading classes
1367		return div.getElementsByClassName("i").length === 2;
1368	});
1369
1370	// Support: IE<10
1371	// Check if getElementById returns elements by name
1372	// The broken getElementById methods don't pick up programatically-set names,
1373	// so use a roundabout getElementsByName test
1374	support.getById = assert(function( div ) {
1375		docElem.appendChild( div ).id = expando;
1376		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
1377	});
1378
1379	// ID find and filter
1380	if ( support.getById ) {
1381		Expr.find["ID"] = function( id, context ) {
1382			if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
1383				var m = context.getElementById( id );
1384				// Check parentNode to catch when Blackberry 4.6 returns
1385				// nodes that are no longer in the document #6963
1386				return m && m.parentNode ? [m] : [];
1387			}
1388		};
1389		Expr.filter["ID"] = function( id ) {
1390			var attrId = id.replace( runescape, funescape );
1391			return function( elem ) {
1392				return elem.getAttribute("id") === attrId;
1393			};
1394		};
1395	} else {
1396		// Support: IE6/7
1397		// getElementById is not reliable as a find shortcut
1398		delete Expr.find["ID"];
1399
1400		Expr.filter["ID"] =  function( id ) {
1401			var attrId = id.replace( runescape, funescape );
1402			return function( elem ) {
1403				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1404				return node && node.value === attrId;
1405			};
1406		};
1407	}
1408
1409	// Tag
1410	Expr.find["TAG"] = support.getElementsByTagName ?
1411		function( tag, context ) {
1412			if ( typeof context.getElementsByTagName !== strundefined ) {
1413				return context.getElementsByTagName( tag );
1414			}
1415		} :
1416		function( tag, context ) {
1417			var elem,
1418				tmp = [],
1419				i = 0,
1420				results = context.getElementsByTagName( tag );
1421
1422			// Filter out possible comments
1423			if ( tag === "*" ) {
1424				while ( (elem = results[i++]) ) {
1425					if ( elem.nodeType === 1 ) {
1426						tmp.push( elem );
1427					}
1428				}
1429
1430				return tmp;
1431			}
1432			return results;
1433		};
1434
1435	// Class
1436	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1437		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1438			return context.getElementsByClassName( className );
1439		}
1440	};
1441
1442	/* QSA/matchesSelector
1443	---------------------------------------------------------------------- */
1444
1445	// QSA and matchesSelector support
1446
1447	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1448	rbuggyMatches = [];
1449
1450	// qSa(:focus) reports false when true (Chrome 21)
1451	// We allow this because of a bug in IE8/9 that throws an error
1452	// whenever `document.activeElement` is accessed on an iframe
1453	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1454	// See http://bugs.jquery.com/ticket/13378
1455	rbuggyQSA = [];
1456
1457	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1458		// Build QSA regex
1459		// Regex strategy adopted from Diego Perini
1460		assert(function( div ) {
1461			// Select is set to empty string on purpose
1462			// This is to test IE's treatment of not explicitly
1463			// setting a boolean content attribute,
1464			// since its presence should be enough
1465			// http://bugs.jquery.com/ticket/12359
1466			div.innerHTML = "<select><option selected=''></option></select>";
1467
1468			// Support: IE8
1469			// Boolean attributes and "value" are not treated correctly
1470			if ( !div.querySelectorAll("[selected]").length ) {
1471				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1472			}
1473
1474			// Webkit/Opera - :checked should return selected option elements
1475			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1476			// IE8 throws error here and will not see later tests
1477			if ( !div.querySelectorAll(":checked").length ) {
1478				rbuggyQSA.push(":checked");
1479			}
1480		});
1481
1482		assert(function( div ) {
1483
1484			// Support: Opera 10-12/IE8
1485			// ^= $= *= and empty values
1486			// Should not select anything
1487			// Support: Windows 8 Native Apps
1488			// The type attribute is restricted during .innerHTML assignment
1489			var input = doc.createElement("input");
1490			input.setAttribute( "type", "hidden" );
1491			div.appendChild( input ).setAttribute( "t", "" );
1492
1493			if ( div.querySelectorAll("[t^='']").length ) {
1494				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1495			}
1496
1497			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1498			// IE8 throws error here and will not see later tests
1499			if ( !div.querySelectorAll(":enabled").length ) {
1500				rbuggyQSA.push( ":enabled", ":disabled" );
1501			}
1502
1503			// Opera 10-11 does not throw on post-comma invalid pseudos
1504			div.querySelectorAll("*,:x");
1505			rbuggyQSA.push(",.*:");
1506		});
1507	}
1508
1509	if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
1510		docElem.mozMatchesSelector ||
1511		docElem.oMatchesSelector ||
1512		docElem.msMatchesSelector) )) ) {
1513
1514		assert(function( div ) {
1515			// Check to see if it's possible to do matchesSelector
1516			// on a disconnected node (IE 9)
1517			support.disconnectedMatch = matches.call( div, "div" );
1518
1519			// This should fail with an exception
1520			// Gecko does not error, returns false instead
1521			matches.call( div, "[s!='']:x" );
1522			rbuggyMatches.push( "!=", pseudos );
1523		});
1524	}
1525
1526	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1527	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1528
1529	/* Contains
1530	---------------------------------------------------------------------- */
1531
1532	// Element contains another
1533	// Purposefully does not implement inclusive descendent
1534	// As in, an element does not contain itself
1535	contains = rnative.test( docElem.contains ) || docElem.compareDocumentPosition ?
1536		function( a, b ) {
1537			var adown = a.nodeType === 9 ? a.documentElement : a,
1538				bup = b && b.parentNode;
1539			return a === bup || !!( bup && bup.nodeType === 1 && (
1540				adown.contains ?
1541					adown.contains( bup ) :
1542					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1543			));
1544		} :
1545		function( a, b ) {
1546			if ( b ) {
1547				while ( (b = b.parentNode) ) {
1548					if ( b === a ) {
1549						return true;
1550					}
1551				}
1552			}
1553			return false;
1554		};
1555
1556	/* Sorting
1557	---------------------------------------------------------------------- */
1558
1559	// Document order sorting
1560	sortOrder = docElem.compareDocumentPosition ?
1561	function( a, b ) {
1562
1563		// Flag for duplicate removal
1564		if ( a === b ) {
1565			hasDuplicate = true;
1566			return 0;
1567		}
1568
1569		var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b );
1570
1571		if ( compare ) {
1572			// Disconnected nodes
1573			if ( compare & 1 ||
1574				(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1575
1576				// Choose the first element that is related to our preferred document
1577				if ( a === doc || contains(preferredDoc, a) ) {
1578					return -1;
1579				}
1580				if ( b === doc || contains(preferredDoc, b) ) {
1581					return 1;
1582				}
1583
1584				// Maintain original order
1585				return sortInput ?
1586					( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1587					0;
1588			}
1589
1590			return compare & 4 ? -1 : 1;
1591		}
1592
1593		// Not directly comparable, sort on existence of method
1594		return a.compareDocumentPosition ? -1 : 1;
1595	} :
1596	function( a, b ) {
1597		var cur,
1598			i = 0,
1599			aup = a.parentNode,
1600			bup = b.parentNode,
1601			ap = [ a ],
1602			bp = [ b ];
1603
1604		// Exit early if the nodes are identical
1605		if ( a === b ) {
1606			hasDuplicate = true;
1607			return 0;
1608
1609		// Parentless nodes are either documents or disconnected
1610		} else if ( !aup || !bup ) {
1611			return a === doc ? -1 :
1612				b === doc ? 1 :
1613				aup ? -1 :
1614				bup ? 1 :
1615				sortInput ?
1616				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1617				0;
1618
1619		// If the nodes are siblings, we can do a quick check
1620		} else if ( aup === bup ) {
1621			return siblingCheck( a, b );
1622		}
1623
1624		// Otherwise we need full lists of their ancestors for comparison
1625		cur = a;
1626		while ( (cur = cur.parentNode) ) {
1627			ap.unshift( cur );
1628		}
1629		cur = b;
1630		while ( (cur = cur.parentNode) ) {
1631			bp.unshift( cur );
1632		}
1633
1634		// Walk down the tree looking for a discrepancy
1635		while ( ap[i] === bp[i] ) {
1636			i++;
1637		}
1638
1639		return i ?
1640			// Do a sibling check if the nodes have a common ancestor
1641			siblingCheck( ap[i], bp[i] ) :
1642
1643			// Otherwise nodes in our document sort first
1644			ap[i] === preferredDoc ? -1 :
1645			bp[i] === preferredDoc ? 1 :
1646			0;
1647	};
1648
1649	return doc;
1650};
1651
1652Sizzle.matches = function( expr, elements ) {
1653	return Sizzle( expr, null, null, elements );
1654};
1655
1656Sizzle.matchesSelector = function( elem, expr ) {
1657	// Set document vars if needed
1658	if ( ( elem.ownerDocument || elem ) !== document ) {
1659		setDocument( elem );
1660	}
1661
1662	// Make sure that attribute selectors are quoted
1663	expr = expr.replace( rattributeQuotes, "='$1']" );
1664
1665	if ( support.matchesSelector && documentIsHTML &&
1666		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1667		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1668
1669		try {
1670			var ret = matches.call( elem, expr );
1671
1672			// IE 9's matchesSelector returns false on disconnected nodes
1673			if ( ret || support.disconnectedMatch ||
1674					// As well, disconnected nodes are said to be in a document
1675					// fragment in IE 9
1676					elem.document && elem.document.nodeType !== 11 ) {
1677				return ret;
1678			}
1679		} catch(e) {}
1680	}
1681
1682	return Sizzle( expr, document, null, [elem] ).length > 0;
1683};
1684
1685Sizzle.contains = function( context, elem ) {
1686	// Set document vars if needed
1687	if ( ( context.ownerDocument || context ) !== document ) {
1688		setDocument( context );
1689	}
1690	return contains( context, elem );
1691};
1692
1693Sizzle.attr = function( elem, name ) {
1694	// Set document vars if needed
1695	if ( ( elem.ownerDocument || elem ) !== document ) {
1696		setDocument( elem );
1697	}
1698
1699	var fn = Expr.attrHandle[ name.toLowerCase() ],
1700		// Don't get fooled by Object.prototype properties (jQuery #13807)
1701		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1702			fn( elem, name, !documentIsHTML ) :
1703			undefined;
1704
1705	return val === undefined ?
1706		support.attributes || !documentIsHTML ?
1707			elem.getAttribute( name ) :
1708			(val = elem.getAttributeNode(name)) && val.specified ?
1709				val.value :
1710				null :
1711		val;
1712};
1713
1714Sizzle.error = function( msg ) {
1715	throw new Error( "Syntax error, unrecognized expression: " + msg );
1716};
1717
1718/**
1719 * Document sorting and removing duplicates
1720 * @param {ArrayLike} results
1721 */
1722Sizzle.uniqueSort = function( results ) {
1723	var elem,
1724		duplicates = [],
1725		j = 0,
1726		i = 0;
1727
1728	// Unless we *know* we can detect duplicates, assume their presence
1729	hasDuplicate = !support.detectDuplicates;
1730	sortInput = !support.sortStable && results.slice( 0 );
1731	results.sort( sortOrder );
1732
1733	if ( hasDuplicate ) {
1734		while ( (elem = results[i++]) ) {
1735			if ( elem === results[ i ] ) {
1736				j = duplicates.push( i );
1737			}
1738		}
1739		while ( j-- ) {
1740			results.splice( duplicates[ j ], 1 );
1741		}
1742	}
1743
1744	return results;
1745};
1746
1747/**
1748 * Utility function for retrieving the text value of an array of DOM nodes
1749 * @param {Array|Element} elem
1750 */
1751getText = Sizzle.getText = function( elem ) {
1752	var node,
1753		ret = "",
1754		i = 0,
1755		nodeType = elem.nodeType;
1756
1757	if ( !nodeType ) {
1758		// If no nodeType, this is expected to be an array
1759		for ( ; (node = elem[i]); i++ ) {
1760			// Do not traverse comment nodes
1761			ret += getText( node );
1762		}
1763	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1764		// Use textContent for elements
1765		// innerText usage removed for consistency of new lines (see #11153)
1766		if ( typeof elem.textContent === "string" ) {
1767			return elem.textContent;
1768		} else {
1769			// Traverse its children
1770			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1771				ret += getText( elem );
1772			}
1773		}
1774	} else if ( nodeType === 3 || nodeType === 4 ) {
1775		return elem.nodeValue;
1776	}
1777	// Do not include comment or processing instruction nodes
1778
1779	return ret;
1780};
1781
1782Expr = Sizzle.selectors = {
1783
1784	// Can be adjusted by the user
1785	cacheLength: 50,
1786
1787	createPseudo: markFunction,
1788
1789	match: matchExpr,
1790
1791	attrHandle: {},
1792
1793	find: {},
1794
1795	relative: {
1796		">": { dir: "parentNode", first: true },
1797		" ": { dir: "parentNode" },
1798		"+": { dir: "previousSibling", first: true },
1799		"~": { dir: "previousSibling" }
1800	},
1801
1802	preFilter: {
1803		"ATTR": function( match ) {
1804			match[1] = match[1].replace( runescape, funescape );
1805
1806			// Move the given value to match[3] whether quoted or unquoted
1807			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
1808
1809			if ( match[2] === "~=" ) {
1810				match[3] = " " + match[3] + " ";
1811			}
1812
1813			return match.slice( 0, 4 );
1814		},
1815
1816		"CHILD": function( match ) {
1817			/* matches from matchExpr["CHILD"]
1818				1 type (only|nth|...)
1819				2 what (child|of-type)
1820				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1821				4 xn-component of xn+y argument ([+-]?\d*n|)
1822				5 sign of xn-component
1823				6 x of xn-component
1824				7 sign of y-component
1825				8 y of y-component
1826			*/
1827			match[1] = match[1].toLowerCase();
1828
1829			if ( match[1].slice( 0, 3 ) === "nth" ) {
1830				// nth-* requires argument
1831				if ( !match[3] ) {
1832					Sizzle.error( match[0] );
1833				}
1834
1835				// numeric x and y parameters for Expr.filter.CHILD
1836				// remember that false/true cast respectively to 0/1
1837				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1838				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1839
1840			// other types prohibit arguments
1841			} else if ( match[3] ) {
1842				Sizzle.error( match[0] );
1843			}
1844
1845			return match;
1846		},
1847
1848		"PSEUDO": function( match ) {
1849			var excess,
1850				unquoted = !match[5] && match[2];
1851
1852			if ( matchExpr["CHILD"].test( match[0] ) ) {
1853				return null;
1854			}
1855
1856			// Accept quoted arguments as-is
1857			if ( match[3] && match[4] !== undefined ) {
1858				match[2] = match[4];
1859
1860			// Strip excess characters from unquoted arguments
1861			} else if ( unquoted && rpseudo.test( unquoted ) &&
1862				// Get excess from tokenize (recursively)
1863				(excess = tokenize( unquoted, true )) &&
1864				// advance to the next closing parenthesis
1865				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1866
1867				// excess is a negative index
1868				match[0] = match[0].slice( 0, excess );
1869				match[2] = unquoted.slice( 0, excess );
1870			}
1871
1872			// Return only captures needed by the pseudo filter method (type and argument)
1873			return match.slice( 0, 3 );
1874		}
1875	},
1876
1877	filter: {
1878
1879		"TAG": function( nodeNameSelector ) {
1880			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1881			return nodeNameSelector === "*" ?
1882				function() { return true; } :
1883				function( elem ) {
1884					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1885				};
1886		},
1887
1888		"CLASS": function( className ) {
1889			var pattern = classCache[ className + " " ];
1890
1891			return pattern ||
1892				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1893				classCache( className, function( elem ) {
1894					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
1895				});
1896		},
1897
1898		"ATTR": function( name, operator, check ) {
1899			return function( elem ) {
1900				var result = Sizzle.attr( elem, name );
1901
1902				if ( result == null ) {
1903					return operator === "!=";
1904				}
1905				if ( !operator ) {
1906					return true;
1907				}
1908
1909				result += "";
1910
1911				return operator === "=" ? result === check :
1912					operator === "!=" ? result !== check :
1913					operator === "^=" ? check && result.indexOf( check ) === 0 :
1914					operator === "*=" ? check && result.indexOf( check ) > -1 :
1915					operator === "$=" ? check && result.slice( -check.length ) === check :
1916					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
1917					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1918					false;
1919			};
1920		},
1921
1922		"CHILD": function( type, what, argument, first, last ) {
1923			var simple = type.slice( 0, 3 ) !== "nth",
1924				forward = type.slice( -4 ) !== "last",
1925				ofType = what === "of-type";
1926
1927			return first === 1 && last === 0 ?
1928
1929				// Shortcut for :nth-*(n)
1930				function( elem ) {
1931					return !!elem.parentNode;
1932				} :
1933
1934				function( elem, context, xml ) {
1935					var cache, outerCache, node, diff, nodeIndex, start,
1936						dir = simple !== forward ? "nextSibling" : "previousSibling",
1937						parent = elem.parentNode,
1938						name = ofType && elem.nodeName.toLowerCase(),
1939						useCache = !xml && !ofType;
1940
1941					if ( parent ) {
1942
1943						// :(first|last|only)-(child|of-type)
1944						if ( simple ) {
1945							while ( dir ) {
1946								node = elem;
1947								while ( (node = node[ dir ]) ) {
1948									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
1949										return false;
1950									}
1951								}
1952								// Reverse direction for :only-* (if we haven't yet done so)
1953								start = dir = type === "only" && !start && "nextSibling";
1954							}
1955							return true;
1956						}
1957
1958						start = [ forward ? parent.firstChild : parent.lastChild ];
1959
1960						// non-xml :nth-child(...) stores cache data on `parent`
1961						if ( forward && useCache ) {
1962							// Seek `elem` from a previously-cached index
1963							outerCache = parent[ expando ] || (parent[ expando ] = {});
1964							cache = outerCache[ type ] || [];
1965							nodeIndex = cache[0] === dirruns && cache[1];
1966							diff = cache[0] === dirruns && cache[2];
1967							node = nodeIndex && parent.childNodes[ nodeIndex ];
1968
1969							while ( (node = ++nodeIndex && node && node[ dir ] ||
1970
1971								// Fallback to seeking `elem` from the start
1972								(diff = nodeIndex = 0) || start.pop()) ) {
1973
1974								// When found, cache indexes on `parent` and break
1975								if ( node.nodeType === 1 && ++diff && node === elem ) {
1976									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1977									break;
1978								}
1979							}
1980
1981						// Use previously-cached element index if available
1982						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
1983							diff = cache[1];
1984
1985						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
1986						} else {
1987							// Use the same loop as above to seek `elem` from the start
1988							while ( (node = ++nodeIndex && node && node[ dir ] ||
1989								(diff = nodeIndex = 0) || start.pop()) ) {
1990
1991								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
1992									// Cache the index of each encountered element
1993									if ( useCache ) {
1994										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
1995									}
1996
1997									if ( node === elem ) {
1998										break;
1999									}
2000								}
2001							}
2002						}
2003
2004						// Incorporate the offset, then check against cycle size
2005						diff -= last;
2006						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2007					}
2008				};
2009		},
2010
2011		"PSEUDO": function( pseudo, argument ) {
2012			// pseudo-class names are case-insensitive
2013			// http://www.w3.org/TR/selectors/#pseudo-classes
2014			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2015			// Remember that setFilters inherits from pseudos
2016			var args,
2017				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2018					Sizzle.error( "unsupported pseudo: " + pseudo );
2019
2020			// The user may use createPseudo to indicate that
2021			// arguments are needed to create the filter function
2022			// just as Sizzle does
2023			if ( fn[ expando ] ) {
2024				return fn( argument );
2025			}
2026
2027			// But maintain support for old signatures
2028			if ( fn.length > 1 ) {
2029				args = [ pseudo, pseudo, "", argument ];
2030				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2031					markFunction(function( seed, matches ) {
2032						var idx,
2033							matched = fn( seed, argument ),
2034							i = matched.length;
2035						while ( i-- ) {
2036							idx = indexOf.call( seed, matched[i] );
2037							seed[ idx ] = !( matches[ idx ] = matched[i] );
2038						}
2039					}) :
2040					function( elem ) {
2041						return fn( elem, 0, args );
2042					};
2043			}
2044
2045			return fn;
2046		}
2047	},
2048
2049	pseudos: {
2050		// Potentially complex pseudos
2051		"not": markFunction(function( selector ) {
2052			// Trim the selector passed to compile
2053			// to avoid treating leading and trailing
2054			// spaces as combinators
2055			var input = [],
2056				results = [],
2057				matcher = compile( selector.replace( rtrim, "$1" ) );
2058
2059			return matcher[ expando ] ?
2060				markFunction(function( seed, matches, context, xml ) {
2061					var elem,
2062						unmatched = matcher( seed, null, xml, [] ),
2063						i = seed.length;
2064
2065					// Match elements unmatched by `matcher`
2066					while ( i-- ) {
2067						if ( (elem = unmatched[i]) ) {
2068							seed[i] = !(matches[i] = elem);
2069						}
2070					}
2071				}) :
2072				function( elem, context, xml ) {
2073					input[0] = elem;
2074					matcher( input, null, xml, results );
2075					return !results.pop();
2076				};
2077		}),
2078
2079		"has": markFunction(function( selector ) {
2080			return function( elem ) {
2081				return Sizzle( selector, elem ).length > 0;
2082			};
2083		}),
2084
2085		"contains": markFunction(function( text ) {
2086			return function( elem ) {
2087				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2088			};
2089		}),
2090
2091		// "Whether an element is represented by a :lang() selector
2092		// is based solely on the element's language value
2093		// being equal to the identifier C,
2094		// or beginning with the identifier C immediately followed by "-".
2095		// The matching of C against the element's language value is performed case-insensitively.
2096		// The identifier C does not have to be a valid language name."
2097		// http://www.w3.org/TR/selectors/#lang-pseudo
2098		"lang": markFunction( function( lang ) {
2099			// lang value must be a valid identifier
2100			if ( !ridentifier.test(lang || "") ) {
2101				Sizzle.error( "unsupported lang: " + lang );
2102			}
2103			lang = lang.replace( runescape, funescape ).toLowerCase();
2104			return function( elem ) {
2105				var elemLang;
2106				do {
2107					if ( (elemLang = documentIsHTML ?
2108						elem.lang :
2109						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2110
2111						elemLang = elemLang.toLowerCase();
2112						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2113					}
2114				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2115				return false;
2116			};
2117		}),
2118
2119		// Miscellaneous
2120		"target": function( elem ) {
2121			var hash = window.location && window.location.hash;
2122			return hash && hash.slice( 1 ) === elem.id;
2123		},
2124
2125		"root": function( elem ) {
2126			return elem === docElem;
2127		},
2128
2129		"focus": function( elem ) {
2130			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2131		},
2132
2133		// Boolean properties
2134		"enabled": function( elem ) {
2135			return elem.disabled === false;
2136		},
2137
2138		"disabled": function( elem ) {
2139			return elem.disabled === true;
2140		},
2141
2142		"checked": function( elem ) {
2143			// In CSS3, :checked should return both checked and selected elements
2144			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2145			var nodeName = elem.nodeName.toLowerCase();
2146			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2147		},
2148
2149		"selected": function( elem ) {
2150			// Accessing this property makes selected-by-default
2151			// options in Safari work properly
2152			if ( elem.parentNode ) {
2153				elem.parentNode.selectedIndex;
2154			}
2155
2156			return elem.selected === true;
2157		},
2158
2159		// Contents
2160		"empty": function( elem ) {
2161			// http://www.w3.org/TR/selectors/#empty-pseudo
2162			// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
2163			//   not comment, processing instructions, or others
2164			// Thanks to Diego Perini for the nodeName shortcut
2165			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
2166			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2167				if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
2168					return false;
2169				}
2170			}
2171			return true;
2172		},
2173
2174		"parent": function( elem ) {
2175			return !Expr.pseudos["empty"]( elem );
2176		},
2177
2178		// Element/input types
2179		"header": function( elem ) {
2180			return rheader.test( elem.nodeName );
2181		},
2182
2183		"input": function( elem ) {
2184			return rinputs.test( elem.nodeName );
2185		},
2186
2187		"button": function( elem ) {
2188			var name = elem.nodeName.toLowerCase();
2189			return name === "input" && elem.type === "button" || name === "button";
2190		},
2191
2192		"text": function( elem ) {
2193			var attr;
2194			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
2195			// use getAttribute instead to test this case
2196			return elem.nodeName.toLowerCase() === "input" &&
2197				elem.type === "text" &&
2198				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
2199		},
2200
2201		// Position-in-collection
2202		"first": createPositionalPseudo(function() {
2203			return [ 0 ];
2204		}),
2205
2206		"last": createPositionalPseudo(function( matchIndexes, length ) {
2207			return [ length - 1 ];
2208		}),
2209
2210		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2211			return [ argument < 0 ? argument + length : argument ];
2212		}),
2213
2214		"even": createPositionalPseudo(function( matchIndexes, length ) {
2215			var i = 0;
2216			for ( ; i < length; i += 2 ) {
2217				matchIndexes.push( i );
2218			}
2219			return matchIndexes;
2220		}),
2221
2222		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2223			var i = 1;
2224			for ( ; i < length; i += 2 ) {
2225				matchIndexes.push( i );
2226			}
2227			return matchIndexes;
2228		}),
2229
2230		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2231			var i = argument < 0 ? argument + length : argument;
2232			for ( ; --i >= 0; ) {
2233				matchIndexes.push( i );
2234			}
2235			return matchIndexes;
2236		}),
2237
2238		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2239			var i = argument < 0 ? argument + length : argument;
2240			for ( ; ++i < length; ) {
2241				matchIndexes.push( i );
2242			}
2243			return matchIndexes;
2244		})
2245	}
2246};
2247
2248Expr.pseudos["nth"] = Expr.pseudos["eq"];
2249
2250// Add button/input type pseudos
2251for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2252	Expr.pseudos[ i ] = createInputPseudo( i );
2253}
2254for ( i in { submit: true, reset: true } ) {
2255	Expr.pseudos[ i ] = createButtonPseudo( i );
2256}
2257
2258// Easy API for creating new setFilters
2259function setFilters() {}
2260setFilters.prototype = Expr.filters = Expr.pseudos;
2261Expr.setFilters = new setFilters();
2262
2263function tokenize( selector, parseOnly ) {
2264	var matched, match, tokens, type,
2265		soFar, groups, preFilters,
2266		cached = tokenCache[ selector + " " ];
2267
2268	if ( cached ) {
2269		return parseOnly ? 0 : cached.slice( 0 );
2270	}
2271
2272	soFar = selector;
2273	groups = [];
2274	preFilters = Expr.preFilter;
2275
2276	while ( soFar ) {
2277
2278		// Comma and first run
2279		if ( !matched || (match = rcomma.exec( soFar )) ) {
2280			if ( match ) {
2281				// Don't consume trailing commas as valid
2282				soFar = soFar.slice( match[0].length ) || soFar;
2283			}
2284			groups.push( tokens = [] );
2285		}
2286
2287		matched = false;
2288
2289		// Combinators
2290		if ( (match = rcombinators.exec( soFar )) ) {
2291			matched = match.shift();
2292			tokens.push({
2293				value: matched,
2294				// Cast descendant combinators to space
2295				type: match[0].replace( rtrim, " " )
2296			});
2297			soFar = soFar.slice( matched.length );
2298		}
2299
2300		// Filters
2301		for ( type in Expr.filter ) {
2302			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2303				(match = preFilters[ type ]( match ))) ) {
2304				matched = match.shift();
2305				tokens.push({
2306					value: matched,
2307					type: type,
2308					matches: match
2309				});
2310				soFar = soFar.slice( matched.length );
2311			}
2312		}
2313
2314		if ( !matched ) {
2315			break;
2316		}
2317	}
2318
2319	// Return the length of the invalid excess
2320	// if we're just parsing
2321	// Otherwise, throw an error or return tokens
2322	return parseOnly ?
2323		soFar.length :
2324		soFar ?
2325			Sizzle.error( selector ) :
2326			// Cache the tokens
2327			tokenCache( selector, groups ).slice( 0 );
2328}
2329
2330function toSelector( tokens ) {
2331	var i = 0,
2332		len = tokens.length,
2333		selector = "";
2334	for ( ; i < len; i++ ) {
2335		selector += tokens[i].value;
2336	}
2337	return selector;
2338}
2339
2340function addCombinator( matcher, combinator, base ) {
2341	var dir = combinator.dir,
2342		checkNonElements = base && dir === "parentNode",
2343		doneName = done++;
2344
2345	return combinator.first ?
2346		// Check against closest ancestor/preceding element
2347		function( elem, context, xml ) {
2348			while ( (elem = elem[ dir ]) ) {
2349				if ( elem.nodeType === 1 || checkNonElements ) {
2350					return matcher( elem, context, xml );
2351				}
2352			}
2353		} :
2354
2355		// Check against all ancestor/preceding elements
2356		function( elem, context, xml ) {
2357			var data, cache, outerCache,
2358				dirkey = dirruns + " " + doneName;
2359
2360			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2361			if ( xml ) {
2362				while ( (elem = elem[ dir ]) ) {
2363					if ( elem.nodeType === 1 || checkNonElements ) {
2364						if ( matcher( elem, context, xml ) ) {
2365							return true;
2366						}
2367					}
2368				}
2369			} else {
2370				while ( (elem = elem[ dir ]) ) {
2371					if ( elem.nodeType === 1 || checkNonElements ) {
2372						outerCache = elem[ expando ] || (elem[ expando ] = {});
2373						if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
2374							if ( (data = cache[1]) === true || data === cachedruns ) {
2375								return data === true;
2376							}
2377						} else {
2378							cache = outerCache[ dir ] = [ dirkey ];
2379							cache[1] = matcher( elem, context, xml ) || cachedruns;
2380							if ( cache[1] === true ) {
2381								return true;
2382							}
2383						}
2384					}
2385				}
2386			}
2387		};
2388}
2389
2390function elementMatcher( matchers ) {
2391	return matchers.length > 1 ?
2392		function( elem, context, xml ) {
2393			var i = matchers.length;
2394			while ( i-- ) {
2395				if ( !matchers[i]( elem, context, xml ) ) {
2396					return false;
2397				}
2398			}
2399			return true;
2400		} :
2401		matchers[0];
2402}
2403
2404function condense( unmatched, map, filter, context, xml ) {
2405	var elem,
2406		newUnmatched = [],
2407		i = 0,
2408		len = unmatched.length,
2409		mapped = map != null;
2410
2411	for ( ; i < len; i++ ) {
2412		if ( (elem = unmatched[i]) ) {
2413			if ( !filter || filter( elem, context, xml ) ) {
2414				newUnmatched.push( elem );
2415				if ( mapped ) {
2416					map.push( i );
2417				}
2418			}
2419		}
2420	}
2421
2422	return newUnmatched;
2423}
2424
2425function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2426	if ( postFilter && !postFilter[ expando ] ) {
2427		postFilter = setMatcher( postFilter );
2428	}
2429	if ( postFinder && !postFinder[ expando ] ) {
2430		postFinder = setMatcher( postFinder, postSelector );
2431	}
2432	return markFunction(function( seed, results, context, xml ) {
2433		var temp, i, elem,
2434			preMap = [],
2435			postMap = [],
2436			preexisting = results.length,
2437
2438			// Get initial elements from seed or context
2439			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2440
2441			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2442			matcherIn = preFilter && ( seed || !selector ) ?
2443				condense( elems, preMap, preFilter, context, xml ) :
2444				elems,
2445
2446			matcherOut = matcher ?
2447				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2448				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2449
2450					// ...intermediate processing is necessary
2451					[] :
2452
2453					// ...otherwise use results directly
2454					results :
2455				matcherIn;
2456
2457		// Find primary matches
2458		if ( matcher ) {
2459			matcher( matcherIn, matcherOut, context, xml );
2460		}
2461
2462		// Apply postFilter
2463		if ( postFilter ) {
2464			temp = condense( matcherOut, postMap );
2465			postFilter( temp, [], context, xml );
2466
2467			// Un-match failing elements by moving them back to matcherIn
2468			i = temp.length;
2469			while ( i-- ) {
2470				if ( (elem = temp[i]) ) {
2471					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2472				}
2473			}
2474		}
2475
2476		if ( seed ) {
2477			if ( postFinder || preFilter ) {
2478				if ( postFinder ) {
2479					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2480					temp = [];
2481					i = matcherOut.length;
2482					while ( i-- ) {
2483						if ( (elem = matcherOut[i]) ) {
2484							// Restore matcherIn since elem is not yet a final match
2485							temp.push( (matcherIn[i] = elem) );
2486						}
2487					}
2488					postFinder( null, (matcherOut = []), temp, xml );
2489				}
2490
2491				// Move matched elements from seed to results to keep them synchronized
2492				i = matcherOut.length;
2493				while ( i-- ) {
2494					if ( (elem = matcherOut[i]) &&
2495						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2496
2497						seed[temp] = !(results[temp] = elem);
2498					}
2499				}
2500			}
2501
2502		// Add elements to results, through postFinder if defined
2503		} else {
2504			matcherOut = condense(
2505				matcherOut === results ?
2506					matcherOut.splice( preexisting, matcherOut.length ) :
2507					matcherOut
2508			);
2509			if ( postFinder ) {
2510				postFinder( null, results, matcherOut, xml );
2511			} else {
2512				push.apply( results, matcherOut );
2513			}
2514		}
2515	});
2516}
2517
2518function matcherFromTokens( tokens ) {
2519	var checkContext, matcher, j,
2520		len = tokens.length,
2521		leadingRelative = Expr.relative[ tokens[0].type ],
2522		implicitRelative = leadingRelative || Expr.relative[" "],
2523		i = leadingRelative ? 1 : 0,
2524
2525		// The foundational matcher ensures that elements are reachable from top-level context(s)
2526		matchContext = addCombinator( function( elem ) {
2527			return elem === checkContext;
2528		}, implicitRelative, true ),
2529		matchAnyContext = addCombinator( function( elem ) {
2530			return indexOf.call( checkContext, elem ) > -1;
2531		}, implicitRelative, true ),
2532		matchers = [ function( elem, context, xml ) {
2533			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2534				(checkContext = context).nodeType ?
2535					matchContext( elem, context, xml ) :
2536					matchAnyContext( elem, context, xml ) );
2537		} ];
2538
2539	for ( ; i < len; i++ ) {
2540		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2541			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2542		} else {
2543			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2544
2545			// Return special upon seeing a positional matcher
2546			if ( matcher[ expando ] ) {
2547				// Find the next relative operator (if any) for proper handling
2548				j = ++i;
2549				for ( ; j < len; j++ ) {
2550					if ( Expr.relative[ tokens[j].type ] ) {
2551						break;
2552					}
2553				}
2554				return setMatcher(
2555					i > 1 && elementMatcher( matchers ),
2556					i > 1 && toSelector(
2557						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2558						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2559					).replace( rtrim, "$1" ),
2560					matcher,
2561					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2562					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2563					j < len && toSelector( tokens )
2564				);
2565			}
2566			matchers.push( matcher );
2567		}
2568	}
2569
2570	return elementMatcher( matchers );
2571}
2572
2573function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2574	// A counter to specify which element is currently being matched
2575	var matcherCachedRuns = 0,
2576		bySet = setMatchers.length > 0,
2577		byElement = elementMatchers.length > 0,
2578		superMatcher = function( seed, context, xml, results, expandContext ) {
2579			var elem, j, matcher,
2580				setMatched = [],
2581				matchedCount = 0,
2582				i = "0",
2583				unmatched = seed && [],
2584				outermost = expandContext != null,
2585				contextBackup = outermostContext,
2586				// We must always have either seed elements or context
2587				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
2588				// Use integer dirruns iff this is the outermost matcher
2589				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
2590
2591			if ( outermost ) {
2592				outermostContext = context !== document && context;
2593				cachedruns = matcherCachedRuns;
2594			}
2595
2596			// Add elements passing elementMatchers directly to results
2597			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2598			for ( ; (elem = elems[i]) != null; i++ ) {
2599				if ( byElement && elem ) {
2600					j = 0;
2601					while ( (matcher = elementMatchers[j++]) ) {
2602						if ( matcher( elem, context, xml ) ) {
2603							results.push( elem );
2604							break;
2605						}
2606					}
2607					if ( outermost ) {
2608						dirruns = dirrunsUnique;
2609						cachedruns = ++matcherCachedRuns;
2610					}
2611				}
2612
2613				// Track unmatched elements for set filters
2614				if ( bySet ) {
2615					// They will have gone through all possible matchers
2616					if ( (elem = !matcher && elem) ) {
2617						matchedCount--;
2618					}
2619
2620					// Lengthen the array for every element, matched or not
2621					if ( seed ) {
2622						unmatched.push( elem );
2623					}
2624				}
2625			}
2626
2627			// Apply set filters to unmatched elements
2628			matchedCount += i;
2629			if ( bySet && i !== matchedCount ) {
2630				j = 0;
2631				while ( (matcher = setMatchers[j++]) ) {
2632					matcher( unmatched, setMatched, context, xml );
2633				}
2634
2635				if ( seed ) {
2636					// Reintegrate element matches to eliminate the need for sorting
2637					if ( matchedCount > 0 ) {
2638						while ( i-- ) {
2639							if ( !(unmatched[i] || setMatched[i]) ) {
2640								setMatched[i] = pop.call( results );
2641							}
2642						}
2643					}
2644
2645					// Discard index placeholder values to get only actual matches
2646					setMatched = condense( setMatched );
2647				}
2648
2649				// Add matches to results
2650				push.apply( results, setMatched );
2651
2652				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2653				if ( outermost && !seed && setMatched.length > 0 &&
2654					( matchedCount + setMatchers.length ) > 1 ) {
2655
2656					Sizzle.uniqueSort( results );
2657				}
2658			}
2659
2660			// Override manipulation of globals by nested matchers
2661			if ( outermost ) {
2662				dirruns = dirrunsUnique;
2663				outermostContext = contextBackup;
2664			}
2665
2666			return unmatched;
2667		};
2668
2669	return bySet ?
2670		markFunction( superMatcher ) :
2671		superMatcher;
2672}
2673
2674compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
2675	var i,
2676		setMatchers = [],
2677		elementMatchers = [],
2678		cached = compilerCache[ selector + " " ];
2679
2680	if ( !cached ) {
2681		// Generate a function of recursive functions that can be used to check each element
2682		if ( !group ) {
2683			group = tokenize( selector );
2684		}
2685		i = group.length;
2686		while ( i-- ) {
2687			cached = matcherFromTokens( group[i] );
2688			if ( cached[ expando ] ) {
2689				setMatchers.push( cached );
2690			} else {
2691				elementMatchers.push( cached );
2692			}
2693		}
2694
2695		// Cache the compiled function
2696		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2697	}
2698	return cached;
2699};
2700
2701function multipleContexts( selector, contexts, results ) {
2702	var i = 0,
2703		len = contexts.length;
2704	for ( ; i < len; i++ ) {
2705		Sizzle( selector, contexts[i], results );
2706	}
2707	return results;
2708}
2709
2710function select( selector, context, results, seed ) {
2711	var i, tokens, token, type, find,
2712		match = tokenize( selector );
2713
2714	if ( !seed ) {
2715		// Try to minimize operations if there is only one group
2716		if ( match.length === 1 ) {
2717
2718			// Take a shortcut and set the context if the root selector is an ID
2719			tokens = match[0] = match[0].slice( 0 );
2720			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2721					support.getById && context.nodeType === 9 && documentIsHTML &&
2722					Expr.relative[ tokens[1].type ] ) {
2723
2724				context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2725				if ( !context ) {
2726					return results;
2727				}
2728				selector = selector.slice( tokens.shift().value.length );
2729			}
2730
2731			// Fetch a seed set for right-to-left matching
2732			i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2733			while ( i-- ) {
2734				token = tokens[i];
2735
2736				// Abort if we hit a combinator
2737				if ( Expr.relative[ (type = token.type) ] ) {
2738					break;
2739				}
2740				if ( (find = Expr.find[ type ]) ) {
2741					// Search, expanding context for leading sibling combinators
2742					if ( (seed = find(
2743						token.matches[0].replace( runescape, funescape ),
2744						rsibling.test( tokens[0].type ) && context.parentNode || context
2745					)) ) {
2746
2747						// If seed is empty or no tokens remain, we can return early
2748						tokens.splice( i, 1 );
2749						selector = seed.length && toSelector( tokens );
2750						if ( !selector ) {
2751							push.apply( results, seed );
2752							return results;
2753						}
2754
2755						break;
2756					}
2757				}
2758			}
2759		}
2760	}
2761
2762	// Compile and execute a filtering function
2763	// Provide `match` to avoid retokenization if we modified the selector above
2764	compile( selector, match )(
2765		seed,
2766		context,
2767		!documentIsHTML,
2768		results,
2769		rsibling.test( selector )
2770	);
2771	return results;
2772}
2773
2774// One-time assignments
2775
2776// Sort stability
2777support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2778
2779// Support: Chrome<14
2780// Always assume duplicates if they aren't passed to the comparison function
2781support.detectDuplicates = hasDuplicate;
2782
2783// Initialize against the default document
2784setDocument();
2785
2786// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2787// Detached nodes confoundingly follow *each other*
2788support.sortDetached = assert(function( div1 ) {
2789	// Should return 1, but returns 4 (following)
2790	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2791});
2792
2793// Support: IE<8
2794// Prevent attribute/property "interpolation"
2795// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2796if ( !assert(function( div ) {
2797	div.innerHTML = "<a href='#'></a>";
2798	return div.firstChild.getAttribute("href") === "#" ;
2799}) ) {
2800	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2801		if ( !isXML ) {
2802			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2803		}
2804	});
2805}
2806
2807// Support: IE<9
2808// Use defaultValue in place of getAttribute("value")
2809if ( !support.attributes || !assert(function( div ) {
2810	div.innerHTML = "<input/>";
2811	div.firstChild.setAttribute( "value", "" );
2812	return div.firstChild.getAttribute( "value" ) === "";
2813}) ) {
2814	addHandle( "value", function( elem, name, isXML ) {
2815		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2816			return elem.defaultValue;
2817		}
2818	});
2819}
2820
2821// Support: IE<9
2822// Use getAttributeNode to fetch booleans when getAttribute lies
2823if ( !assert(function( div ) {
2824	return div.getAttribute("disabled") == null;
2825}) ) {
2826	addHandle( booleans, function( elem, name, isXML ) {
2827		var val;
2828		if ( !isXML ) {
2829			return (val = elem.getAttributeNode( name )) && val.specified ?
2830				val.value :
2831				elem[ name ] === true ? name.toLowerCase() : null;
2832		}
2833	});
2834}
2835
2836jQuery.find = Sizzle;
2837jQuery.expr = Sizzle.selectors;
2838jQuery.expr[":"] = jQuery.expr.pseudos;
2839jQuery.unique = Sizzle.uniqueSort;
2840jQuery.text = Sizzle.getText;
2841jQuery.isXMLDoc = Sizzle.isXML;
2842jQuery.contains = Sizzle.contains;
2843
2844
2845})( window );
2846// String to Object options format cache
2847var optionsCache = {};
2848
2849// Convert String-formatted options into Object-formatted ones and store in cache
2850function createOptions( options ) {
2851	var object = optionsCache[ options ] = {};
2852	jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
2853		object[ flag ] = true;
2854	});
2855	return object;
2856}
2857
2858/*
2859 * Create a callback list using the following parameters:
2860 *
2861 *	options: an optional list of space-separated options that will change how
2862 *			the callback list behaves or a more traditional option object
2863 *
2864 * By default a callback list will act like an event callback list and can be
2865 * "fired" multiple times.
2866 *
2867 * Possible options:
2868 *
2869 *	once:			will ensure the callback list can only be fired once (like a Deferred)
2870 *
2871 *	memory:			will keep track of previous values and will call any callback added
2872 *					after the list has been fired right away with the latest "memorized"
2873 *					values (like a Deferred)
2874 *
2875 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
2876 *
2877 *	stopOnFalse:	interrupt callings when a callback returns false
2878 *
2879 */
2880jQuery.Callbacks = function( options ) {
2881
2882	// Convert options from String-formatted to Object-formatted if needed
2883	// (we check in cache first)
2884	options = typeof options === "string" ?
2885		( optionsCache[ options ] || createOptions( options ) ) :
2886		jQuery.extend( {}, options );
2887
2888	var // Last fire value (for non-forgettable lists)
2889		memory,
2890		// Flag to know if list was already fired
2891		fired,
2892		// Flag to know if list is currently firing
2893		firing,
2894		// First callback to fire (used internally by add and fireWith)
2895		firingStart,
2896		// End of the loop when firing
2897		firingLength,
2898		// Index of currently firing callback (modified by remove if needed)
2899		firingIndex,
2900		// Actual callback list
2901		list = [],
2902		// Stack of fire calls for repeatable lists
2903		stack = !options.once && [],
2904		// Fire callbacks
2905		fire = function( data ) {
2906			memory = options.memory && data;
2907			fired = true;
2908			firingIndex = firingStart || 0;
2909			firingStart = 0;
2910			firingLength = list.length;
2911			firing = true;
2912			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
2913				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
2914					memory = false; // To prevent further calls using add
2915					break;
2916				}
2917			}
2918			firing = false;
2919			if ( list ) {
2920				if ( stack ) {
2921					if ( stack.length ) {
2922						fire( stack.shift() );
2923					}
2924				} else if ( memory ) {
2925					list = [];
2926				} else {
2927					self.disable();
2928				}
2929			}
2930		},
2931		// Actual Callbacks object
2932		self = {
2933			// Add a callback or a collection of callbacks to the list
2934			add: function() {
2935				if ( list ) {
2936					// First, we save the current length
2937					var start = list.length;
2938					(function add( args ) {
2939						jQuery.each( args, function( _, arg ) {
2940							var type = jQuery.type( arg );
2941							if ( type === "function" ) {
2942								if ( !options.unique || !self.has( arg ) ) {
2943									list.push( arg );
2944								}
2945							} else if ( arg && arg.length && type !== "string" ) {
2946								// Inspect recursively
2947								add( arg );
2948							}
2949						});
2950					})( arguments );
2951					// Do we need to add the callbacks to the
2952					// current firing batch?
2953					if ( firing ) {
2954						firingLength = list.length;
2955					// With memory, if we're not firing then
2956					// we should call right away
2957					} else if ( memory ) {
2958						firingStart = start;
2959						fire( memory );
2960					}
2961				}
2962				return this;
2963			},
2964			// Remove a callback from the list
2965			remove: function() {
2966				if ( list ) {
2967					jQuery.each( arguments, function( _, arg ) {
2968						var index;
2969						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
2970							list.splice( index, 1 );
2971							// Handle firing indexes
2972							if ( firing ) {
2973								if ( index <= firingLength ) {
2974									firingLength--;
2975								}
2976								if ( index <= firingIndex ) {
2977									firingIndex--;
2978								}
2979							}
2980						}
2981					});
2982				}
2983				return this;
2984			},
2985			// Check if a given callback is in the list.
2986			// If no argument is given, return whether or not list has callbacks attached.
2987			has: function( fn ) {
2988				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
2989			},
2990			// Remove all callbacks from the list
2991			empty: function() {
2992				list = [];
2993				firingLength = 0;
2994				return this;
2995			},
2996			// Have the list do nothing anymore
2997			disable: function() {
2998				list = stack = memory = undefined;
2999				return this;
3000			},
3001			// Is it disabled?
3002			disabled: function() {
3003				return !list;
3004			},
3005			// Lock the list in its current state
3006			lock: function() {
3007				stack = undefined;
3008				if ( !memory ) {
3009					self.disable();
3010				}
3011				return this;
3012			},
3013			// Is it locked?
3014			locked: function() {
3015				return !stack;
3016			},
3017			// Call all callbacks with the given context and arguments
3018			fireWith: function( context, args ) {
3019				if ( list && ( !fired || stack ) ) {
3020					args = args || [];
3021					args = [ context, args.slice ? args.slice() : args ];
3022					if ( firing ) {
3023						stack.push( args );
3024					} else {
3025						fire( args );
3026					}
3027				}
3028				return this;
3029			},
3030			// Call all the callbacks with the given arguments
3031			fire: function() {
3032				self.fireWith( this, arguments );
3033				return this;
3034			},
3035			// To know if the callbacks have already been called at least once
3036			fired: function() {
3037				return !!fired;
3038			}
3039		};
3040
3041	return self;
3042};
3043jQuery.extend({
3044
3045	Deferred: function( func ) {
3046		var tuples = [
3047				// action, add listener, listener list, final state
3048				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
3049				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
3050				[ "notify", "progress", jQuery.Callbacks("memory") ]
3051			],
3052			state = "pending",
3053			promise = {
3054				state: function() {
3055					return state;
3056				},
3057				always: function() {
3058					deferred.done( arguments ).fail( arguments );
3059					return this;
3060				},
3061				then: function( /* fnDone, fnFail, fnProgress */ ) {
3062					var fns = arguments;
3063					return jQuery.Deferred(function( newDefer ) {
3064						jQuery.each( tuples, function( i, tuple ) {
3065							var action = tuple[ 0 ],
3066								fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3067							// deferred[ done | fail | progress ] for forwarding actions to newDefer
3068							deferred[ tuple[1] ](function() {
3069								var returned = fn && fn.apply( this, arguments );
3070								if ( returned && jQuery.isFunction( returned.promise ) ) {
3071									returned.promise()
3072										.done( newDefer.resolve )
3073										.fail( newDefer.reject )
3074										.progress( newDefer.notify );
3075								} else {
3076									newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
3077								}
3078							});
3079						});
3080						fns = null;
3081					}).promise();
3082				},
3083				// Get a promise for this deferred
3084				// If obj is provided, the promise aspect is added to the object
3085				promise: function( obj ) {
3086					return obj != null ? jQuery.extend( obj, promise ) : promise;
3087				}
3088			},
3089			deferred = {};
3090
3091		// Keep pipe for back-compat
3092		promise.pipe = promise.then;
3093
3094		// Add list-specific methods
3095		jQuery.each( tuples, function( i, tuple ) {
3096			var list = tuple[ 2 ],
3097				stateString = tuple[ 3 ];
3098
3099			// promise[ done | fail | progress ] = list.add
3100			promise[ tuple[1] ] = list.add;
3101
3102			// Handle state
3103			if ( stateString ) {
3104				list.add(function() {
3105					// state = [ resolved | rejected ]
3106					state = stateString;
3107
3108				// [ reject_list | resolve_list ].disable; progress_list.lock
3109				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3110			}
3111
3112			// deferred[ resolve | reject | notify ]
3113			deferred[ tuple[0] ] = function() {
3114				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
3115				return this;
3116			};
3117			deferred[ tuple[0] + "With" ] = list.fireWith;
3118		});
3119
3120		// Make the deferred a promise
3121		promise.promise( deferred );
3122
3123		// Call given func if any
3124		if ( func ) {
3125			func.call( deferred, deferred );
3126		}
3127
3128		// All done!
3129		return deferred;
3130	},
3131
3132	// Deferred helper
3133	when: function( subordinate /* , ..., subordinateN */ ) {
3134		var i = 0,
3135			resolveValues = core_slice.call( arguments ),
3136			length = resolveValues.length,
3137
3138			// the count of uncompleted subordinates
3139			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
3140
3141			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
3142			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
3143
3144			// Update function for both resolve and progress values
3145			updateFunc = function( i, contexts, values ) {
3146				return function( value ) {
3147					contexts[ i ] = this;
3148					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
3149					if( values === progressValues ) {
3150						deferred.notifyWith( contexts, values );
3151					} else if ( !( --remaining ) ) {
3152						deferred.resolveWith( contexts, values );
3153					}
3154				};
3155			},
3156
3157			progressValues, progressContexts, resolveContexts;
3158
3159		// add listeners to Deferred subordinates; treat others as resolved
3160		if ( length > 1 ) {
3161			progressValues = new Array( length );
3162			progressContexts = new Array( length );
3163			resolveContexts = new Array( length );
3164			for ( ; i < length; i++ ) {
3165				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
3166					resolveValues[ i ].promise()
3167						.done( updateFunc( i, resolveContexts, resolveValues ) )
3168						.fail( deferred.reject )
3169						.progress( updateFunc( i, progressContexts, progressValues ) );
3170				} else {
3171					--remaining;
3172				}
3173			}
3174		}
3175
3176		// if we're not waiting on anything, resolve the master
3177		if ( !remaining ) {